diff --git a/.github/workflows/bindings.yml b/.github/workflows/bindings.yml index 15b0eeee6c..f34bd26b43 100644 --- a/.github/workflows/bindings.yml +++ b/.github/workflows/bindings.yml @@ -154,3 +154,36 @@ jobs: # Release example requires iota-sdk-swift package to be published first # - name: Run the release example # run: make swift-release-example + + typescript: + if: (!cancelled() && needs.diff.outputs.isBindings == 'true') + needs: diff + runs-on: ubuntu-latest + steps: + - name: Checkout repository + uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0 + - name: Install uniffi-bindgen-node (patched for UniFFI 0.29) + run: | + git clone https://github.com/livekit/uniffi-bindgen-node.git /tmp/uniffi-bindgen-node + cd /tmp/uniffi-bindgen-node + git checkout 9faabc2d6841498789d4d6737cae57e7a1c0f069 + git apply $GITHUB_WORKSPACE/bindings/typescript/uniffi-bindgen-node-0.29.patch + cargo install --path . + - name: Setup Node.js + uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0 + with: + node-version: "22" + - name: Install dependencies + run: cd bindings/typescript && npm install + - name: Build the bindings + run: make typescript + - name: Checks for uncommitted changes + run: git diff --exit-code + - name: Check format of the examples + run: make typescript-examples-format-check + - uses: ./.github/actions/start-local-network + - name: Run the examples + run: make typescript-examples + # Release example requires @iota/sdk package to be published first + # - name: Run the release example + # run: make typescript-release-example diff --git a/.github/workflows/typescript_publish.yml b/.github/workflows/typescript_publish.yml new file mode 100644 index 0000000000..225ff336c2 --- /dev/null +++ b/.github/workflows/typescript_publish.yml @@ -0,0 +1,126 @@ +name: Publish TypeScript SDK to npm + +on: + release: + types: [published] + workflow_dispatch: + inputs: + test_publish: + description: "Publish to npm with --dry-run only" + required: false + default: true + type: boolean + +permissions: + contents: read + +jobs: + build: + if: (github.event_name == 'release' && startsWith(github.event.release.tag_name, 'iota-typescript-sdk')) || github.event_name == 'workflow_dispatch' + runs-on: ${{ matrix.os }} + strategy: + matrix: + include: + - os: ubuntu-latest + target: x86_64-unknown-linux-gnu + lib: libiota_sdk_ffi.so + folder: linux-x64 + - os: ubuntu-latest + target: aarch64-unknown-linux-gnu + lib: libiota_sdk_ffi.so + folder: linux-arm64 + - os: macos-latest + target: x86_64-apple-darwin + lib: libiota_sdk_ffi.dylib + folder: darwin-x64 + - os: macos-latest + target: aarch64-apple-darwin + lib: libiota_sdk_ffi.dylib + folder: darwin-arm64 + - os: windows-latest + target: x86_64-pc-windows-msvc + lib: iota_sdk_ffi.dll + folder: win32-x64 + - os: windows-latest + target: aarch64-pc-windows-msvc + lib: iota_sdk_ffi.dll + folder: win32-arm64 + steps: + - name: Checkout iota-rust-sdk + uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0 + with: + ref: ${{ github.event.release.tag_name || github.ref }} + + - name: Install Rust + uses: dtolnay/rust-toolchain@0f44b27771c32bda9f458f75a1e241b09791b331 + with: + targets: ${{ matrix.target }} + toolchain: stable + + - name: Install cross-compilation tools + if: matrix.target == 'aarch64-unknown-linux-gnu' + run: sudo apt-get update && sudo apt-get install -y gcc-aarch64-linux-gnu g++-aarch64-linux-gnu + + - name: Build ${{ matrix.os }} ${{ matrix.target }} library + if: matrix.os == 'macos-latest' + run: RUSTFLAGS="-C link-args=-Wl,-install_name,@rpath/${{ matrix.lib }}" cargo build -p iota-sdk-ffi --lib --release --target ${{ matrix.target }} + + - name: Build ${{ matrix.os }} ${{ matrix.target }} library + if: matrix.os == 'ubuntu-latest' + env: + CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER: /usr/bin/aarch64-linux-gnu-gcc + CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER: /usr/bin/x86_64-linux-gnu-gcc + run: RUSTFLAGS="-C link-args=-Wl,-rpath,$ORIGIN" cargo build -p iota-sdk-ffi --lib --release --target ${{ matrix.target }} + + - name: Build ${{ matrix.os }} ${{ matrix.target }} library + if: matrix.os == 'windows-latest' + run: cargo build -p iota-sdk-ffi --lib --release --target ${{ matrix.target }} + + - name: Prepare library archive + run: | + mkdir -p tmp/lib/${{ matrix.folder }} + cp target/${{ matrix.target }}/release/${{ matrix.lib }} tmp/lib/${{ matrix.folder }}/${{ matrix.lib }} + + - name: Upload native library + uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0 + with: + name: native-lib-${{ matrix.target }} + path: tmp + + publish: + runs-on: ubuntu-latest + needs: build + steps: + - name: Checkout repository + uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0 + with: + ref: ${{ github.event.release.tag_name || github.ref }} + + - name: Setup Node.js + uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0 + with: + node-version: "22" + registry-url: "https://registry.npmjs.org" + + - name: Download native libraries + uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0 + with: + path: bindings/typescript/lib + pattern: native-lib-* + merge-multiple: true + + - name: Dry run publish + if: github.event_name == 'workflow_dispatch' && inputs.test_publish == true + run: | + cd bindings/typescript + npm publish --dry-run + env: + NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} + + - name: Publish to npm + if: github.event_name == 'release' || (github.event_name == 'workflow_dispatch' && inputs.test_publish == false) + run: | + cd bindings/typescript + npm publish --access public + env: + NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} diff --git a/Makefile b/Makefile index ee506a2cff..f97b5b7ebf 100644 --- a/Makefile +++ b/Makefile @@ -79,6 +79,7 @@ bindings: ## Build all bindings @$(MAKE) python @$(MAKE) csharp @$(MAKE) swift + @$(MAKE) typescript .PHONY: bindings-example bindings-example: ## Run a specific example for all bindings. Usage: make bindings-example example @@ -87,6 +88,7 @@ bindings-example: ## Run a specific example for all bindings. Usage: make bindin @$(MAKE) python-example $(word 2,$(MAKECMDGOALS)) @$(MAKE) csharp-example $(word 2,$(MAKECMDGOALS)) @$(MAKE) swift-example $(word 2,$(MAKECMDGOALS)) + @$(MAKE) typescript-example $(word 2,$(MAKECMDGOALS)) .PHONY: bindings-examples bindings-examples: ## Run all bindings examples @@ -95,6 +97,7 @@ bindings-examples: ## Run all bindings examples @$(MAKE) python-examples @$(MAKE) csharp-examples @$(MAKE) swift-examples + @$(MAKE) typescript-examples .PHONY: bindings-examples-format-check bindings-examples-format-check: ## Check format of all bindings examples @@ -103,6 +106,7 @@ bindings-examples-format-check: ## Check format of all bindings examples @$(MAKE) python-examples-format-check @$(MAKE) csharp-examples-format-check @$(MAKE) swift-examples-format-check + @$(MAKE) typescript-examples-format-check .PHONY: bindings-examples-format bindings-examples-format: ## Format all bindings examples @@ -111,6 +115,7 @@ bindings-examples-format: ## Format all bindings examples @$(MAKE) python-examples-format @$(MAKE) csharp-examples-format @$(MAKE) swift-examples-format + @$(MAKE) typescript-examples-format # Build ffi crate and detect platform define build_binding @@ -315,6 +320,49 @@ swift-examples-format-check: ## Check format of all Swift bindings examples swift-examples-format: ## Format all Swift bindings examples @swift-format format --recursive bindings/swift/examples --in-place +.PHONY: typescript +typescript: ## Build TypeScript bindings + @printf "Building TypeScript bindings...\n" + @$(build_binding) \ + uniffi-bindgen-node generate target/release/libiota_sdk_ffi$${LIB_EXT} --crate-name iota_sdk_ffi --out-dir bindings/typescript/lib || exit $$?; \ + cp target/release/libiota_sdk_ffi$${LIB_EXT} bindings/typescript/lib/ + +.PHONY: typescript-example +typescript-example: ## Run a specific TypeScript example. Usage: make typescript-example example +%: + @true +typescript-example: + @printf "\nRunning TypeScript example \"$(word 2,$(MAKECMDGOALS))\"\n" + @cd bindings/typescript; \ + npx tsx examples/$(word 2,$(MAKECMDGOALS)).ts || exit $$?; \ + cd - + +# transaction_signer_callback: requires callback interface support not yet available in uniffi-bindgen-node +# abstract_account: requires specific local network config (also fails in Go bindings) +TYPESCRIPT_SKIP_EXAMPLES := transaction_signer_callback abstract_account + +.PHONY: typescript-examples +typescript-examples: ## Run all TypeScript bindings examples + @for example in $$(find bindings/typescript/examples -name "*.ts" -not -path "*/release/*" -exec basename {} .ts \;); do \ + skip=false; \ + for s in $(TYPESCRIPT_SKIP_EXAMPLES); do \ + if [ "$$example" = "$$s" ]; then skip=true; break; fi; \ + done; \ + if [ "$$skip" = "true" ]; then \ + printf "\nSkipping TypeScript example \"$$example\"\n"; \ + else \ + $(MAKE) typescript-example "$$example" || exit $$?; \ + fi; \ + done + +.PHONY: typescript-examples-format-check +typescript-examples-format-check: ## Check format of all TypeScript bindings examples + @cd bindings/typescript && npx prettier --check "examples/**/*.ts" + +.PHONY: typescript-examples-format +typescript-examples-format: ## Format all TypeScript bindings examples + @cd bindings/typescript && npx prettier --write "examples/**/*.ts" + .PHONY: example example: ## Run a specific Rust example. Usage: make example example %: @@ -359,6 +407,11 @@ swift-release-example: ## Run the Swift release example @printf "\nRunning Swift release example\n" @cd bindings/swift/examples/release && swift run || exit $$? +.PHONY: typescript-release-example +typescript-release-example: ## Run the TypeScript release example + @printf "\nRunning TypeScript release example\n" + @cd bindings/typescript/examples/release && npm install && npx tsx example.ts || exit $$? + .PHONY: release-examples release-examples: ## Run all release examples @$(MAKE) rust-release-example @@ -367,6 +420,7 @@ release-examples: ## Run all release examples @$(MAKE) python-release-example @$(MAKE) csharp-release-example @$(MAKE) swift-release-example + @$(MAKE) typescript-release-example .PHONY: help help: ## Show this help diff --git a/bindings/typescript/.gitignore b/bindings/typescript/.gitignore new file mode 100644 index 0000000000..f45b7011e4 --- /dev/null +++ b/bindings/typescript/.gitignore @@ -0,0 +1,7 @@ +# Node modules +node_modules + +# Native library files (platform-specific, built at compile time) +lib/*.dylib +lib/*.so +lib/*.dll diff --git a/bindings/typescript/.prettierrc b/bindings/typescript/.prettierrc new file mode 100644 index 0000000000..cf7c9eb333 --- /dev/null +++ b/bindings/typescript/.prettierrc @@ -0,0 +1,7 @@ +{ + "semi": true, + "trailingComma": "all", + "singleQuote": false, + "printWidth": 100, + "tabWidth": 2 +} diff --git a/bindings/typescript/CHANGELOG.md b/bindings/typescript/CHANGELOG.md new file mode 100644 index 0000000000..80e44d66e6 --- /dev/null +++ b/bindings/typescript/CHANGELOG.md @@ -0,0 +1,3 @@ +## [0.0.1-alpha.1] - 2026-XX-XX + +Initial Release diff --git a/bindings/typescript/README.md b/bindings/typescript/README.md new file mode 100644 index 0000000000..da83a3660a --- /dev/null +++ b/bindings/typescript/README.md @@ -0,0 +1,118 @@ +# IOTA SDK - TypeScript Bindings + +TypeScript bindings for the IOTA SDK, enabling TypeScript/JavaScript developers to interact with the IOTA network. + +## Installation + +To use the IOTA SDK in your TypeScript project, install it via npm: + +```bash +npm install @iota/sdk +``` + +The package includes pre-built native libraries for: + +- macOS (x86_64 and ARM64) +- Linux (x86_64 and ARM64) +- Windows (x86_64 and ARM64) + +## Quick Start + +Here is a simple example that queries the chain ID from the IOTA network: + +```typescript +import { GraphQlClient } from "@iota/sdk"; + +async function main() { + // Create a GraphQL client connected to devnet + const client = GraphQlClient.newDevnet(); + + // Query the chain ID + const chainId = await client.chainId(); + console.log("Chain ID:", chainId); +} + +main(); +``` + +## Usage + +The SDK provides GraphQL client functionality to interact with IOTA: + +```typescript +// Connect to devnet +const client = GraphQlClient.newDevnet(); + +// Connect to testnet +const client = GraphQlClient.newTestnet(); + +// Connect to mainnet +const client = GraphQlClient.newMainnet(); + +// Connect to a custom endpoint +const client = GraphQlClient.new("https://your-endpoint.com"); + +// Generate a mnemonic +import { generateMnemonic, MnemonicLength } from "@iota/sdk"; +const mnemonic = generateMnemonic(MnemonicLength.WORDS12); +``` + +## Examples + +More examples are available in the [examples directory](https://github.com/iotaledger/iota-rust-sdk/tree/develop/bindings/typescript/examples), including: + +- Getting chain information +- Querying coin balances +- Working with transactions +- Managing addresses and keys +- And many more + +## Building from Source + +If you want to build the TypeScript bindings from the Rust source: + +### Prerequisites + +- GNU Make +- Node.js 22+ +- Rust toolchain +- uniffi-bindgen-node + +Install `uniffi-bindgen-node` via: + +```bash +cargo install uniffi-bindgen-node --git https://github.com/nicklimmm/uniffi-bindgen-node --branch main +``` + +Verify by running `make --version`, `node --version`, and `uniffi-bindgen-node --version`. + +### Generate TypeScript bindings + +```bash +make typescript +``` + +### Run TypeScript examples + +```sh +make typescript-example chain_id +``` + +## Project Structure + +``` +bindings/typescript/ +├── package.json # Package configuration +├── tsconfig.json # TypeScript configuration +├── lib/ +│ ├── iota_sdk.js # Generated bindings +│ ├── iota_sdk.d.ts # TypeScript type declarations +│ └── libiota_sdk_ffi.* # Native library +├── examples/ # Example scripts +├── uniffi.toml # UniFFI configuration +└── README.md # This file +``` + +## License + +This project is licensed under the Apache License 2.0. diff --git a/bindings/typescript/examples/abstract_account.ts b/bindings/typescript/examples/abstract_account.ts new file mode 100644 index 0000000000..e915773e00 --- /dev/null +++ b/bindings/typescript/examples/abstract_account.ts @@ -0,0 +1,142 @@ +// Copyright (c) 2026 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { + GraphQlClient, + Address, + ObjectId, + TransactionBuilder, + TransactionSigner, + Ed25519PrivateKey, + PtbArgument, + Identifier, + FaucetClient, + MovePackageData, + MoveAuthenticatorBuilder, + WaitForTx, +} from "../lib"; + +const PRECOMPILED_PACKAGE = + '{"modules":["oRzrCwYAAAALAQAUAhQmAzorBGUGBWtPB7oBwAII+gNgBtoECRDjBCoKjQULDJgFQgAJAgkCCwINAg4CFgIXAhoCGwEKAAEMAAAAAgACAgIAAwMHAQgBBAQIAAUIBAAGBQgACAcCAAkGBwAAEwABAAAUAgEAAAwDAQABDwsBAQgDEAkKAQgFFQQFAAcYBwEBDAkZDA0ABgYEBgMGAggBBwgHAAQIAAYIBggICAgFBggACAgGCAQGCAIGCAcBBwgHAQgFAQgAAQkAAQsDAQgAAwYIBggICAgBCwMBCQACCQALAwEJAAEKAgEICAdBQ0NPVU5UB0FjY291bnQLQXV0aENvbnRleHQaQXV0aGVudGljYXRvckZ1bmN0aW9uUmVmVjEFQ2xvY2sRUGFja2FnZU1ldGFkYXRhVjEGU3RyaW5nCVR4Q29udGV4dANVSUQHYWNjb3VudAVhc2NpaQxhdXRoX2NvbnRleHQMYXV0aGVudGljYXRlFmF1dGhlbnRpY2F0b3JfZnVuY3Rpb24FY2xvY2sRY3JlYXRlX2FjY291bnRfdjEbY3JlYXRlX2F1dGhfZnVuY3Rpb25fcmVmX3YxC2R1bW15X2ZpZWxkAmlkBGluaXQJbGlua19hdXRoA25ldwZvYmplY3QQcGFja2FnZV9tZXRhZGF0YRNwdWJsaWNfc2hhcmVfb2JqZWN0BnN0cmluZwh0cmFuc2Zlcgp0eF9jb250ZXh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCgIGBWhlbGxvDmlvdGE6Om1ldGFkYXRhGgEAAAAAAAAAEQEMYXV0aGVudGljYXRlAQABAAIBEggFAQIBEQEAAAAAAQULAREFEgA4AAIBAQAACAkLAQsCCwM4AQwECwALBDgCAgIBAAABCQsBBwARByEEBgUIBgAAAAAAAAAAJwIA"],"dependencies":["0x0000000000000000000000000000000000000000000000000000000000000002","0x0000000000000000000000000000000000000000000000000000000000000001"],"digest":[236,68,86,252,91,28,224,206,146,112,120,93,47,52,14,168,169,132,252,75,45,104,10,116,171,91,155,100,66,111,66,147]}'; + +async function sleep(ms: number) { + return new Promise((resolve) => setTimeout(resolve, ms)); +} + +async function setupAccount(client: GraphQlClient): Promise { + // Parse the precompiled move package + const packageData = MovePackageData.fromJson(PRECOMPILED_PACKAGE); + + // Create a random private key to derive a sender address + const privateKey = Ed25519PrivateKey.generate(); + const sender = privateKey.publicKey().deriveAddress(); + + // Fund the sender address for gas payment + const faucet = FaucetClient.newLocalnet(); + const faucetReceipt = await faucet.requestAndWaitForFinalized(sender, client); + if (faucetReceipt === undefined) { + throw new Error("Failed to request coins from faucet"); + } + + // Build the `publish` PTB + let builder = new TransactionBuilder(sender).withClient(client); + // Publish the package and receive the upgrade cap + builder.publish(packageData, "upgrade_cap"); + // Transfer the upgrade cap to the sender address + builder.transferObjects(sender, [PtbArgument.assigned("upgrade_cap")]); + + // Sign and execute the transaction (publish the package) + const signer = TransactionSigner.fromEd25519(privateKey); + let effects = await builder.execute(signer, "finalized"); + + console.log(`Publishing package: ${effects.asV1().status}\n`); + + // Wait some time for the indexer to process the tx + await sleep(3000); + + // Get package, package metadata and account IDs from the effects + let packageId: ObjectId | null = null; + let packageMetadataId: ObjectId | null = null; + let accountId: ObjectId | null = null; + + for (const changedObj of effects.asV1().changedObjects) { + if (changedObj.outputState.tag === "packageWrite") { + packageId = changedObj.objectId; + } else if (changedObj.outputState.tag === "objectWrite") { + const objectId = changedObj.objectId; + const obj = await client.object(objectId, undefined); + + if (obj !== undefined) { + const typeName = obj.asStruct().structType.name().asStr(); + if (typeName === "PackageMetadataV1") { + packageMetadataId = objectId; + } + if (typeName === "Account") { + accountId = objectId; + } + } + } + } + + if (packageId === undefined) { + throw new Error("Missing package id"); + } + if (packageMetadataId === undefined) { + throw new Error("Missing package metadata id"); + } + if (accountId === undefined) { + throw new Error("Missing account id"); + } + + console.log(`Package ID: ${packageId.toHex()}`); + console.log(`PackageMetadataV1 ID: ${packageMetadataId.toHex()}`); + console.log(`Account ID: ${accountId.toHex()}\n`); + + // Build the `link_auth` PTB + builder = new TransactionBuilder(sender).withClient(client); + builder.moveCall(packageId.toAddress(), new Identifier("account"), new Identifier("link_auth"), [ + PtbArgument.sharedMut(accountId), + PtbArgument.objectId(packageMetadataId), + PtbArgument.string("account"), + PtbArgument.string("authenticate"), + ], [], []); + + // Sign and execute the transaction (link the authenticator) + effects = await builder.execute(signer, "finalized"); + + console.log(`Linking account to authenticate method: ${effects.asV1().status}\n`); + + return accountId; +} + +async function main() { + const client = GraphQlClient.newLocalnet(); + const accountId = await setupAccount(client); + const fromAddress = accountId.toAddress(); + const toAddress = Address.fromHex( + "0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900", + ); + + // Fund the sender address for gas payment + const faucet = FaucetClient.newLocalnet(); + const faucetReceipt = await faucet.requestAndWaitForFinalized(fromAddress, client); + if (faucetReceipt === undefined) { + throw new Error("Failed to request coins from faucet"); + } + + const builder = new TransactionBuilder(fromAddress).withClient(client); + builder.sendIota(toAddress, PtbArgument.u64(5000000000n)); + + const moveAuthenticator = await new MoveAuthenticatorBuilder( + accountId, + [PtbArgument.string("hello"), PtbArgument.shared(ObjectId.clock())], + [], + ).finish(client); + + const signer = TransactionSigner.fromMoveAuthenticator(moveAuthenticator); + const effects = await builder.execute(signer, "finalized"); + + console.log(`Sending IOTA via abstract account: ${effects.asV1().status}`); +} + +main(); diff --git a/bindings/typescript/examples/address_from_mnemonic.ts b/bindings/typescript/examples/address_from_mnemonic.ts new file mode 100644 index 0000000000..bb9e68f0dd --- /dev/null +++ b/bindings/typescript/examples/address_from_mnemonic.ts @@ -0,0 +1,51 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { + Ed25519PrivateKey, + Secp256k1PrivateKey, + Secp256r1PrivateKey, + base64Encode, +} from "../lib"; + +function main() { + const mnemonic = "round attack kitchen wink winter music trip tiny nephew hire orange what"; + + const ed25519Key = Ed25519PrivateKey.fromMnemonic(mnemonic, 0n, ""); + const ed25519Bech32 = ed25519Key.toBech32(); + const ed25519PubKey = ed25519Key.publicKey(); + const ed25519FlaggedPubKey = ed25519PubKey.toFlaggedBytes(); + const ed25519Address = ed25519PubKey.deriveAddress(); + + console.log("Ed25519\n---"); + console.log(`Private Key: ${ed25519Bech32}`); + console.log(`Public Key: ${base64Encode(ed25519PubKey.toBytes())}`); + console.log(`Public Key With Flag: ${base64Encode(ed25519FlaggedPubKey)}`); + console.log(`Address: ${ed25519Address.toHex()}`); + + const secp256k1Key = Secp256k1PrivateKey.fromMnemonic(mnemonic, 1n, ""); + const secp256k1Bech32 = secp256k1Key.toBech32(); + const secp256k1PubKey = secp256k1Key.publicKey(); + const secp256k1FlaggedPubKey = secp256k1PubKey.toFlaggedBytes(); + const secp256k1Address = secp256k1PubKey.deriveAddress(); + + console.log("\nSecp256k1\n---"); + console.log(`Private Key: ${secp256k1Bech32}`); + console.log(`Public Key: ${base64Encode(secp256k1PubKey.toBytes())}`); + console.log(`Public Key With Flag: ${base64Encode(secp256k1FlaggedPubKey)}`); + console.log(`Address: ${secp256k1Address.toHex()}`); + + const secp256r1Key = Secp256r1PrivateKey.fromMnemonicWithPath(mnemonic, "m/74'/4218'/0'/0/2", ""); + const secp256r1Bech32 = secp256r1Key.toBech32(); + const secp256r1PubKey = secp256r1Key.publicKey(); + const secp256r1FlaggedPubKey = secp256r1PubKey.toFlaggedBytes(); + const secp256r1Address = secp256r1PubKey.deriveAddress(); + + console.log("\nSecp256r1\n---"); + console.log(`Private Key: ${secp256r1Bech32}`); + console.log(`Public Key: ${base64Encode(secp256r1PubKey.toBytes())}`); + console.log(`Public Key With Flag: ${base64Encode(secp256r1FlaggedPubKey)}`); + console.log(`Address: ${secp256r1Address.toHex()}`); +} + +main(); diff --git a/bindings/typescript/examples/chain_id.ts b/bindings/typescript/examples/chain_id.ts new file mode 100644 index 0000000000..7e897d7609 --- /dev/null +++ b/bindings/typescript/examples/chain_id.ts @@ -0,0 +1,13 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { GraphQlClient } from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + + const chainId = await client.chainId(); + console.log("Chain ID:", chainId); +} + +main(); diff --git a/bindings/typescript/examples/coin_balances.ts b/bindings/typescript/examples/coin_balances.ts new file mode 100644 index 0000000000..657f651bca --- /dev/null +++ b/bindings/typescript/examples/coin_balances.ts @@ -0,0 +1,24 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { GraphQlClient, Address } from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + + const address = Address.fromHex( + "0xda1820edf693ee32b5729907b9b2ec8e64980ee8c008c17e89cfb4e5ecd72151", + ); + + const coins = await client.coins(address); + for (const coin of coins.data) { + console.log( + `Coin = ${coin.id().toHex()}, Coin Type = ${coin.coinType().asStructTag()}, Balance = ${coin.balance()}`, + ); + } + + const balance = await client.balance(address); + console.log(`Total Balance = ${balance}`); +} + +main(); diff --git a/bindings/typescript/examples/custom_query.ts b/bindings/typescript/examples/custom_query.ts new file mode 100644 index 0000000000..bfd026ac1c --- /dev/null +++ b/bindings/typescript/examples/custom_query.ts @@ -0,0 +1,42 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { GraphQlClient, Query } from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + + const queryEpochDataStr = ` + query MyQuery($id: UInt53) { + epoch(id: $id) { + epochId + referenceGasPrice + totalGasFees + totalCheckpoints + totalTransactions + } + } + `; + const queryEpochData = Query.create({ query: queryEpochDataStr }); + let res = await client.runQuery(queryEpochData); + console.log(res); + + const variables = { id: 1 }; + const queryEpochDataWithVariables = Query.create({ + query: queryEpochDataStr, + variables: JSON.stringify(variables), + }); + res = await client.runQuery(queryEpochDataWithVariables); + console.log(res); + + const queryChainIdStr = ` + query MyQuery { + chainIdentifier + } + `; + const queryChainId = Query.create({ query: queryChainIdStr }); + res = await client.runQuery(queryChainId); + console.log(res); +} + +main(); diff --git a/bindings/typescript/examples/dev_inspect.ts b/bindings/typescript/examples/dev_inspect.ts new file mode 100644 index 0000000000..0c983fc29b --- /dev/null +++ b/bindings/typescript/examples/dev_inspect.ts @@ -0,0 +1,138 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { + GraphQlClient, + Address, + ObjectId, + TransactionBuilder, + Identifier, + PtbArgument, + TypeTag, + StructTag, +} from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + + const sender = Address.zero(); + + const iotaNamesPackageAddress = Address.fromHex( + "0x7fff6e95f385349bec98d17121ab2bfa3e134f2f0b1ccefc270313415f7835ea", + ); + const iotaNamesObjectId = ObjectId.fromHex( + "0x7cab491740d51e0d75b26bf9984e49ba2e32a2d0694cabcee605543ed13c7dec", + ); + const stdAddress = Address.std(); + + const name = "name.iota"; + console.log(`Looking up name: ${name}`); + + const builder = new TransactionBuilder(sender).withClient(client); + + // 1. Get the registry + builder.moveCall( + iotaNamesPackageAddress, + new Identifier("iota_names"), + new Identifier("registry"), + [PtbArgument.sharedMut(iotaNamesObjectId)], + [ + TypeTag.newStruct( + new StructTag( + iotaNamesPackageAddress, + new Identifier("registry"), + new Identifier("Registry"), + [], + ), + ), + ], + ["iota_names"], + ); + + // 2. Create name from string + builder.moveCall( + iotaNamesPackageAddress, + new Identifier("name"), + new Identifier("new"), + [PtbArgument.string(name)], + [], + ["name"], + ); + + // 3. Lookup name record + builder.moveCall( + iotaNamesPackageAddress, + new Identifier("registry"), + new Identifier("lookup"), + [PtbArgument.assigned("iota_names"), PtbArgument.assigned("name")], + [], + ["name_record_opt"], + ); + + // 4. Borrow name record from option + builder.moveCall( + stdAddress, + new Identifier("option"), + new Identifier("borrow"), + [PtbArgument.assigned("name_record_opt")], + [ + TypeTag.newStruct( + new StructTag( + iotaNamesPackageAddress, + new Identifier("name_record"), + new Identifier("NameRecord"), + [], + ), + ), + ], + ["name_record"], + ); + + // 5. Get target address from name record + builder.moveCall( + iotaNamesPackageAddress, + new Identifier("name_record"), + new Identifier("target_address"), + [PtbArgument.assigned("name_record")], + [], + ["target_address_opt"], + ); + + // 6. Borrow address from option + builder.moveCall( + stdAddress, + new Identifier("option"), + new Identifier("borrow"), + [PtbArgument.assigned("target_address_opt")], + [TypeTag.newAddress()], + ["target_address"], + ); + + const res = await builder.dryRun(true); + + if (res.error !== undefined) { + throw new Error(`Failed to lookup name: ${res.error}`); + } + + // Extract the resolved address from the last result + if (res.results.length > 0) { + const lastEffect = res.results[res.results.length - 1]; + if (lastEffect.returnValues.length > 0) { + const returnValue = lastEffect.returnValues[0]; + if (returnValue.typeTag.isAddress() && returnValue.bcs.byteLength === 32) { + const resolvedAddress = Address.fromBytes(returnValue.bcs); + console.log(`Resolved address: ${resolvedAddress.toHex()}`); + } else { + console.log( + `Last result is not an address type or has wrong length: ${returnValue.bcs.byteLength}`, + ); + } + } else { + console.log("No return value in last effect"); + } + } else { + console.log("No results found"); + } +} + +main(); diff --git a/bindings/typescript/examples/dry_run_bytes.ts b/bindings/typescript/examples/dry_run_bytes.ts new file mode 100644 index 0000000000..19883dce7b --- /dev/null +++ b/bindings/typescript/examples/dry_run_bytes.ts @@ -0,0 +1,22 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { GraphQlClient, Transaction } from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + + const txBytesBase64 = + "AAABACAAAKSYS9SV1DRvogjd/09dXlrUjCHexjHd68mYCfFpAAEBAQABAADaGCDt9pPuMrVymQe5suyOZJgO6MAIwX6Jz7Tl7NchUQHclW3om5FOan+9g8rr78jskb4SB2Z+pVdjhjkaqCRJzPC6fSAAAAAAILFkUl8sWJyphiT+5+p5Rev6nLCp6DDtMQTNwLSMcOHw2hgg7faT7jK1cpkHubLsjmSYDujACMF+ic+05ezXIVHoAwAAAAAAAICEHgAAAAAAAA=="; + const transaction = Transaction.fromBase64(txBytesBase64); + + const res = await client.dryRunTx(transaction); + if (res.error !== undefined) { + throw new Error(`Dry run failed: ${res.error}`); + } + + console.log("Dry run was successful!"); + console.log(`Dry run result: ${res}`); +} + +main(); diff --git a/bindings/typescript/examples/dynamic_fields.ts b/bindings/typescript/examples/dynamic_fields.ts new file mode 100644 index 0000000000..d5cf9c2212 --- /dev/null +++ b/bindings/typescript/examples/dynamic_fields.ts @@ -0,0 +1,19 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { GraphQlClient, Address } from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + const parentObjectId = Address.fromHex( + "0x7cab491740d51e0d75b26bf9984e49ba2e32a2d0694cabcee605543ed13c7dec", + ); + const page = await client.dynamicFields(parentObjectId); + console.log("Page size:", page.data.length); + if (page.data.length > 0) { + console.log("First field name:\n", page.data[0].name); + console.log("First field value:\n", page.data[0].valueAsJson); + } +} + +main(); diff --git a/bindings/typescript/examples/epoch.ts b/bindings/typescript/examples/epoch.ts new file mode 100644 index 0000000000..d66b3b3154 --- /dev/null +++ b/bindings/typescript/examples/epoch.ts @@ -0,0 +1,31 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { GraphQlClient } from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + + // Get current epoch + const currentEpoch = await client.epoch(); + if (currentEpoch === undefined) { + throw new Error("missing current epoch"); + } + + console.log(`Current epoch: ${currentEpoch.epochId}`); + console.log(`Current epoch start time: ${currentEpoch.startTimestamp}`); + + // Get previous epoch + const previousEpochId = currentEpoch.epochId - 1n; + const previousEpoch = await client.epoch(previousEpochId); + if (previousEpoch === undefined) { + throw new Error("missing previous epoch"); + } + + console.log(`Previous epoch: ${previousEpoch.epochId}`); + if (previousEpoch.totalStakeRewards !== undefined) { + console.log(`Previous epoch stake rewards: ${previousEpoch.totalStakeRewards}`); + } +} + +main(); diff --git a/bindings/typescript/examples/faucet.ts b/bindings/typescript/examples/faucet.ts new file mode 100644 index 0000000000..61de646484 --- /dev/null +++ b/bindings/typescript/examples/faucet.ts @@ -0,0 +1,24 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { Address, FaucetClient } from "../lib"; + +async function main() { + const address = Address.fromHex( + "0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900", + ); + const faucetClient = FaucetClient.newLocalnet(); + const faucetReceipt = await faucetClient.requestAndWait(address); + if (faucetReceipt) { + console.log("Faucet receipt:"); + for (const coin of faucetReceipt.sent) { + console.log( + ` Coin ID: ${coin.id.toHex()}, Amount: ${coin.amount}, Digest: ${coin.transferTxDigest.toBase58()}`, + ); + } + } else { + console.log("Faucet receipt: None"); + } +} + +main(); diff --git a/bindings/typescript/examples/gas_sponsor.ts b/bindings/typescript/examples/gas_sponsor.ts new file mode 100644 index 0000000000..bae3adaa44 --- /dev/null +++ b/bindings/typescript/examples/gas_sponsor.ts @@ -0,0 +1,42 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { GraphQlClient, Address, TransactionBuilder, Identifier, PtbArgument } from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + + const sender = Address.fromHex( + "0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900", + ); + const sponsor = Address.fromHex( + "0xda1820edf693ee32b5729907b9b2ec8e64980ee8c008c17e89cfb4e5ecd72151", + ); + + const builder = new TransactionBuilder(sender).withClient(client); + + const packageAddr = Address.std(); + const moduleName = new Identifier("u8"); + const functionName = new Identifier("max"); + + builder.moveCall(packageAddr, moduleName, functionName, [ + PtbArgument.u8(0), + PtbArgument.u8(1), + ], [], []); + + builder.sponsor(sponsor); + + const txn = await builder.finish(); + + console.log("Signing Digest:", txn.signingDigestHex()); + console.log("Txn Bytes:", txn.toBase64()); + + const res = await client.dryRunTx(txn); + if (res.error !== undefined) { + throw new Error(`Failed to send gas sponsor tx: ${res.error}`); + } + + console.log("Gas sponsor tx dry run was successful!"); +} + +main(); diff --git a/bindings/typescript/examples/gas_station.ts b/bindings/typescript/examples/gas_station.ts new file mode 100644 index 0000000000..69522b1ebc --- /dev/null +++ b/bindings/typescript/examples/gas_station.ts @@ -0,0 +1,39 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { + GraphQlClient, + Address, + TransactionBuilder, + TransactionSigner, + Ed25519PrivateKey, + Identifier, + PtbArgument, +} from "../lib"; + +async function main() { + const client = GraphQlClient.newLocalnet(); + const gasStationUrl = "http://0.0.0.0:9527"; + const gasStationAuthToken = "test"; + const keypair = Ed25519PrivateKey.generate(); + const sender = keypair.publicKey().deriveAddress(); + const signer = TransactionSigner.fromEd25519(keypair); + + const builder = new TransactionBuilder(sender).withClient(client); + + builder.moveCall(Address.std(), new Identifier("u64"), new Identifier("sqrt"), [ + PtbArgument.u64(64n), + ], [], []); + + const headers = new Map>(); + headers.set("Authorization", [`Bearer ${gasStationAuthToken}`]); + builder.gasStationSponsor(gasStationUrl, undefined, headers); + + const res = await builder.execute(signer); + + console.log(res); + + console.log("Sponsored transaction was successful!"); +} + +main(); diff --git a/bindings/typescript/examples/generate_ed25519_address.ts b/bindings/typescript/examples/generate_ed25519_address.ts new file mode 100644 index 0000000000..0d9c967392 --- /dev/null +++ b/bindings/typescript/examples/generate_ed25519_address.ts @@ -0,0 +1,19 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { Ed25519PrivateKey, base64Encode } from "../lib"; + +function main() { + const privateKey = Ed25519PrivateKey.generate(); + const privateKeyBech32 = privateKey.toBech32(); + const publicKey = privateKey.publicKey(); + const flaggedPublicKey = publicKey.toFlaggedBytes(); + const address = publicKey.deriveAddress(); + + console.log(`Private Key: ${privateKeyBech32}`); + console.log(`Public Key: ${base64Encode(publicKey.toBytes())}`); + console.log(`Public Key With Flag: ${base64Encode(flaggedPublicKey)}`); + console.log(`Address: ${address.toHex()}`); +} + +main(); diff --git a/bindings/typescript/examples/generate_mnemonic.ts b/bindings/typescript/examples/generate_mnemonic.ts new file mode 100644 index 0000000000..b09d24473b --- /dev/null +++ b/bindings/typescript/examples/generate_mnemonic.ts @@ -0,0 +1,13 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { generateMnemonic, MnemonicLength } from "../lib"; + +function main() { + const mnemonic24 = generateMnemonic(undefined); + console.log("24 word mnemonic:", mnemonic24); + const mnemonic12 = generateMnemonic("words12"); + console.log("12 word mnemonic:", mnemonic12); +} + +main(); diff --git a/bindings/typescript/examples/generic_move_function.ts b/bindings/typescript/examples/generic_move_function.ts new file mode 100644 index 0000000000..f0171b2bad --- /dev/null +++ b/bindings/typescript/examples/generic_move_function.ts @@ -0,0 +1,47 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { + GraphQlClient, + Address, + TransactionBuilder, + Identifier, + PtbArgument, + TypeTag, +} from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + + const sender = Address.fromHex( + "0x71b4b4f171b4355ff691b7c470579cf1a926f96f724e5f9a30efc4b5f75d085e", + ); + + const builder = new TransactionBuilder(sender).withClient(client); + + const addr1 = Address.fromHex( + "0xde49ea53fbadee67d3e35a097cdbea210b659676fc680a0b0c5f11d0763d375e", + ); + const addr2 = Address.fromHex( + "0xe512234aa4ef6184c52663f09612b68f040dd0c45de037d96190a071ca5525b3", + ); + + builder.moveCall( + Address.framework(), + new Identifier("vec_map"), + new Identifier("from_keys_values"), + [PtbArgument.addressVec([addr1, addr2]), PtbArgument.u64Vec([10_000_000n, 20_000_000n])], + [TypeTag.newAddress(), TypeTag.newU64()], + [], + ); + + const res = await builder.dryRun(); + + if (res.error !== undefined) { + throw new Error(`Failed to call generic Move function: ${res.error}`); + } + + console.log("Successfully called generic Move function!"); +} + +main(); diff --git a/bindings/typescript/examples/get_object.ts b/bindings/typescript/examples/get_object.ts new file mode 100644 index 0000000000..2e6f9c1ac1 --- /dev/null +++ b/bindings/typescript/examples/get_object.ts @@ -0,0 +1,27 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { GraphQlClient, ObjectId, hexEncode } from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + + const objectId = ObjectId.fromHex( + "0x541b117cac18fb1c07a293db300acd12b05c01fa81232b37151b005ca7d4f755", + ); + + const obj = await client.object(objectId); + if (obj === undefined) { + throw new Error("missing object"); + } + + console.log("Object ID:", obj.objectId().toHex()); + console.log("Version:", obj.version()); + console.log("Previous transaction:", obj.previousTransaction().toBase58()); + console.log("Owner:", obj.owner()); + console.log("Storage rebate:", obj.storageRebate()); + console.log("Type:", obj.objectType()); + console.log("BCS bytes:", hexEncode(obj.asStruct().contents)); +} + +main(); diff --git a/bindings/typescript/examples/get_transaction.ts b/bindings/typescript/examples/get_transaction.ts new file mode 100644 index 0000000000..1d89c51eaa --- /dev/null +++ b/bindings/typescript/examples/get_transaction.ts @@ -0,0 +1,20 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { GraphQlClient, Digest } from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + const digest = Digest.fromBase58("CY14gCcLcVuSMN9Hq7Ya6vEhBAzSzciNw47togWXJAZ8"); + + const signedTransaction = await client.transaction(digest); + console.log(`Signed Transaction: \`${signedTransaction}\`\n`); + + const transactionEffects = await client.transactionEffects(digest); + console.log(`Transaction Effects: \`${transactionEffects}\`\n`); + + const transactionDataEffects = await client.transactionDataEffects(digest); + console.log(`Transaction Data Effects: \`${transactionDataEffects}\`\n`); +} + +main(); diff --git a/bindings/typescript/examples/json_query.ts b/bindings/typescript/examples/json_query.ts new file mode 100644 index 0000000000..6ccbc3eb5e --- /dev/null +++ b/bindings/typescript/examples/json_query.ts @@ -0,0 +1,140 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { GraphQlClient, Query } from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + + const queryStr = ` + query getLatestIotaSystemState { + epoch { + epochId + startTimestamp + endTimestamp + referenceGasPrice + safeMode { + enabled + gasSummary { + computationCost + computationCostBurned + nonRefundableStorageFee + storageCost + storageRebate + } + } + storageFund { + nonRefundableBalance + totalObjectStorageRebates + } + systemStateVersion + iotaTotalSupply + iotaTreasuryCapId + systemParameters { + minValidatorCount + maxValidatorCount + minValidatorJoiningStake + durationMs + validatorLowStakeThreshold + validatorLowStakeGracePeriod + validatorVeryLowStakeThreshold + } + protocolConfigs { + protocolVersion + } + validatorSet { + activeValidators { + pageInfo { + hasNextPage + endCursor + } + nodes { + ...RPC_VALIDATOR_FIELDS + } + } + committeeMembers { + pageInfo { + hasNextPage + endCursor + } + nodes { + ...RPC_VALIDATOR_FIELDS + } + } + inactivePoolsSize + pendingActiveValidatorsSize + stakingPoolMappingsSize + validatorCandidatesSize + pendingRemovals + totalStake + stakingPoolMappingsId + pendingActiveValidatorsId + validatorCandidatesId + inactivePoolsId + } + } + } + + fragment RPC_VALIDATOR_FIELDS on Validator { + address { + address + } + credentials { + authorityPubKey + networkPubKey + protocolPubKey + proofOfPossession + netAddress + p2PAddress + primaryAddress + } + nextEpochCredentials { + authorityPubKey + networkPubKey + protocolPubKey + proofOfPossession + netAddress + p2PAddress + primaryAddress + } + name + description + imageUrl + projectUrl + operationCap { + address + } + stakingPoolId + exchangeRatesTable { + address + } + exchangeRatesSize + stakingPoolActivationEpoch + stakingPoolIotaBalance + rewardsPool + poolTokenBalance + pendingStake + pendingTotalIotaWithdraw + pendingPoolTokenWithdraw + votingPower + gasPrice + commissionRate + nextEpochStake + nextEpochGasPrice + nextEpochCommissionRate + atRisk + reportRecords { + nodes { + address + } + } + apy + } + `; + + const query = Query.create({ query: queryStr }); + const res = await client.runQuery(query); + console.log(res); +} + +main(); diff --git a/bindings/typescript/examples/json_roundtrip.ts b/bindings/typescript/examples/json_roundtrip.ts new file mode 100644 index 0000000000..63d66ef262 --- /dev/null +++ b/bindings/typescript/examples/json_roundtrip.ts @@ -0,0 +1,26 @@ +// Copyright (c) 2026 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +// This example demonstrates how to convert a Transaction to and from JSON. +// A similar roundtrip can be done for other types as well. + +import { Transaction, transactionToJson, transactionFromJson } from "../lib"; + +function main() { + // A sample transaction in base64 format + const txBytesBase64 = + "AAACACAAAKSQS9SV1DRvogjd/09dXlrUjCHexjHd68mYCfFpAAAIAPIFKgEAAAACAgABAQEAAQECAAABAABhGDDTZBpo+UppDcwl0fSw2slIMlrBj23TJWQ3FzXzLAILAnDunSfaDbCWUeX3M436MsfuZEHM76H24wVzW8/Hq3M6MhwAAAAAIKlI7704HwxEKcAJUDavYxFuJgvpsFwQktqa3/trEI4n0EB3/jtvrROz1O0NU1t8qSr8rI8PKg4JJfufTwswxplyOjIcAAAAACBwo4RInFHkslDFUznEltYw/OPcH4EFo0/At7kMLZpocGEYMNNkGmj5SmkNzCXR9LDayUgyWsGPbdMlZDcXNfMs6AMAAAAAAACgLS0AAAAAAAA="; + + // Parse the transaction from base64 + const transaction = Transaction.fromBase64(txBytesBase64); + + // Convert the transaction to JSON + const json = transactionToJson(transaction); + console.log(`Transaction as JSON:\n${json}`); + + // Convert the JSON back to a transaction + const parsedTransaction = transactionFromJson(json); + console.log(`Parsed transaction back from JSON: ${parsedTransaction}`); +} + +main(); diff --git a/bindings/typescript/examples/move_functions.ts b/bindings/typescript/examples/move_functions.ts new file mode 100644 index 0000000000..a89546dd03 --- /dev/null +++ b/bindings/typescript/examples/move_functions.ts @@ -0,0 +1,34 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { GraphQlClient, Address } from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + + const packageAddress = Address.fromHex( + "0x6f727ea576a00036657fff0ae3a6d7c8171b178bf35112d6b83b2a6272cc5f0d", + ); + + const pkg = await client.package_(packageAddress, undefined); + if (pkg === undefined) { + throw new Error("missing package"); + } + + for (const [moduleId] of pkg.modules()) { + const mod = await client.normalizedMoveModule(packageAddress, moduleId.asStr()); + if (mod === undefined) { + console.log(`module \`${moduleId.asStr()}\` not found`); + return; + } + if (mod.functions !== undefined) { + console.log(`Module: ${moduleId.asStr()}`); + for (const fun of mod.functions.nodes) { + console.log(`- ${String(fun)}`); + } + console.log(); + } + } +} + +main(); diff --git a/bindings/typescript/examples/move_view_call.ts b/bindings/typescript/examples/move_view_call.ts new file mode 100644 index 0000000000..9421d9a54b --- /dev/null +++ b/bindings/typescript/examples/move_view_call.ts @@ -0,0 +1,48 @@ +// Copyright (c) 2026 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +// TODO: https://github.com/iotaledger/iota-rust-sdk/issues/1000 + +import { GraphQlClient, MoveViewArg } from "../lib"; + +async function main() { + const client = GraphQlClient.newDevnet(); + + // =========================================================================== + // Example 1: Using moveViewCall() with typed arguments (blake2b256) + // =========================================================================== + console.log("=== Example 1: moveViewCall() with typed arguments (blake2b256) ==="); + console.log(); + + // Using typed arguments: an array of u8 values using the u8Vec constructor + const hashArgs = [MoveViewArg.u8Vec(new Uint8Array([0, 1, 2]))]; + + const result = await client.moveViewCall("0x2::hash::blake2b256", undefined, hashArgs); + + if (result.error !== undefined) { + console.log("Error:", result.error); + } else if (result.results !== undefined) { + console.log("Results:", result.results); + } else { + console.log("No results"); + } + + // =========================================================================== + // Example 2: Using moveViewCallJson() with JSON values (blake2b256) + // =========================================================================== + console.log(); + console.log("=== Example 2: moveViewCallJson() with JSON values (blake2b256) ==="); + console.log(); + + const jsonResult = await client.moveViewCallJson("0x2::hash::blake2b256", undefined, ["[0, 1, 2]"]); + + if (jsonResult.error !== undefined) { + console.log("JSON Error:", jsonResult.error); + } else if (jsonResult.results !== undefined) { + console.log("JSON Results:", jsonResult.results); + } else { + console.log("No JSON results"); + } +} + +main(); diff --git a/bindings/typescript/examples/objects_by_type.ts b/bindings/typescript/examples/objects_by_type.ts new file mode 100644 index 0000000000..46082d92b4 --- /dev/null +++ b/bindings/typescript/examples/objects_by_type.ts @@ -0,0 +1,23 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { GraphQlClient, ObjectFilter } from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + + const stakedIotas = await client.objects( + ObjectFilter.create({ typeTag: "0x3::staking_pool::StakedIota" }), + ); + + if (stakedIotas.data.length === 0) { + console.log("No StakedIota objects found"); + } else { + console.log("StakedIota object IDs:"); + for (const stakedIota of stakedIotas.data) { + console.log(stakedIota.objectId().toHex()); + } + } +} + +main(); diff --git a/bindings/typescript/examples/owned_objects.ts b/bindings/typescript/examples/owned_objects.ts new file mode 100644 index 0000000000..7fc172d273 --- /dev/null +++ b/bindings/typescript/examples/owned_objects.ts @@ -0,0 +1,16 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { GraphQlClient, Address, ObjectFilter } from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + const address = Address.zero(); + const objectsPage = await client.objects(ObjectFilter.create({ owner: address })); + console.log(`Owned objects(${objectsPage.data.length}):`); + for (const obj of objectsPage.data) { + console.log(obj.objectId().toHex()); + } +} + +main(); diff --git a/bindings/typescript/examples/package_events.ts b/bindings/typescript/examples/package_events.ts new file mode 100644 index 0000000000..f8e15c01cf --- /dev/null +++ b/bindings/typescript/examples/package_events.ts @@ -0,0 +1,25 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { GraphQlClient, EventFilter, PaginationFilter, Direction } from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + + const events = await client.events( + EventFilter.create({ + eventType: + "0x7fff6e95f385349bec98d17121ab2bfa3e134f2f0b1ccefc270313415f7835ea::registry::NameRecordAddedEvent", + }), + PaginationFilter.create({ direction: "forward", limit: 10 }), + ); + + for (const event of events.data) { + console.log(`Type: ${event.type}`); + console.log(`Sender: ${event.sender.toHex()}`); + console.log(`Module: ${event.module}`); + console.log(`JSON: ${event.json}`); + } +} + +main(); diff --git a/bindings/typescript/examples/pagination.ts b/bindings/typescript/examples/pagination.ts new file mode 100644 index 0000000000..83ef88d927 --- /dev/null +++ b/bindings/typescript/examples/pagination.ts @@ -0,0 +1,34 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { GraphQlClient, Address, ObjectFilter, PaginationFilter, Direction } from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + const address = Address.fromHex( + "0xda1820edf693ee32b5729907b9b2ec8e64980ee8c008c17e89cfb4e5ecd72151", + ); + + const allObjects: any[] = []; + let nextCursor: string | undefined = undefined; + while (true) { + console.log(`Fetching page with cursor: ${nextCursor}`); + const page = await client.objects( + ObjectFilter.create({ owner: address }), + // Limit to 1 to demonstrate pagination + PaginationFilter.create({ direction: "forward", cursor: nextCursor, limit: 1 }), + ); + allObjects.push(...page.data); + if (page.pageInfo.hasNextPage) { + nextCursor = page.pageInfo.endCursor; + } else { + break; + } + } + console.log(`${allObjects.length} objects fetched:`); + for (const obj of allObjects) { + console.log(obj.objectId().toHex()); + } +} + +main(); diff --git a/bindings/typescript/examples/prepare_merge_coins.ts b/bindings/typescript/examples/prepare_merge_coins.ts new file mode 100644 index 0000000000..930bb89894 --- /dev/null +++ b/bindings/typescript/examples/prepare_merge_coins.ts @@ -0,0 +1,37 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { GraphQlClient, Address, TransactionBuilder, PtbArgument } from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + + const sender = Address.fromHex( + "0xda1820edf693ee32b5729907b9b2ec8e64980ee8c008c17e89cfb4e5ecd72151", + ); + + const coin0 = PtbArgument.objectIdFromHex( + "0xdc956de89b914e6a7fbd83caebefc8ec91be1207667ea5576386391aa82449cc", + ); + const coin1 = PtbArgument.objectIdFromHex( + "0x65beb18e282d1f33a39bffa84ff92ec4d2fec0350ba6f7e5a568afff72d651db", + ); + + const builder = new TransactionBuilder(sender).withClient(client); + + builder.mergeCoins(coin0, [coin1]); + + const txn = await builder.finish(); + + console.log("Signing Digest:", txn.signingDigestHex()); + console.log("Txn Bytes:", txn.toBase64()); + + const res = await builder.dryRun(); + if (res.error !== undefined) { + throw new Error(`Failed to merge coins: ${res.error}`); + } + + console.log("Merge coins dry run was successful!"); +} + +main(); diff --git a/bindings/typescript/examples/prepare_send_coins.ts b/bindings/typescript/examples/prepare_send_coins.ts new file mode 100644 index 0000000000..ee0f208372 --- /dev/null +++ b/bindings/typescript/examples/prepare_send_coins.ts @@ -0,0 +1,38 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { GraphQlClient, Address, TransactionBuilder, PtbArgument } from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + + const fromAddress = Address.fromHex( + "0xda1820edf693ee32b5729907b9b2ec8e64980ee8c008c17e89cfb4e5ecd72151", + ); + const toAddress = Address.fromHex( + "0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900", + ); + + // This is a coin of type + // 0xfce9c14e5f0c2b65787debb8145a33a4a2fc83152e8939000b862e174bc86bb8::cert::CERT + const coinId = PtbArgument.objectIdFromHex( + "0xe0e45ecb12ddca5f0d5192d2ee9e7f711959aa98614f9905e1e25c612ffd99a2", + ); + + const builder = new TransactionBuilder(fromAddress).withClient(client); + builder.sendCoins([coinId], toAddress, PtbArgument.u64(50000000000n)); + + const txn = await builder.finish(); + + console.log("Signing Digest:", txn.signingDigestHex()); + console.log("Txn Bytes:", txn.toBase64()); + + const res = await builder.dryRun(); + if (res.error !== undefined) { + throw new Error(`Failed to send coins: ${res.error}`); + } + + console.log("Send coins dry run was successful!"); +} + +main(); diff --git a/bindings/typescript/examples/prepare_send_iota.ts b/bindings/typescript/examples/prepare_send_iota.ts new file mode 100644 index 0000000000..9bce2cf17b --- /dev/null +++ b/bindings/typescript/examples/prepare_send_iota.ts @@ -0,0 +1,33 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { GraphQlClient, Address, TransactionBuilder, PtbArgument } from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + + const fromAddress = Address.fromHex( + "0xda1820edf693ee32b5729907b9b2ec8e64980ee8c008c17e89cfb4e5ecd72151", + ); + + const toAddress = Address.fromHex( + "0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900", + ); + + const builder = new TransactionBuilder(fromAddress).withClient(client); + builder.sendIota(toAddress, PtbArgument.u64(5000000000n)); + + const txn = await builder.finish(); + + console.log("Signing Digest:", txn.signingDigestHex()); + console.log("Txn Bytes:", txn.toBase64()); + + const res = await client.dryRunTx(txn); + if (res.error !== undefined) { + throw new Error(`Failed to send IOTA: ${res.error}`); + } + + console.log("Send IOTA dry run was successful!"); +} + +main(); diff --git a/bindings/typescript/examples/prepare_send_iota_multi.ts b/bindings/typescript/examples/prepare_send_iota_multi.ts new file mode 100644 index 0000000000..ac12d1bfb7 --- /dev/null +++ b/bindings/typescript/examples/prepare_send_iota_multi.ts @@ -0,0 +1,50 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { + GraphQlClient, + Address, + ObjectId, + TransactionBuilder, + PtbArgument, +} from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + const sender = Address.fromHex( + "0xda1820edf693ee32b5729907b9b2ec8e64980ee8c008c17e89cfb4e5ecd72151", + ); + const coinId = ObjectId.fromHex( + "0xdc956de89b914e6a7fbd83caebefc8ec91be1207667ea5576386391aa82449cc", + ); + + const recipients: [string, bigint][] = [ + ["0x111173a14c3d402c01546c54265c30cc04414c7b7ec1732412bb19066dd49d11", 1_000_000_000n], + ["0x2222b466a24399ebcf5ec0f04820812ae20fea1037c736cfec608753aa38b522", 2_000_000_000n], + ]; + + const amounts = recipients.map(([_, amount]) => PtbArgument.u64(amount)); + const labels = recipients.map((_, i) => `coin${i}`); + + const builder = new TransactionBuilder(sender).withClient(client); + + builder.splitCoins(PtbArgument.objectId(coinId), amounts, labels); + for (let i = 0; i < recipients.length; i++) { + builder.transferObjects(Address.fromHex(recipients[i][0]), [PtbArgument.assigned(labels[i])]); + } + + const txn = await builder.finish(); + + console.log("Signing Digest:", txn.signingDigestHex()); + console.log("Txn Bytes:", txn.toBase64()); + + const res = await client.dryRunTx(txn); + + if (res.error !== undefined) { + throw new Error(`Failed to send IOTA: ${res.error}`); + } + + console.log("Send IOTA dry run was successful!"); +} + +main(); diff --git a/bindings/typescript/examples/prepare_split_coins.ts b/bindings/typescript/examples/prepare_split_coins.ts new file mode 100644 index 0000000000..757cbd6f9f --- /dev/null +++ b/bindings/typescript/examples/prepare_split_coins.ts @@ -0,0 +1,50 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { + GraphQlClient, + Address, + ObjectId, + TransactionBuilder, + PtbArgument, +} from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + + const sender = Address.fromHex( + "0xda1820edf693ee32b5729907b9b2ec8e64980ee8c008c17e89cfb4e5ecd72151", + ); + + const coinId = ObjectId.fromHex( + "0xdc956de89b914e6a7fbd83caebefc8ec91be1207667ea5576386391aa82449cc", + ); + + const builder = new TransactionBuilder(sender).withClient(client); + + builder + .splitCoins( + PtbArgument.objectId(coinId), + [PtbArgument.u64(1000n), PtbArgument.u64(2000n), PtbArgument.u64(3000n)], + ["coin1", "coin2", "coin3"], + ) + .transferObjects(sender, [ + PtbArgument.assigned("coin1"), + PtbArgument.assigned("coin2"), + PtbArgument.assigned("coin3"), + ]); + + const txn = await builder.finish(); + + console.log("Signing Digest:", txn.signingDigestHex()); + console.log("Txn Bytes:", txn.toBase64()); + + const res = await builder.dryRun(); + if (res.error !== undefined) { + throw new Error(`Failed to split coins: ${res.error}`); + } + + console.log("Split coins dry run was successful!"); +} + +main(); diff --git a/bindings/typescript/examples/prepare_transfer_objects.ts b/bindings/typescript/examples/prepare_transfer_objects.ts new file mode 100644 index 0000000000..913cb4abd1 --- /dev/null +++ b/bindings/typescript/examples/prepare_transfer_objects.ts @@ -0,0 +1,43 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { GraphQlClient, Address, TransactionBuilder, PtbArgument } from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + + const fromAddress = Address.fromHex( + "0xda1820edf693ee32b5729907b9b2ec8e64980ee8c008c17e89cfb4e5ecd72151", + ); + const toAddress = Address.fromHex( + "0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900", + ); + const objsToTransfer = [ + PtbArgument.objectIdFromHex( + "0x65beb18e282d1f33a39bffa84ff92ec4d2fec0350ba6f7e5a568afff72d651db", + ), + PtbArgument.objectIdFromHex( + "0xdc956de89b914e6a7fbd83caebefc8ec91be1207667ea5576386391aa82449cc", + ), + PtbArgument.objectIdFromHex( + "0xe0e45ecb12ddca5f0d5192d2ee9e7f711959aa98614f9905e1e25c612ffd99a2", + ), + ]; + + const builder = new TransactionBuilder(fromAddress).withClient(client); + builder.transferObjects(toAddress, objsToTransfer); + + const txn = await builder.finish(); + + console.log("Signing Digest:", txn.signingDigestHex()); + console.log("Txn Bytes:", txn.toBase64()); + + const res = await client.dryRunTx(txn); + if (res.error !== undefined) { + throw new Error(`Failed to transfer objects: ${res.error}`); + } + + console.log("Transfer objects dry run was successful!"); +} + +main(); diff --git a/bindings/typescript/examples/prepare_transfer_objects_offline.ts b/bindings/typescript/examples/prepare_transfer_objects_offline.ts new file mode 100644 index 0000000000..c0324dd16d --- /dev/null +++ b/bindings/typescript/examples/prepare_transfer_objects_offline.ts @@ -0,0 +1,61 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { + GraphQlClient, + Address, + ObjectId, + TransactionBuilder, + PtbArgument, +} from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + + const fromAddress = Address.fromHex( + "0xda1820edf693ee32b5729907b9b2ec8e64980ee8c008c17e89cfb4e5ecd72151", + ); + const toAddress = Address.fromHex( + "0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900", + ); + const objIds = [ + ObjectId.fromHex("0x65beb18e282d1f33a39bffa84ff92ec4d2fec0350ba6f7e5a568afff72d651db"), + ObjectId.fromHex("0xdc956de89b914e6a7fbd83caebefc8ec91be1207667ea5576386391aa82449cc"), + ObjectId.fromHex("0xe0e45ecb12ddca5f0d5192d2ee9e7f711959aa98614f9905e1e25c612ffd99a2"), + ]; + const objsToTransfer = []; + for (const objId of objIds) { + const obj = await client.object(objId); + if (obj === undefined) { + throw new Error(`Missing object: ${objId}`); + } + objsToTransfer.push(PtbArgument.objectRef(obj.objectRef())); + } + + const gasCoinId = ObjectId.fromHex( + "0x65beb18e282d1f33a39bffa84ff92ec4d2fec0350ba6f7e5a568afff72d651db", + ); + const gasCoin = await client.object(gasCoinId); + if (gasCoin === undefined) { + throw new Error(`Missing gas coin: ${gasCoinId}`); + } + const gasPrice = (await client.referenceGasPrice()) ?? 100n; + + const builder = new TransactionBuilder(fromAddress); + builder.transferObjects(toAddress, objsToTransfer); + builder.gas([gasCoin.objectRef()]).gasPrice(gasPrice).gasBudget(500000000n); + + const txn = builder.finish(); + + console.log("Signing Digest:", txn.signingDigestHex()); + console.log("Txn Bytes:", txn.toBase64()); + + const res = await client.dryRunTx(txn); + if (res.error !== undefined) { + throw new Error(`Failed to transfer objects: ${res.error}`); + } + + console.log("Transfer objects dry run was successful!"); +} + +main(); diff --git a/bindings/typescript/examples/publish_upgrade.ts b/bindings/typescript/examples/publish_upgrade.ts new file mode 100644 index 0000000000..7a3bb502b8 --- /dev/null +++ b/bindings/typescript/examples/publish_upgrade.ts @@ -0,0 +1,193 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +// This example allows you to publish any Move package by compiling it +// first using the `iota` binary. For demonstration purposes this example +// immediately upgrades the package after publishing it. +// +// ```bash +// cd /path/to/your/move/package +// export COMPILED_PACKAGE=$(iota move build --dump-bytecode-as-base64) +// ``` +// +// With this example it is necessary to run a localnet: +// +// ```sh +// iota start --with-faucet --with-graphql --committee-size 1 --force-regenesis +// ``` + +import { + GraphQlClient, + Address, + TransactionBuilder, + TransactionSigner, + Ed25519PrivateKey, + PtbArgument, + Identifier, + FaucetClient, + MovePackageData, + StructTag, + UpgradePolicy, + WaitForTx, +} from "../lib"; + +const PRECOMPILED_PACKAGE = + '{"modules":["oRzrCwYAAAAKAQAIAggUAxw+BFoGBWBBB6EBwQEI4gJACqIDGgy8A5cBDdMEBgAKAQ0BEwEUAAIMAAABCAAAAAgAAQQEAAMDAgAACAABAAAJAgMAABACAwAAEgQDAAAMBQYAAAYHAQAAEQgBAAAFCQoAAQsACwACDg8BAQwCEw8BAQgDDwwNAAoOCgYJBgEHCAQAAQYIAAEDAQYIAQQHCAEDAwcIBAEIAAQDAwUHCAQDCAAFBwgEAgMHCAQBCAIBCAMBBggEAQUBCAECCQAFBkNvbmZpZwVGb3JnZQVTd29yZAlUeENvbnRleHQDVUlEDWNyZWF0ZV9jb25maWcMY3JlYXRlX3N3b3JkAmlkBGluaXQFbWFnaWMJbXlfbW9kdWxlA25ldwluZXdfc3dvcmQGb2JqZWN0D3B1YmxpY190cmFuc2ZlcgZzZW5kZXIIc3RyZW5ndGgOc3dvcmRfdHJhbnNmZXIOc3dvcmRzX2NyZWF0ZWQIdHJhbnNmZXIKdHhfY29udGV4dAV2YWx1ZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAgMHCAMJAxADAQICBwgDEgMCAgIHCAMVAwAAAAABCQoAEQgGAAAAAAAAAAASAQsALhELOAACAQEAAAEECwAQABQCAgEAAAEECwAQARQCAwEAAAEECwAQAhQCBAEAAAEOCgAQAhQGAQAAAAAAAAAWCwAPAhULAxEICwELAhIAAgUBAAABCAsDEQgLAAsBEgALAjgBAgYBAAABBAsACwE4AgIHAQAAAQULAREICwASAgIAAQACAQEA"],"dependencies":["0x0000000000000000000000000000000000000000000000000000000000000002","0x0000000000000000000000000000000000000000000000000000000000000001"],"digest":[246,127,102,77,186,19,68,12,161,181,56,248,210,0,91,211,245,251,165,152,0,197,250,135,171,37,177,240,133,76,122,124]}'; + +async function sleep(ms: number) { + return new Promise((resolve) => setTimeout(resolve, ms)); +} + +async function main() { + // Read and parse the compiled package, or use the default package + let packageDataJson = process.env.COMPILED_PACKAGE; + if (!packageDataJson) { + console.log("No compiled package found in env var. Using default."); + packageDataJson = PRECOMPILED_PACKAGE; + } else { + console.log("Using custom Move package found in env var."); + } + + const packageData = MovePackageData.fromJson(packageDataJson); + const modules = packageData.modules(); + console.log(`Modules: ${modules.length}`); + const dependencies = packageData.dependencies(); + console.log(`Dependencies: ${dependencies.length}`); + const digest = packageData.digest(); + console.log(`Digest: ${digest.toBase58()}`); + + // Create a random private key to derive a sender address and for signing + const privateKey = Ed25519PrivateKey.generate(); + const sender = privateKey.publicKey().deriveAddress(); + console.log(`Sender: ${sender.toHex()}`); + + const client = GraphQlClient.newLocalnet(); + + // Fund the sender address for gas payment + const faucet = FaucetClient.newLocalnet(); + const faucetReceipt = await faucet.requestAndWaitForFinalized(sender, client); + if (faucetReceipt === undefined) { + throw new Error("Failed to request coins from faucet"); + } + + // Build the `publish` PTB + let builder = new TransactionBuilder(sender).withClient(client); + // Publish the package and receive the upgrade cap in return + builder.publish(packageData, "upgrade_cap"); + // Transfer the upgrade cap to the sender address + builder.transferObjects(sender, [PtbArgument.assigned("upgrade_cap")]); + let tx = await builder.finish(); + + // Perform a dry-run first to check if everything is correct + console.log("> Publishing package (dry run):"); + let result = await client.dryRunTx(tx, false); + if (result.error !== undefined) { + throw new Error(`Dry run failed: ${result.error}`); + } + if (result.effects === undefined) { + throw new Error("Dry run failed: no effects"); + } + console.log("Success"); + + // Sign and execute the transaction (publish the package) + console.log("> Publishing package:"); + let sig = privateKey.signTransaction(tx); + let effects = await client.executeTx([sig], tx, "finalized"); + console.log("Success"); + + // Wait some time for the indexer to process the tx + await sleep(3000); + + // Resolve UpgradeCap and PackageId via the client + let upgradeCap: any = null; + let packageId: any = null; + for (const changedObj of effects.asV1().changedObjects) { + if (changedObj.outputState.tag === "objectWrite") { + const objectId = changedObj.objectId; + const obj = await client.object(objectId, undefined); + if (obj === undefined) { + throw new Error(`Missing object ${objectId.toHex()}`); + } + if (String(obj.asStruct().structType) === String(StructTag.newUpgradeCap())) { + console.log(`UpgradeCap: ${objectId.toHex()}`); + console.log(`UpgradeCapOwner: ${changedObj.outputState.inner.owner.asAddress().toHex()}`); + upgradeCap = objectId; + } + } else if (changedObj.outputState.tag === "packageWrite") { + packageId = changedObj.objectId; + console.log(`Package ID: ${packageId.toHex()}`); + const version = changedObj.outputState.inner.version; + console.log(`Package version: ${version}`); + } + } + + if (upgradeCap === undefined) { + throw new Error("Missing upgrade cap"); + } + if (packageId === undefined) { + throw new Error("Missing package id"); + } + + // Build the `upgrade` PTB + builder = new TransactionBuilder(sender).withClient(client); + + // Authorize the upgrade by providing the upgrade cap object id to receive an upgrade + // ticket + builder.moveCall( + Address.framework(), + new Identifier("package"), + new Identifier("authorize_upgrade"), + [ + PtbArgument.objectId(upgradeCap), + PtbArgument.u8(UpgradePolicy.compatible().asU8()), + PtbArgument.u8Vec(digest.toBytes()), + ], + [], + ["upgrade_ticket"], + ); + + // Upgrade the package to receive an upgrade receipt + builder.upgrade(packageId, packageData, PtbArgument.assigned("upgrade_ticket"), "upgrade_receipt"); + + // Commit the upgrade using the receipt + builder.moveCall( + Address.framework(), + new Identifier("package"), + new Identifier("commit_upgrade"), + [PtbArgument.objectId(upgradeCap), PtbArgument.assigned("upgrade_receipt")], + [], + [], + ); + + tx = await builder.finish(); + + // Perform a dry-run first to check if everything is correct + console.log("> Upgrading package (dry run):"); + result = await client.dryRunTx(tx, false); + if (result.error !== undefined) { + throw new Error(`Dry run failed: ${result.error}`); + } + if (result.effects === undefined) { + throw new Error("Dry run failed: no effects"); + } + console.log("Success"); + + // Sign and execute the transaction (upgrade the package) + console.log("> Upgrading package:"); + sig = privateKey.signTransaction(tx); + effects = await client.executeTx([sig], tx); + console.log("Success"); + + // Wait some time for the indexer to process the tx + await sleep(3000); + + // Print the new package version (should now be 2) + for (const changedObj of effects.asV1().changedObjects) { + if (changedObj.outputState.tag === "packageWrite") { + console.log(`New Package ID: ${changedObj.objectId.toHex()}`); + console.log(`New Package version: ${changedObj.outputState.inner.version}`); + } + } +} + +main(); diff --git a/bindings/typescript/examples/release/example.ts b/bindings/typescript/examples/release/example.ts new file mode 100644 index 0000000000..2dbbcd4c55 --- /dev/null +++ b/bindings/typescript/examples/release/example.ts @@ -0,0 +1,13 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { GraphQlClient } from "@iota/sdk"; + +async function main() { + const client = GraphQlClient.newTestnet(); + + const chainId = await client.chainId(); + console.log("Chain ID:", chainId); +} + +main(); diff --git a/bindings/typescript/examples/release/package.json b/bindings/typescript/examples/release/package.json new file mode 100644 index 0000000000..f595e4c9a0 --- /dev/null +++ b/bindings/typescript/examples/release/package.json @@ -0,0 +1,11 @@ +{ + "name": "iota-sdk-typescript-release-example", + "version": "1.0.0", + "private": true, + "dependencies": { + "@iota/sdk": "latest" + }, + "devDependencies": { + "tsx": "^4.19.0" + } +} diff --git a/bindings/typescript/examples/sign_send_iota.ts b/bindings/typescript/examples/sign_send_iota.ts new file mode 100644 index 0000000000..731e18fb11 --- /dev/null +++ b/bindings/typescript/examples/sign_send_iota.ts @@ -0,0 +1,52 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { + GraphQlClient, + Address, + TransactionBuilder, + Ed25519PrivateKey, + PtbArgument, + UserSignature, + FaucetClient, + hexEncode, +} from "../lib"; + +async function main() { + // Amount to send in nanos + const amount = 1000n; + const recipientAddress = Address.fromHex( + "0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900", + ); + + const privateKey = new Ed25519PrivateKey(new Uint8Array(32)); + const publicKey = privateKey.publicKey(); + const senderAddress = publicKey.deriveAddress(); + console.log(`Sender address: ${senderAddress.toHex()}`); + + const client = GraphQlClient.newLocalnet(); + + // Request funds from faucet + const faucet = FaucetClient.newLocalnet(); + await faucet.requestAndWaitForFinalized(senderAddress, client); + + const builder = new TransactionBuilder(senderAddress).withClient(client); + builder.sendIota(recipientAddress, PtbArgument.u64(amount)); + const txn = await builder.finish(); + + const dryRunResult = await client.dryRunTx(txn); + if (dryRunResult.error !== undefined) { + throw new Error(`Dry run failed: ${dryRunResult.error}`); + } + + const signature = privateKey.trySignSimple(txn.signingDigest()); + const userSignature = UserSignature.newSimple(signature); + + const effects = await client.executeTx([userSignature], txn); + + console.log(`Digest: ${hexEncode(effects.digest().toBytes())}`); + console.log(`Transaction status: ${effects.asV1().status}`); + console.log(`Effects: ${effects.asV1()}`); +} + +main(); diff --git a/bindings/typescript/examples/stake.ts b/bindings/typescript/examples/stake.ts new file mode 100644 index 0000000000..9119f8ddee --- /dev/null +++ b/bindings/typescript/examples/stake.ts @@ -0,0 +1,33 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { GraphQlClient, Address, TransactionBuilder, PtbArgument } from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + + const myAddress = Address.fromHex( + "0xda1820edf693ee32b5729907b9b2ec8e64980ee8c008c17e89cfb4e5ecd72151", + ); + + const validators = await client.activeValidators(); + if (validators.data.length === 0) { + throw new Error("no validators found"); + } + const validator = validators.data[0]; + + console.log("Staking to validator", validator.name || "with no name"); + + const builder = new TransactionBuilder(myAddress).withClient(client); + + builder.stake(PtbArgument.u64(1000000000n), validator.address); + + const res = await builder.dryRun(); + if (res.error !== undefined) { + throw new Error(`Failed to stake: ${res.error}`); + } + + console.log("Stake dry run was successful!"); +} + +main(); diff --git a/bindings/typescript/examples/transaction_signer_callback.ts b/bindings/typescript/examples/transaction_signer_callback.ts new file mode 100644 index 0000000000..43bb8472a8 --- /dev/null +++ b/bindings/typescript/examples/transaction_signer_callback.ts @@ -0,0 +1,61 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { + GraphQlClient, + Address, + TransactionBuilder, + TransactionSigner, + TransactionSignerFn, + TransactionSignerFnOutput, + Ed25519PrivateKey, + PtbArgument, + FaucetClient, + hexEncode, + Transaction, + WaitForTx, +} from "../lib"; + +class AsyncSigner implements TransactionSignerFn { + private key: Ed25519PrivateKey; + + constructor(key: Ed25519PrivateKey) { + this.key = key; + } + + async sign(transaction: Transaction): Promise { + return TransactionSignerFnOutput.create({ + signature: this.key.signTransaction(transaction), + }); + } +} + +async function main() { + const amount = 1000n; + const recipientAddress = Address.fromHex( + "0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900", + ); + + const privateKey = new Ed25519PrivateKey(new Uint8Array(32)); + const publicKey = privateKey.publicKey(); + const senderAddress = publicKey.deriveAddress(); + console.log(`Sender address: ${senderAddress.toHex()}`); + + const client = GraphQlClient.newLocalnet(); + + // Request funds from faucet + const faucet = FaucetClient.newLocalnet(); + await faucet.requestAndWaitForFinalized(senderAddress, client); + + const builder = new TransactionBuilder(senderAddress).withClient(client); + builder.sendIota(recipientAddress, PtbArgument.u64(amount)); + + const signer = new TransactionSigner(new AsyncSigner(privateKey)); + const effects = await builder.execute(signer, "finalized"); + + console.log(`Digest: ${hexEncode(effects.digest().toBytes())}`); + console.log(`Transaction status: ${effects.asV1().status}`); + console.log(`Effects: ${effects.asV1()}`); +} + +main(); diff --git a/bindings/typescript/examples/transactions_with_function.ts b/bindings/typescript/examples/transactions_with_function.ts new file mode 100644 index 0000000000..2ed6635eab --- /dev/null +++ b/bindings/typescript/examples/transactions_with_function.ts @@ -0,0 +1,16 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { GraphQlClient, TransactionsFilter } from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + const transactions = await client.transactions( + TransactionsFilter.create({ function: "0x3::iota_system::request_add_stake" }), + ); + for (const transaction of transactions.data) { + console.log("Digest:", transaction.transaction.digest().toBase58()); + } +} + +main(); diff --git a/bindings/typescript/examples/transactions_with_shared.ts b/bindings/typescript/examples/transactions_with_shared.ts new file mode 100644 index 0000000000..1685947d5a --- /dev/null +++ b/bindings/typescript/examples/transactions_with_shared.ts @@ -0,0 +1,22 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { GraphQlClient, ObjectId, TransactionsFilter } from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + + const sharedObjId = ObjectId.fromHex( + "0x7cab491740d51e0d75b26bf9984e49ba2e32a2d0694cabcee605543ed13c7dec", + ); + + const transactions = await client.transactions( + TransactionsFilter.create({ inputObject: sharedObjId }), + ); + + for (const transaction of transactions.data) { + console.log("Digest:", transaction.transaction.digest().toBase58()); + } +} + +main(); diff --git a/bindings/typescript/examples/tx_command_results.ts b/bindings/typescript/examples/tx_command_results.ts new file mode 100644 index 0000000000..ccd9d9dc43 --- /dev/null +++ b/bindings/typescript/examples/tx_command_results.ts @@ -0,0 +1,69 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { + GraphQlClient, + Address, + TransactionBuilder, + Identifier, + PtbArgument, +} from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + + const sender = Address.fromHex( + "0xda1820edf693ee32b5729907b9b2ec8e64980ee8c008c17e89cfb4e5ecd72151", + ); + + const builder = new TransactionBuilder(sender).withClient(client); + + const packageAddr = Address.std(); + const moduleName = new Identifier("u64"); + const functionName = new Identifier("max"); + + builder.moveCall( + packageAddr, + moduleName, + functionName, + [PtbArgument.u64(0n), PtbArgument.u64(1000n)], + [], + // Assign a name to the result of this command + ["res0"], + ); + + builder.moveCall( + packageAddr, + moduleName, + functionName, + [PtbArgument.u64(1000n), PtbArgument.u64(2000n)], + [], + // Assign a name to the result of this command + ["res1"], + ); + + builder.splitCoins( + PtbArgument.gas(), + // Use the assigned results of previous commands as arguments + [PtbArgument.assigned("res0"), PtbArgument.assigned("res1")], + // For nested results, a tuple or vec can be used to assign them + ["coin0", "coin1"], + ); + + // Use assigned results as arguments + builder.transferObjects(sender, [PtbArgument.assigned("coin0"), PtbArgument.assigned("coin1")]); + + const txn = await builder.finish(); + + console.log("Signing Digest:", txn.signingDigestHex()); + console.log("Txn Bytes:", txn.toBase64()); + + const res = await client.dryRunTx(txn, false); + if (res.error !== undefined) { + throw new Error(`Failed to send tx: ${res.error}`); + } + + console.log("Tx dry run was successful!"); +} + +main(); diff --git a/bindings/typescript/examples/unstake.ts b/bindings/typescript/examples/unstake.ts new file mode 100644 index 0000000000..5e8ff3a04d --- /dev/null +++ b/bindings/typescript/examples/unstake.ts @@ -0,0 +1,35 @@ +// Copyright (c) 2025 IOTA Stiftung +// SPDX-License-Identifier: Apache-2.0 + +import { + GraphQlClient, + TransactionBuilder, + PtbArgument, + ObjectFilter, + StructTag, +} from "../lib"; + +async function main() { + const client = GraphQlClient.newTestnet(); + + const stakedIotas = await client.objects( + ObjectFilter.create({ typeTag: String(StructTag.newStakedIota()) }), + ); + if (stakedIotas.data.length === 0) { + throw new Error("no staked iotas found"); + } + const stakedIota = stakedIotas.data[0]; + + const builder = new TransactionBuilder(stakedIota.owner().asAddress()).withClient(client); + + builder.unstake(PtbArgument.objectId(stakedIota.objectId())); + + const res = await builder.dryRun(); + if (res.error !== undefined) { + throw new Error(`Failed to unstake: ${res.error}`); + } + + console.log("Unstake dry run was successful!"); +} + +main(); diff --git a/bindings/typescript/lib/index.ts b/bindings/typescript/lib/index.ts new file mode 100644 index 0000000000..9d233337b2 --- /dev/null +++ b/bindings/typescript/lib/index.ts @@ -0,0 +1,2 @@ +export * from './iota-sdk-ffi-node'; + diff --git a/bindings/typescript/lib/iota-sdk-ffi-node.ts b/bindings/typescript/lib/iota-sdk-ffi-node.ts new file mode 100644 index 0000000000..02953849f8 --- /dev/null +++ b/bindings/typescript/lib/iota-sdk-ffi-node.ts @@ -0,0 +1,60919 @@ + + + + + + +import { + type UniffiByteArray, + type UniffiDuration, + AbstractFfiConverterByteArray, + FfiConverterInt8, + FfiConverterInt16, + FfiConverterInt32, + FfiConverterInt64, + FfiConverterFloat32, + FfiConverterFloat64, + FfiConverterUInt8, + FfiConverterUInt16, + FfiConverterUInt32, + FfiConverterUInt64, + FfiConverterBool, + FfiConverterDuration, + UniffiTimestamp, + FfiConverterTimestamp, + FfiConverterOptional, + FfiConverterArray, + FfiConverterMap, + FfiConverterArrayBuffer, + FfiConverterObject, + RustBuffer, + UniffiError, + UniffiInternalError, + type UniffiRustCaller, + type UniffiRustCallStatus, + UniffiAbstractObject, + UniffiRustArcPtr, + UnsafeMutableRawPointer, + UniffiObjectFactory, + uniffiCreateFfiConverterString, + uniffiCreateRecord, + uniffiRustCallAsync, + uniffiTypeNameSymbol, + variantOrdinalSymbol, + destructorGuardSymbol, + pointerLiteralSymbol, +} from 'uniffi-bindgen-react-native'; + +import { + DataType, + type JsExternal, + open, /* close, */ + define, + load, + arrayConstructor, + funcConstructor, + restorePointer, + wrapPointer, + unwrapPointer, + createPointer, + freePointer, + isNullPointer, + PointerType, + type FieldType, +} from 'ffi-rs'; + + +import FFI_DYNAMIC_LIB, { + uniffiCaller, + FfiConverterString, + + type UniffiRustBufferStruct, + type UniffiForeignBytes, + UniffiRustBufferValue, + type UniffiRustCallStatusStruct, + type UniffiCallbackRustFutureContinuationCallback, + type UniffiCallbackForeignFutureFree, + type UniffiCallbackCallbackInterfaceFree,type UniffiForeignFuture,type UniffiForeignFutureStructU8, + type UniffiCallbackForeignFutureCompleteU8,type UniffiForeignFutureStructI8, + type UniffiCallbackForeignFutureCompleteI8,type UniffiForeignFutureStructU16, + type UniffiCallbackForeignFutureCompleteU16,type UniffiForeignFutureStructI16, + type UniffiCallbackForeignFutureCompleteI16,type UniffiForeignFutureStructU32, + type UniffiCallbackForeignFutureCompleteU32,type UniffiForeignFutureStructI32, + type UniffiCallbackForeignFutureCompleteI32,type UniffiForeignFutureStructU64, + type UniffiCallbackForeignFutureCompleteU64,type UniffiForeignFutureStructI64, + type UniffiCallbackForeignFutureCompleteI64,type UniffiForeignFutureStructF32, + type UniffiCallbackForeignFutureCompleteF32,type UniffiForeignFutureStructF64, + type UniffiCallbackForeignFutureCompleteF64,type UniffiForeignFutureStructPointer, + type UniffiCallbackForeignFutureCompletePointer,type UniffiForeignFutureStructRustBuffer, + type UniffiCallbackForeignFutureCompleteRustBuffer,type UniffiForeignFutureStructVoid, + type UniffiCallbackForeignFutureCompleteVoid, + type UniffiCallbackCallbackInterfaceTransactionSignerFnMethod0,type UniffiVTableCallbackInterfaceTransactionSignerFn, +} from './iota-sdk-ffi-sys'; + + +// ========== +// Record definitions: +// ========== + + + +/** + * A new Jwk + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * active-jwk = jwk-id jwk u64 + * ``` + */ +export type ActiveJwk = { +/** + * Identifier used to uniquely identify a Jwk + */jwkId: JwkId; +/** + * The Jwk + */jwk: Jwk; +/** + * Most recent epoch in which the jwk was validated + */epoch: /*u64*/bigint; +} + +export const ActiveJwk = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link ActiveJwk}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link ActiveJwk}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeActiveJwk = (() => { + type TypeName = ActiveJwk; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + jwkId: FfiConverterTypeJwkId.read(from), + jwk: FfiConverterTypeJwk.read(from), + epoch: FfiConverterUInt64.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypeJwkId.write(value.jwkId, into); + FfiConverterTypeJwk.write(value.jwk, into); + FfiConverterUInt64.write(value.epoch, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypeJwkId.allocationSize(value.jwkId) + + FfiConverterTypeJwk.allocationSize(value.jwk) + + FfiConverterUInt64.allocationSize(value.epoch) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * Expire old JWKs + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * authenticator-state-expire = u64 u64 + * ``` + */ +export type AuthenticatorStateExpire = { +/** + * Expire JWKs that have a lower epoch than this + */minEpoch: /*u64*/bigint; +/** + * The initial version of the authenticator object that it was shared at. + */authenticatorObjInitialSharedVersion: /*u64*/bigint; +} + +export const AuthenticatorStateExpire = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link AuthenticatorStateExpire}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link AuthenticatorStateExpire}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeAuthenticatorStateExpire = (() => { + type TypeName = AuthenticatorStateExpire; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + minEpoch: FfiConverterUInt64.read(from), + authenticatorObjInitialSharedVersion: FfiConverterUInt64.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterUInt64.write(value.minEpoch, into); + FfiConverterUInt64.write(value.authenticatorObjInitialSharedVersion, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterUInt64.allocationSize(value.minEpoch) + + FfiConverterUInt64.allocationSize(value.authenticatorObjInitialSharedVersion) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * Update the set of valid JWKs + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * authenticator-state-update = u64 ; epoch + * u64 ; round + * (vector active-jwk) + * u64 ; initial version of the authenticator object + * ``` + */ +export type AuthenticatorStateUpdateV1 = { +/** + * Epoch of the authenticator state update transaction + */epoch: /*u64*/bigint; +/** + * Consensus round of the authenticator state update + */round: /*u64*/bigint; +/** + * newly active jwks + */newActiveJwks: Array;authenticatorObjInitialSharedVersion: /*u64*/bigint; +} + +export const AuthenticatorStateUpdateV1 = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link AuthenticatorStateUpdateV1}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link AuthenticatorStateUpdateV1}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeAuthenticatorStateUpdateV1 = (() => { + type TypeName = AuthenticatorStateUpdateV1; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + epoch: FfiConverterUInt64.read(from), + round: FfiConverterUInt64.read(from), + newActiveJwks: (new FfiConverterArray(FfiConverterTypeActiveJwk)).read(from), + authenticatorObjInitialSharedVersion: FfiConverterUInt64.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterUInt64.write(value.epoch, into); + FfiConverterUInt64.write(value.round, into); + (new FfiConverterArray(FfiConverterTypeActiveJwk)).write(value.newActiveJwks, into); + FfiConverterUInt64.write(value.authenticatorObjInitialSharedVersion, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterUInt64.allocationSize(value.epoch) + + FfiConverterUInt64.allocationSize(value.round) + + (new FfiConverterArray(FfiConverterTypeActiveJwk)).allocationSize(value.newActiveJwks) + + FfiConverterUInt64.allocationSize(value.authenticatorObjInitialSharedVersion) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type BatchSendStatus = {status: BatchSendStatusType;transferredGasObjects?: FaucetReceipt; +} + +export const BatchSendStatus = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link BatchSendStatus}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link BatchSendStatus}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeBatchSendStatus = (() => { + type TypeName = BatchSendStatus; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + status: FfiConverterTypeBatchSendStatusType.read(from), + transferredGasObjects: (new FfiConverterOptional(FfiConverterTypeFaucetReceipt)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypeBatchSendStatusType.write(value.status, into); + (new FfiConverterOptional(FfiConverterTypeFaucetReceipt)).write(value.transferredGasObjects, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypeBatchSendStatusType.allocationSize(value.status) + + (new FfiConverterOptional(FfiConverterTypeFaucetReceipt)).allocationSize(value.transferredGasObjects) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * Input/output state of an object that was changed during execution + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * changed-object = object-id object-in object-out id-operation + * ``` + */ +export type ChangedObject = { +/** + * Id of the object + */objectId: ObjectId; +/** + * State of the object in the store prior to this transaction. + */inputState: ObjectIn; +/** + * State of the object in the store after this transaction. + */outputState: ObjectOut; +/** + * Whether this object ID is created or deleted in this transaction. + * This information isn't required by the protocol but is useful for + * providing more detailed semantics on object changes. + */idOperation: IdOperation; +} + +export const ChangedObject = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link ChangedObject}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link ChangedObject}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeChangedObject = (() => { + type TypeName = ChangedObject; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + objectId: FfiConverterTypeObjectId.read(from), + inputState: FfiConverterTypeObjectIn.read(from), + outputState: FfiConverterTypeObjectOut.read(from), + idOperation: FfiConverterTypeIdOperation.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypeObjectId.write(value.objectId, into); + FfiConverterTypeObjectIn.write(value.inputState, into); + FfiConverterTypeObjectOut.write(value.outputState, into); + FfiConverterTypeIdOperation.write(value.idOperation, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypeObjectId.allocationSize(value.objectId) + + FfiConverterTypeObjectIn.allocationSize(value.inputState) + + FfiConverterTypeObjectOut.allocationSize(value.outputState) + + FfiConverterTypeIdOperation.allocationSize(value.idOperation) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * A page of items returned by the GraphQL server. + */ +export type CheckpointSummaryPage = { +/** + * Information about the page, such as the cursor and whether there are + * more pages. + */pageInfo: PageInfo; +/** + * The data returned by the server. + */data: Array; +} + +export const CheckpointSummaryPage = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link CheckpointSummaryPage}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link CheckpointSummaryPage}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeCheckpointSummaryPage = (() => { + type TypeName = CheckpointSummaryPage; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + pageInfo: FfiConverterTypePageInfo.read(from), + data: (new FfiConverterArray(FfiConverterTypeCheckpointSummary)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypePageInfo.write(value.pageInfo, into); + (new FfiConverterArray(FfiConverterTypeCheckpointSummary)).write(value.data, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypePageInfo.allocationSize(value.pageInfo) + + (new FfiConverterArray(FfiConverterTypeCheckpointSummary)).allocationSize(value.data) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type CoinInfo = {amount: /*u64*/bigint;id: ObjectId;transferTxDigest: Digest; +} + +export const CoinInfo = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link CoinInfo}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link CoinInfo}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeCoinInfo = (() => { + type TypeName = CoinInfo; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + amount: FfiConverterUInt64.read(from), + id: FfiConverterTypeObjectId.read(from), + transferTxDigest: FfiConverterTypeDigest.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterUInt64.write(value.amount, into); + FfiConverterTypeObjectId.write(value.id, into); + FfiConverterTypeDigest.write(value.transferTxDigest, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterUInt64.allocationSize(value.amount) + + FfiConverterTypeObjectId.allocationSize(value.id) + + FfiConverterTypeDigest.allocationSize(value.transferTxDigest) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * The coin metadata associated with the given coin type. + */ +export type CoinMetadata = { +/** + * The CoinMetadata object ID. + */address: ObjectId; +/** + * The number of decimal places used to represent the token. + */decimals?: /*i32*/number; +/** + * Optional description of the token, provided by the creator of the token. + */description?: string; +/** + * Icon URL of the coin. + */iconUrl?: string; +/** + * Full, official name of the token. + */name?: string; +/** + * The token's identifying abbreviation. + */symbol?: string; +/** + * The overall quantity of tokens that will be issued. + */supply?: string; +/** + * Version of the token. + */version: /*u64*/bigint; +} + +export const CoinMetadata = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link CoinMetadata}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link CoinMetadata}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeCoinMetadata = (() => { + type TypeName = CoinMetadata; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + address: FfiConverterTypeObjectId.read(from), + decimals: (new FfiConverterOptional(FfiConverterInt32)).read(from), + description: (new FfiConverterOptional(FfiConverterString)).read(from), + iconUrl: (new FfiConverterOptional(FfiConverterString)).read(from), + name: (new FfiConverterOptional(FfiConverterString)).read(from), + symbol: (new FfiConverterOptional(FfiConverterString)).read(from), + supply: (new FfiConverterOptional(FfiConverterString)).read(from), + version: FfiConverterUInt64.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypeObjectId.write(value.address, into); + (new FfiConverterOptional(FfiConverterInt32)).write(value.decimals, into); + (new FfiConverterOptional(FfiConverterString)).write(value.description, into); + (new FfiConverterOptional(FfiConverterString)).write(value.iconUrl, into); + (new FfiConverterOptional(FfiConverterString)).write(value.name, into); + (new FfiConverterOptional(FfiConverterString)).write(value.symbol, into); + (new FfiConverterOptional(FfiConverterString)).write(value.supply, into); + FfiConverterUInt64.write(value.version, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypeObjectId.allocationSize(value.address) + + (new FfiConverterOptional(FfiConverterInt32)).allocationSize(value.decimals) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.description) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.iconUrl) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.name) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.symbol) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.supply) + + FfiConverterUInt64.allocationSize(value.version) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * A page of items returned by the GraphQL server. + */ +export type CoinPage = { +/** + * Information about the page, such as the cursor and whether there are + * more pages. + */pageInfo: PageInfo; +/** + * The data returned by the server. + */data: Array; +} + +export const CoinPage = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link CoinPage}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link CoinPage}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeCoinPage = (() => { + type TypeName = CoinPage; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + pageInfo: FfiConverterTypePageInfo.read(from), + data: (new FfiConverterArray(FfiConverterTypeCoin)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypePageInfo.write(value.pageInfo, into); + (new FfiConverterArray(FfiConverterTypeCoin)).write(value.data, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypePageInfo.allocationSize(value.pageInfo) + + (new FfiConverterArray(FfiConverterTypeCoin)).allocationSize(value.data) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * Effects of a single command in the dry run, including mutated references + * and return values. + */ +export type DryRunEffect = { +/** + * Changes made to arguments that were mutably borrowed by this command. + */mutatedReferences: Array; +/** + * Return results of this command. + */returnValues: Array; +} + +export const DryRunEffect = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link DryRunEffect}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link DryRunEffect}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeDryRunEffect = (() => { + type TypeName = DryRunEffect; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + mutatedReferences: (new FfiConverterArray(FfiConverterTypeDryRunMutation)).read(from), + returnValues: (new FfiConverterArray(FfiConverterTypeDryRunReturn)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + (new FfiConverterArray(FfiConverterTypeDryRunMutation)).write(value.mutatedReferences, into); + (new FfiConverterArray(FfiConverterTypeDryRunReturn)).write(value.returnValues, into); + + } + allocationSize(value: TypeName): number { + return ( + (new FfiConverterArray(FfiConverterTypeDryRunMutation)).allocationSize(value.mutatedReferences) + + (new FfiConverterArray(FfiConverterTypeDryRunReturn)).allocationSize(value.returnValues) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * A mutation to an argument that was mutably borrowed by a command. + */ +export type DryRunMutation = { +/** + * The transaction argument that was mutated. + */input: TransactionArgument; +/** + * The Move type of the mutated value. + */typeTag: TypeTag; +/** + * The BCS representation of the mutated value. + */bcs: ArrayBuffer; +} + +export const DryRunMutation = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link DryRunMutation}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link DryRunMutation}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeDryRunMutation = (() => { + type TypeName = DryRunMutation; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + input: FfiConverterTypeTransactionArgument.read(from), + typeTag: FfiConverterTypeTypeTag.read(from), + bcs: FfiConverterArrayBuffer.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypeTransactionArgument.write(value.input, into); + FfiConverterTypeTypeTag.write(value.typeTag, into); + FfiConverterArrayBuffer.write(value.bcs, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypeTransactionArgument.allocationSize(value.input) + + FfiConverterTypeTypeTag.allocationSize(value.typeTag) + + FfiConverterArrayBuffer.allocationSize(value.bcs) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * The result of a simulation (dry run), which includes the effects of the + * transaction, any errors that may have occurred, and intermediate results for + * each command. + */ +export type DryRunResult = { +/** + * The error that occurred during dry run execution, if any. + */error?: string; +/** + * The intermediate results for each command of the dry run execution, + * including contents of mutated references and return values. + */results: Array; +/** + * The transaction block representing the dry run execution. + */transaction?: SignedTransaction; +/** + * The effects of the transaction execution. + */effects?: TransactionEffects; +} + +export const DryRunResult = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link DryRunResult}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link DryRunResult}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeDryRunResult = (() => { + type TypeName = DryRunResult; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + error: (new FfiConverterOptional(FfiConverterString)).read(from), + results: (new FfiConverterArray(FfiConverterTypeDryRunEffect)).read(from), + transaction: (new FfiConverterOptional(FfiConverterTypeSignedTransaction)).read(from), + effects: (new FfiConverterOptional(FfiConverterTypeTransactionEffects)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + (new FfiConverterOptional(FfiConverterString)).write(value.error, into); + (new FfiConverterArray(FfiConverterTypeDryRunEffect)).write(value.results, into); + (new FfiConverterOptional(FfiConverterTypeSignedTransaction)).write(value.transaction, into); + (new FfiConverterOptional(FfiConverterTypeTransactionEffects)).write(value.effects, into); + + } + allocationSize(value: TypeName): number { + return ( + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.error) + + (new FfiConverterArray(FfiConverterTypeDryRunEffect)).allocationSize(value.results) + + (new FfiConverterOptional(FfiConverterTypeSignedTransaction)).allocationSize(value.transaction) + + (new FfiConverterOptional(FfiConverterTypeTransactionEffects)).allocationSize(value.effects) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * A return value from a command in the dry run. + */ +export type DryRunReturn = { +/** + * The Move type of the return value. + */typeTag: TypeTag; +/** + * The BCS representation of the return value. + */bcs: ArrayBuffer; +} + +export const DryRunReturn = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link DryRunReturn}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link DryRunReturn}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeDryRunReturn = (() => { + type TypeName = DryRunReturn; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + typeTag: FfiConverterTypeTypeTag.read(from), + bcs: FfiConverterArrayBuffer.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypeTypeTag.write(value.typeTag, into); + FfiConverterArrayBuffer.write(value.bcs, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypeTypeTag.allocationSize(value.typeTag) + + FfiConverterArrayBuffer.allocationSize(value.bcs) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * The name part of a dynamic field, including its type, bcs, and json + * representation. + */ +export type DynamicFieldName = { +/** + * The type name of this dynamic field name + */typeTag: TypeTag; +/** + * The bcs bytes of this dynamic field name + */bcs: ArrayBuffer; +/** + * The json representation of the dynamic field name + */json?: string; +} + +export const DynamicFieldName = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link DynamicFieldName}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link DynamicFieldName}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeDynamicFieldName = (() => { + type TypeName = DynamicFieldName; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + typeTag: FfiConverterTypeTypeTag.read(from), + bcs: FfiConverterArrayBuffer.read(from), + json: (new FfiConverterOptional(FfiConverterString)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypeTypeTag.write(value.typeTag, into); + FfiConverterArrayBuffer.write(value.bcs, into); + (new FfiConverterOptional(FfiConverterString)).write(value.json, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypeTypeTag.allocationSize(value.typeTag) + + FfiConverterArrayBuffer.allocationSize(value.bcs) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.json) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * The output of a dynamic field query, that includes the name, value, and + * value's json representation. + */ +export type DynamicFieldOutput = { +/** + * The name of the dynamic field + */name: DynamicFieldName; +/** + * The dynamic field value typename and bcs + */value?: DynamicFieldValue; +/** + * The json representation of the dynamic field value object + */valueAsJson?: string; +} + +export const DynamicFieldOutput = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link DynamicFieldOutput}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link DynamicFieldOutput}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeDynamicFieldOutput = (() => { + type TypeName = DynamicFieldOutput; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + name: FfiConverterTypeDynamicFieldName.read(from), + value: (new FfiConverterOptional(FfiConverterTypeDynamicFieldValue)).read(from), + valueAsJson: (new FfiConverterOptional(FfiConverterString)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypeDynamicFieldName.write(value.name, into); + (new FfiConverterOptional(FfiConverterTypeDynamicFieldValue)).write(value.value, into); + (new FfiConverterOptional(FfiConverterString)).write(value.valueAsJson, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypeDynamicFieldName.allocationSize(value.name) + + (new FfiConverterOptional(FfiConverterTypeDynamicFieldValue)).allocationSize(value.value) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.valueAsJson) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * A page of items returned by the GraphQL server. + */ +export type DynamicFieldOutputPage = { +/** + * Information about the page, such as the cursor and whether there are + * more pages. + */pageInfo: PageInfo; +/** + * The data returned by the server. + */data: Array; +} + +export const DynamicFieldOutputPage = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link DynamicFieldOutputPage}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link DynamicFieldOutputPage}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeDynamicFieldOutputPage = (() => { + type TypeName = DynamicFieldOutputPage; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + pageInfo: FfiConverterTypePageInfo.read(from), + data: (new FfiConverterArray(FfiConverterTypeDynamicFieldOutput)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypePageInfo.write(value.pageInfo, into); + (new FfiConverterArray(FfiConverterTypeDynamicFieldOutput)).write(value.data, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypePageInfo.allocationSize(value.pageInfo) + + (new FfiConverterArray(FfiConverterTypeDynamicFieldOutput)).allocationSize(value.data) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * The value part of a dynamic field. + */ +export type DynamicFieldValue = {typeTag: TypeTag;bcs: ArrayBuffer; +} + +export const DynamicFieldValue = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link DynamicFieldValue}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link DynamicFieldValue}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeDynamicFieldValue = (() => { + type TypeName = DynamicFieldValue; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + typeTag: FfiConverterTypeTypeTag.read(from), + bcs: FfiConverterArrayBuffer.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypeTypeTag.write(value.typeTag, into); + FfiConverterArrayBuffer.write(value.bcs, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypeTypeTag.allocationSize(value.typeTag) + + FfiConverterArrayBuffer.allocationSize(value.bcs) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * Data which, when included in a [`CheckpointSummary`], signals the end of an + * `Epoch`. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * end-of-epoch-data = (vector validator-committee-member) ; next_epoch_committee + * u64 ; next_epoch_protocol_version + * (vector checkpoint-commitment) ; epoch_commitments + * ``` + */ +export type EndOfEpochData = {nextEpochCommittee: Array;nextEpochProtocolVersion: /*u64*/bigint;epochCommitments: Array;epochSupplyChange: /*i64*/bigint; +} + +export const EndOfEpochData = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link EndOfEpochData}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link EndOfEpochData}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeEndOfEpochData = (() => { + type TypeName = EndOfEpochData; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + nextEpochCommittee: (new FfiConverterArray(FfiConverterTypeValidatorCommitteeMember)).read(from), + nextEpochProtocolVersion: FfiConverterUInt64.read(from), + epochCommitments: (new FfiConverterArray(FfiConverterTypeCheckpointCommitment)).read(from), + epochSupplyChange: FfiConverterInt64.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + (new FfiConverterArray(FfiConverterTypeValidatorCommitteeMember)).write(value.nextEpochCommittee, into); + FfiConverterUInt64.write(value.nextEpochProtocolVersion, into); + (new FfiConverterArray(FfiConverterTypeCheckpointCommitment)).write(value.epochCommitments, into); + FfiConverterInt64.write(value.epochSupplyChange, into); + + } + allocationSize(value: TypeName): number { + return ( + (new FfiConverterArray(FfiConverterTypeValidatorCommitteeMember)).allocationSize(value.nextEpochCommittee) + + FfiConverterUInt64.allocationSize(value.nextEpochProtocolVersion) + + (new FfiConverterArray(FfiConverterTypeCheckpointCommitment)).allocationSize(value.epochCommitments) + + FfiConverterInt64.allocationSize(value.epochSupplyChange) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type Epoch = { +/** + * The epoch's id as a sequence number that starts at 0 and is incremented + * by one at every epoch change. + */epochId: /*u64*/bigint; +/** + * The storage fees paid for transactions executed during the epoch. + */fundInflow?: string; +/** + * The storage fee rebates paid to users who deleted the data associated + * with past transactions. + */fundOutflow?: string; +/** + * The storage fund available in this epoch. + * This fund is used to redistribute storage fees from past transactions + * to future validators. + */fundSize?: string; +/** + * A commitment by the committee at the end of epoch on the contents of the + * live object set at that time. This can be used to verify state + * snapshots. + */liveObjectSetDigest?: string; +/** + * The difference between the fund inflow and outflow, representing + * the net amount of storage fees accumulated in this epoch. + */netInflow?: string; +/** + * The epoch's corresponding protocol configuration, including the feature + * flags and the configuration options. + */protocolConfigs?: ProtocolConfigs; +/** + * The minimum gas price that a quorum of validators are guaranteed to sign + * a transaction for. + */referenceGasPrice?: string; +/** + * The epoch's starting timestamp. + */startTimestamp: /*u64*/bigint; +/** + * The epoch's ending timestamp. Note that this is available only on epochs + * that have ended. + */endTimestamp?: /*u64*/bigint; +/** + * The value of the `version` field of `0x5`, the + * `0x3::iota::IotaSystemState` object. This version changes whenever + * the fields contained in the system state object (held in a dynamic + * field attached to `0x5`) change. + */systemStateVersion?: /*u64*/bigint; +/** + * The total number of checkpoints in this epoch. + */totalCheckpoints?: /*u64*/bigint; +/** + * The total amount of gas fees (in IOTA) that were paid in this epoch. + */totalGasFees?: string; +/** + * The total IOTA rewarded as stake. + */totalStakeRewards?: string; +/** + * The total number of transaction in this epoch. + */totalTransactions?: /*u64*/bigint; +/** + * Validator related properties. For active validators, see + * `active_validators` API. + * For epochs other than the current the data provided refer to the start + * of the epoch. + */validatorSet?: ValidatorSet; +} + +export const Epoch = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link Epoch}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link Epoch}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeEpoch = (() => { + type TypeName = Epoch; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + epochId: FfiConverterUInt64.read(from), + fundInflow: (new FfiConverterOptional(FfiConverterString)).read(from), + fundOutflow: (new FfiConverterOptional(FfiConverterString)).read(from), + fundSize: (new FfiConverterOptional(FfiConverterString)).read(from), + liveObjectSetDigest: (new FfiConverterOptional(FfiConverterString)).read(from), + netInflow: (new FfiConverterOptional(FfiConverterString)).read(from), + protocolConfigs: (new FfiConverterOptional(FfiConverterTypeProtocolConfigs)).read(from), + referenceGasPrice: (new FfiConverterOptional(FfiConverterString)).read(from), + startTimestamp: FfiConverterUInt64.read(from), + endTimestamp: (new FfiConverterOptional(FfiConverterUInt64)).read(from), + systemStateVersion: (new FfiConverterOptional(FfiConverterUInt64)).read(from), + totalCheckpoints: (new FfiConverterOptional(FfiConverterUInt64)).read(from), + totalGasFees: (new FfiConverterOptional(FfiConverterString)).read(from), + totalStakeRewards: (new FfiConverterOptional(FfiConverterString)).read(from), + totalTransactions: (new FfiConverterOptional(FfiConverterUInt64)).read(from), + validatorSet: (new FfiConverterOptional(FfiConverterTypeValidatorSet)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterUInt64.write(value.epochId, into); + (new FfiConverterOptional(FfiConverterString)).write(value.fundInflow, into); + (new FfiConverterOptional(FfiConverterString)).write(value.fundOutflow, into); + (new FfiConverterOptional(FfiConverterString)).write(value.fundSize, into); + (new FfiConverterOptional(FfiConverterString)).write(value.liveObjectSetDigest, into); + (new FfiConverterOptional(FfiConverterString)).write(value.netInflow, into); + (new FfiConverterOptional(FfiConverterTypeProtocolConfigs)).write(value.protocolConfigs, into); + (new FfiConverterOptional(FfiConverterString)).write(value.referenceGasPrice, into); + FfiConverterUInt64.write(value.startTimestamp, into); + (new FfiConverterOptional(FfiConverterUInt64)).write(value.endTimestamp, into); + (new FfiConverterOptional(FfiConverterUInt64)).write(value.systemStateVersion, into); + (new FfiConverterOptional(FfiConverterUInt64)).write(value.totalCheckpoints, into); + (new FfiConverterOptional(FfiConverterString)).write(value.totalGasFees, into); + (new FfiConverterOptional(FfiConverterString)).write(value.totalStakeRewards, into); + (new FfiConverterOptional(FfiConverterUInt64)).write(value.totalTransactions, into); + (new FfiConverterOptional(FfiConverterTypeValidatorSet)).write(value.validatorSet, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterUInt64.allocationSize(value.epochId) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.fundInflow) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.fundOutflow) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.fundSize) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.liveObjectSetDigest) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.netInflow) + + (new FfiConverterOptional(FfiConverterTypeProtocolConfigs)).allocationSize(value.protocolConfigs) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.referenceGasPrice) + + FfiConverterUInt64.allocationSize(value.startTimestamp) + + (new FfiConverterOptional(FfiConverterUInt64)).allocationSize(value.endTimestamp) + + (new FfiConverterOptional(FfiConverterUInt64)).allocationSize(value.systemStateVersion) + + (new FfiConverterOptional(FfiConverterUInt64)).allocationSize(value.totalCheckpoints) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.totalGasFees) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.totalStakeRewards) + + (new FfiConverterOptional(FfiConverterUInt64)).allocationSize(value.totalTransactions) + + (new FfiConverterOptional(FfiConverterTypeValidatorSet)).allocationSize(value.validatorSet) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * A page of items returned by the GraphQL server. + */ +export type EpochPage = { +/** + * Information about the page, such as the cursor and whether there are + * more pages. + */pageInfo: PageInfo; +/** + * The data returned by the server. + */data: Array; +} + +export const EpochPage = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link EpochPage}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link EpochPage}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeEpochPage = (() => { + type TypeName = EpochPage; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + pageInfo: FfiConverterTypePageInfo.read(from), + data: (new FfiConverterArray(FfiConverterTypeEpoch)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypePageInfo.write(value.pageInfo, into); + (new FfiConverterArray(FfiConverterTypeEpoch)).write(value.data, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypePageInfo.allocationSize(value.pageInfo) + + (new FfiConverterArray(FfiConverterTypeEpoch)).allocationSize(value.data) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * An event + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * event = object-id identifier address struct-tag bytes + * ``` + */ +export type Event = { +/** + * Package id of the top-level function invoked by a MoveCall command which + * triggered this event to be emitted. + */packageId: ObjectId; +/** + * Module name of the top-level function invoked by a MoveCall command + * which triggered this event to be emitted. + */module: string; +/** + * Address of the account that sent the transaction where this event was + * emitted. + */sender: Address; +/** + * The type of the event emitted + */type: string; +/** + * BCS serialized bytes of the event + */contents: ArrayBuffer; +/** + * UTC timestamp in milliseconds since epoch (1/1/1970) + */timestamp: string; +/** + * Structured contents of a Move value + */data: string; +/** + * Representation of a Move value in JSON + */json: string; +} + +export const Event = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link Event}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link Event}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeEvent = (() => { + type TypeName = Event; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + packageId: FfiConverterTypeObjectId.read(from), + module: FfiConverterString.read(from), + sender: FfiConverterTypeAddress.read(from), + type: FfiConverterString.read(from), + contents: FfiConverterArrayBuffer.read(from), + timestamp: FfiConverterString.read(from), + data: FfiConverterString.read(from), + json: FfiConverterString.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypeObjectId.write(value.packageId, into); + FfiConverterString.write(value.module, into); + FfiConverterTypeAddress.write(value.sender, into); + FfiConverterString.write(value.type, into); + FfiConverterArrayBuffer.write(value.contents, into); + FfiConverterString.write(value.timestamp, into); + FfiConverterString.write(value.data, into); + FfiConverterString.write(value.json, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypeObjectId.allocationSize(value.packageId) + + FfiConverterString.allocationSize(value.module) + + FfiConverterTypeAddress.allocationSize(value.sender) + + FfiConverterString.allocationSize(value.type) + + FfiConverterArrayBuffer.allocationSize(value.contents) + + FfiConverterString.allocationSize(value.timestamp) + + FfiConverterString.allocationSize(value.data) + + FfiConverterString.allocationSize(value.json) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type EventFilter = {emittingModule?: string;eventType?: string;sender?: Address;transactionDigest?: string; +} + +export const EventFilter = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link EventFilter}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link EventFilter}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeEventFilter = (() => { + type TypeName = EventFilter; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + emittingModule: (new FfiConverterOptional(FfiConverterString)).read(from), + eventType: (new FfiConverterOptional(FfiConverterString)).read(from), + sender: (new FfiConverterOptional(FfiConverterTypeAddress)).read(from), + transactionDigest: (new FfiConverterOptional(FfiConverterString)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + (new FfiConverterOptional(FfiConverterString)).write(value.emittingModule, into); + (new FfiConverterOptional(FfiConverterString)).write(value.eventType, into); + (new FfiConverterOptional(FfiConverterTypeAddress)).write(value.sender, into); + (new FfiConverterOptional(FfiConverterString)).write(value.transactionDigest, into); + + } + allocationSize(value: TypeName): number { + return ( + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.emittingModule) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.eventType) + + (new FfiConverterOptional(FfiConverterTypeAddress)).allocationSize(value.sender) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.transactionDigest) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * A page of items returned by the GraphQL server. + */ +export type EventPage = { +/** + * Information about the page, such as the cursor and whether there are + * more pages. + */pageInfo: PageInfo; +/** + * The data returned by the server. + */data: Array; +} + +export const EventPage = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link EventPage}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link EventPage}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeEventPage = (() => { + type TypeName = EventPage; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + pageInfo: FfiConverterTypePageInfo.read(from), + data: (new FfiConverterArray(FfiConverterTypeEvent)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypePageInfo.write(value.pageInfo, into); + (new FfiConverterArray(FfiConverterTypeEvent)).write(value.data, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypePageInfo.allocationSize(value.pageInfo) + + (new FfiConverterArray(FfiConverterTypeEvent)).allocationSize(value.data) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type FaucetReceipt = {sent: Array; +} + +export const FaucetReceipt = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link FaucetReceipt}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link FaucetReceipt}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeFaucetReceipt = (() => { + type TypeName = FaucetReceipt; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + sent: (new FfiConverterArray(FfiConverterTypeCoinInfo)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + (new FfiConverterArray(FfiConverterTypeCoinInfo)).write(value.sent, into); + + } + allocationSize(value: TypeName): number { + return ( + (new FfiConverterArray(FfiConverterTypeCoinInfo)).allocationSize(value.sent) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type GqlAddress = {address: Address; +} + +export const GqlAddress = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link GqlAddress}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link GqlAddress}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeGqlAddress = (() => { + type TypeName = GqlAddress; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + address: FfiConverterTypeAddress.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypeAddress.write(value.address, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypeAddress.allocationSize(value.address) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * Summary of gas charges. + * + * Storage is charged independently of computation. + * There are 3 parts to the storage charges: + * `storage_cost`: it is the charge of storage at the time the transaction is + * executed. The cost of storage is the number of bytes of the + * objects being mutated multiplied by a variable storage cost + * per byte `storage_rebate`: this is the amount a user gets back when + * manipulating an object. The `storage_rebate` is the + * `storage_cost` for an object minus fees. `non_refundable_storage_fee`: not + * all the value of the object storage cost is + * given back to user and there is a small fraction that + * is kept by the system. This value tracks that charge. + * + * When looking at a gas cost summary the amount charged to the user is + * `computation_cost + storage_cost - storage_rebate` + * and that is the amount that is deducted from the gas coins. + * `non_refundable_storage_fee` is collected from the objects being + * mutated/deleted and it is tracked by the system in storage funds. + * + * Objects deleted, including the older versions of objects mutated, have the + * storage field on the objects added up to a pool of "potential rebate". This + * rebate then is reduced by the "nonrefundable rate" such that: + * `potential_rebate(storage cost of deleted/mutated objects) = + * storage_rebate + non_refundable_storage_fee` + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * gas-cost-summary = u64 ; computation-cost + * u64 ; storage-cost + * u64 ; storage-rebate + * u64 ; non-refundable-storage-fee + * ``` + */ +export type GasCostSummary = { +/** + * Cost of computation/execution + */computationCost: /*u64*/bigint; +/** + * The burned component of the computation/execution costs + */computationCostBurned: /*u64*/bigint; +/** + * Storage cost, it's the sum of all storage cost for all objects created + * or mutated. + */storageCost: /*u64*/bigint; +/** + * The amount of storage cost refunded to the user for all objects deleted + * or mutated in the transaction. + */storageRebate: /*u64*/bigint; +/** + * The fee for the rebate. The portion of the storage rebate kept by the + * system. + */nonRefundableStorageFee: /*u64*/bigint; +} + +export const GasCostSummary = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link GasCostSummary}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link GasCostSummary}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeGasCostSummary = (() => { + type TypeName = GasCostSummary; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + computationCost: FfiConverterUInt64.read(from), + computationCostBurned: FfiConverterUInt64.read(from), + storageCost: FfiConverterUInt64.read(from), + storageRebate: FfiConverterUInt64.read(from), + nonRefundableStorageFee: FfiConverterUInt64.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterUInt64.write(value.computationCost, into); + FfiConverterUInt64.write(value.computationCostBurned, into); + FfiConverterUInt64.write(value.storageCost, into); + FfiConverterUInt64.write(value.storageRebate, into); + FfiConverterUInt64.write(value.nonRefundableStorageFee, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterUInt64.allocationSize(value.computationCost) + + FfiConverterUInt64.allocationSize(value.computationCostBurned) + + FfiConverterUInt64.allocationSize(value.storageCost) + + FfiConverterUInt64.allocationSize(value.storageRebate) + + FfiConverterUInt64.allocationSize(value.nonRefundableStorageFee) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * Payment information for executing a transaction + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * gas-payment = (vector object-ref) ; gas coin objects + * address ; owner + * u64 ; price + * u64 ; budget + * ``` + */ +export type GasPayment = {objects: Array; +/** + * Owner of the gas objects, either the transaction sender or a sponsor + */owner: Address; +/** + * Gas unit price to use when charging for computation + * + * Must be greater-than-or-equal-to the network's current RGP (reference + * gas price) + */price: /*u64*/bigint; +/** + * Total budget willing to spend for the execution of a transaction + */budget: /*u64*/bigint; +} + +export const GasPayment = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link GasPayment}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link GasPayment}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeGasPayment = (() => { + type TypeName = GasPayment; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + objects: (new FfiConverterArray(FfiConverterTypeObjectReference)).read(from), + owner: FfiConverterTypeAddress.read(from), + price: FfiConverterUInt64.read(from), + budget: FfiConverterUInt64.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + (new FfiConverterArray(FfiConverterTypeObjectReference)).write(value.objects, into); + FfiConverterTypeAddress.write(value.owner, into); + FfiConverterUInt64.write(value.price, into); + FfiConverterUInt64.write(value.budget, into); + + } + allocationSize(value: TypeName): number { + return ( + (new FfiConverterArray(FfiConverterTypeObjectReference)).allocationSize(value.objects) + + FfiConverterTypeAddress.allocationSize(value.owner) + + FfiConverterUInt64.allocationSize(value.price) + + FfiConverterUInt64.allocationSize(value.budget) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * A JSON Web Key + * + * Struct that contains info for a JWK. A list of them for different kids can + * be retrieved from the JWK endpoint (e.g. ). + * The JWK is used to verify the JWT token. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * jwk = string string string string + * ``` + */ +export type Jwk = { +/** + * Key type parameter, + */kty: string; +/** + * RSA public exponent, + */e: string; +/** + * RSA modulus, + */n: string; +/** + * Algorithm parameter, + */alg: string; +} + +export const Jwk = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link Jwk}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link Jwk}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeJwk = (() => { + type TypeName = Jwk; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + kty: FfiConverterString.read(from), + e: FfiConverterString.read(from), + n: FfiConverterString.read(from), + alg: FfiConverterString.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterString.write(value.kty, into); + FfiConverterString.write(value.e, into); + FfiConverterString.write(value.n, into); + FfiConverterString.write(value.alg, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterString.allocationSize(value.kty) + + FfiConverterString.allocationSize(value.e) + + FfiConverterString.allocationSize(value.n) + + FfiConverterString.allocationSize(value.alg) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * Key to uniquely identify a JWK + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * jwk-id = string string + * ``` + */ +export type JwkId = { +/** + * The issuer or identity of the OIDC provider. + */iss: string; +/** + * A key id use to uniquely identify a key from an OIDC provider. + */kid: string; +} + +export const JwkId = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link JwkId}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link JwkId}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeJwkId = (() => { + type TypeName = JwkId; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + iss: FfiConverterString.read(from), + kid: FfiConverterString.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterString.write(value.iss, into); + FfiConverterString.write(value.kid, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterString.allocationSize(value.iss) + + FfiConverterString.allocationSize(value.kid) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type MoveEnum = {abilities?: Array;name: string;typeParameters?: Array;variants?: Array; +} + +export const MoveEnum = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link MoveEnum}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link MoveEnum}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeMoveEnum = (() => { + type TypeName = MoveEnum; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + abilities: (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeMoveAbility)))).read(from), + name: FfiConverterString.read(from), + typeParameters: (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeMoveStructTypeParameter)))).read(from), + variants: (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeMoveEnumVariant)))).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeMoveAbility)))).write(value.abilities, into); + FfiConverterString.write(value.name, into); + (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeMoveStructTypeParameter)))).write(value.typeParameters, into); + (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeMoveEnumVariant)))).write(value.variants, into); + + } + allocationSize(value: TypeName): number { + return ( + (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeMoveAbility)))).allocationSize(value.abilities) + + FfiConverterString.allocationSize(value.name) + + (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeMoveStructTypeParameter)))).allocationSize(value.typeParameters) + + (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeMoveEnumVariant)))).allocationSize(value.variants) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type MoveEnumConnection = {nodes: Array;pageInfo: PageInfo; +} + +export const MoveEnumConnection = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link MoveEnumConnection}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link MoveEnumConnection}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeMoveEnumConnection = (() => { + type TypeName = MoveEnumConnection; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + nodes: (new FfiConverterArray(FfiConverterTypeMoveEnum)).read(from), + pageInfo: FfiConverterTypePageInfo.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + (new FfiConverterArray(FfiConverterTypeMoveEnum)).write(value.nodes, into); + FfiConverterTypePageInfo.write(value.pageInfo, into); + + } + allocationSize(value: TypeName): number { + return ( + (new FfiConverterArray(FfiConverterTypeMoveEnum)).allocationSize(value.nodes) + + FfiConverterTypePageInfo.allocationSize(value.pageInfo) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type MoveEnumVariant = {fields?: Array;name: string; +} + +export const MoveEnumVariant = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link MoveEnumVariant}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link MoveEnumVariant}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeMoveEnumVariant = (() => { + type TypeName = MoveEnumVariant; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + fields: (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeMoveField)))).read(from), + name: FfiConverterString.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeMoveField)))).write(value.fields, into); + FfiConverterString.write(value.name, into); + + } + allocationSize(value: TypeName): number { + return ( + (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeMoveField)))).allocationSize(value.fields) + + FfiConverterString.allocationSize(value.name) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type MoveField = {name: string;type?: OpenMoveType; +} + +export const MoveField = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link MoveField}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link MoveField}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeMoveField = (() => { + type TypeName = MoveField; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + name: FfiConverterString.read(from), + type: (new FfiConverterOptional(FfiConverterTypeOpenMoveType)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterString.write(value.name, into); + (new FfiConverterOptional(FfiConverterTypeOpenMoveType)).write(value.type, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterString.allocationSize(value.name) + + (new FfiConverterOptional(FfiConverterTypeOpenMoveType)).allocationSize(value.type) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type MoveFunctionConnection = {nodes: Array;pageInfo: PageInfo; +} + +export const MoveFunctionConnection = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link MoveFunctionConnection}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link MoveFunctionConnection}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeMoveFunctionConnection = (() => { + type TypeName = MoveFunctionConnection; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + nodes: (new FfiConverterArray(FfiConverterTypeMoveFunction)).read(from), + pageInfo: FfiConverterTypePageInfo.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + (new FfiConverterArray(FfiConverterTypeMoveFunction)).write(value.nodes, into); + FfiConverterTypePageInfo.write(value.pageInfo, into); + + } + allocationSize(value: TypeName): number { + return ( + (new FfiConverterArray(FfiConverterTypeMoveFunction)).allocationSize(value.nodes) + + FfiConverterTypePageInfo.allocationSize(value.pageInfo) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type MoveFunctionTypeParameter = {constraints: Array; +} + +export const MoveFunctionTypeParameter = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link MoveFunctionTypeParameter}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link MoveFunctionTypeParameter}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeMoveFunctionTypeParameter = (() => { + type TypeName = MoveFunctionTypeParameter; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + constraints: (new FfiConverterArray(FfiConverterTypeMoveAbility)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + (new FfiConverterArray(FfiConverterTypeMoveAbility)).write(value.constraints, into); + + } + allocationSize(value: TypeName): number { + return ( + (new FfiConverterArray(FfiConverterTypeMoveAbility)).allocationSize(value.constraints) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * Location in move bytecode where an error occurred + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * move-location = object-id identifier u16 u16 (option identifier) + * ``` + */ +export type MoveLocation = { +/** + * The package id + */package_: ObjectId; +/** + * The module name + */module: string; +/** + * The function index + */function_: /*u16*/number; +/** + * Index into the code stream for a jump. The offset is relative to the + * beginning of the instruction stream. + */instruction: /*u16*/number; +/** + * The name of the function if available + */functionName?: string; +} + +export const MoveLocation = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link MoveLocation}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link MoveLocation}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeMoveLocation = (() => { + type TypeName = MoveLocation; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + package_: FfiConverterTypeObjectId.read(from), + module: FfiConverterString.read(from), + function_: FfiConverterUInt16.read(from), + instruction: FfiConverterUInt16.read(from), + functionName: (new FfiConverterOptional(FfiConverterString)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypeObjectId.write(value.package_, into); + FfiConverterString.write(value.module, into); + FfiConverterUInt16.write(value.function_, into); + FfiConverterUInt16.write(value.instruction, into); + (new FfiConverterOptional(FfiConverterString)).write(value.functionName, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypeObjectId.allocationSize(value.package_) + + FfiConverterString.allocationSize(value.module) + + FfiConverterUInt16.allocationSize(value.function_) + + FfiConverterUInt16.allocationSize(value.instruction) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.functionName) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type MoveModule = {fileFormatVersion: /*i32*/number;enums?: MoveEnumConnection;friends: MoveModuleConnection;functions?: MoveFunctionConnection;structs?: MoveStructConnection; +} + +export const MoveModule = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link MoveModule}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link MoveModule}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeMoveModule = (() => { + type TypeName = MoveModule; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + fileFormatVersion: FfiConverterInt32.read(from), + enums: (new FfiConverterOptional(FfiConverterTypeMoveEnumConnection)).read(from), + friends: FfiConverterTypeMoveModuleConnection.read(from), + functions: (new FfiConverterOptional(FfiConverterTypeMoveFunctionConnection)).read(from), + structs: (new FfiConverterOptional(FfiConverterTypeMoveStructConnection)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterInt32.write(value.fileFormatVersion, into); + (new FfiConverterOptional(FfiConverterTypeMoveEnumConnection)).write(value.enums, into); + FfiConverterTypeMoveModuleConnection.write(value.friends, into); + (new FfiConverterOptional(FfiConverterTypeMoveFunctionConnection)).write(value.functions, into); + (new FfiConverterOptional(FfiConverterTypeMoveStructConnection)).write(value.structs, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterInt32.allocationSize(value.fileFormatVersion) + + (new FfiConverterOptional(FfiConverterTypeMoveEnumConnection)).allocationSize(value.enums) + + FfiConverterTypeMoveModuleConnection.allocationSize(value.friends) + + (new FfiConverterOptional(FfiConverterTypeMoveFunctionConnection)).allocationSize(value.functions) + + (new FfiConverterOptional(FfiConverterTypeMoveStructConnection)).allocationSize(value.structs) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type MoveModuleConnection = {nodes: Array;pageInfo: PageInfo; +} + +export const MoveModuleConnection = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link MoveModuleConnection}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link MoveModuleConnection}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeMoveModuleConnection = (() => { + type TypeName = MoveModuleConnection; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + nodes: (new FfiConverterArray(FfiConverterTypeMoveModuleQuery)).read(from), + pageInfo: FfiConverterTypePageInfo.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + (new FfiConverterArray(FfiConverterTypeMoveModuleQuery)).write(value.nodes, into); + FfiConverterTypePageInfo.write(value.pageInfo, into); + + } + allocationSize(value: TypeName): number { + return ( + (new FfiConverterArray(FfiConverterTypeMoveModuleQuery)).allocationSize(value.nodes) + + FfiConverterTypePageInfo.allocationSize(value.pageInfo) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type MoveModuleQuery = {package_: MovePackageQuery;name: string; +} + +export const MoveModuleQuery = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link MoveModuleQuery}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link MoveModuleQuery}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeMoveModuleQuery = (() => { + type TypeName = MoveModuleQuery; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + package_: FfiConverterTypeMovePackageQuery.read(from), + name: FfiConverterString.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypeMovePackageQuery.write(value.package_, into); + FfiConverterString.write(value.name, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypeMovePackageQuery.allocationSize(value.package_) + + FfiConverterString.allocationSize(value.name) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type MoveObject = {bcs?: string; +} + +export const MoveObject = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link MoveObject}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link MoveObject}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeMoveObject = (() => { + type TypeName = MoveObject; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + bcs: (new FfiConverterOptional(FfiConverterString)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + (new FfiConverterOptional(FfiConverterString)).write(value.bcs, into); + + } + allocationSize(value: TypeName): number { + return ( + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.bcs) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * A page of items returned by the GraphQL server. + */ +export type MovePackagePage = { +/** + * Information about the page, such as the cursor and whether there are + * more pages. + */pageInfo: PageInfo; +/** + * The data returned by the server. + */data: Array; +} + +export const MovePackagePage = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link MovePackagePage}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link MovePackagePage}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeMovePackagePage = (() => { + type TypeName = MovePackagePage; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + pageInfo: FfiConverterTypePageInfo.read(from), + data: (new FfiConverterArray(FfiConverterTypeMovePackage)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypePageInfo.write(value.pageInfo, into); + (new FfiConverterArray(FfiConverterTypeMovePackage)).write(value.data, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypePageInfo.allocationSize(value.pageInfo) + + (new FfiConverterArray(FfiConverterTypeMovePackage)).allocationSize(value.data) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type MovePackageQuery = {address: Address;bcs?: string; +} + +export const MovePackageQuery = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link MovePackageQuery}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link MovePackageQuery}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeMovePackageQuery = (() => { + type TypeName = MovePackageQuery; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + address: FfiConverterTypeAddress.read(from), + bcs: (new FfiConverterOptional(FfiConverterString)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypeAddress.write(value.address, into); + (new FfiConverterOptional(FfiConverterString)).write(value.bcs, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypeAddress.allocationSize(value.address) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.bcs) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * A move struct + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * object-move-struct = compressed-struct-tag bool u64 object-contents + * + * compressed-struct-tag = other-struct-type / gas-coin-type / staked-iota-type / coin-type + * other-struct-type = %x00 struct-tag + * gas-coin-type = %x01 + * staked-iota-type = %x02 + * coin-type = %x03 type-tag + * + * ; first 32 bytes of the contents are the object's object-id + * object-contents = uleb128 (object-id *OCTET) ; length followed by contents + * ``` + */ +export type MoveStruct = { +/** + * The type of this object + */structType: StructTag; +/** + * Number that increases each time a tx takes this object as a mutable + * input This is a lamport timestamp, not a sequentially increasing + * version + */version: /*u64*/bigint; +/** + * BCS bytes of a Move struct value + */contents: ArrayBuffer; +} + +export const MoveStruct = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link MoveStruct}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link MoveStruct}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeMoveStruct = (() => { + type TypeName = MoveStruct; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + structType: FfiConverterTypeStructTag.read(from), + version: FfiConverterUInt64.read(from), + contents: FfiConverterArrayBuffer.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypeStructTag.write(value.structType, into); + FfiConverterUInt64.write(value.version, into); + FfiConverterArrayBuffer.write(value.contents, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypeStructTag.allocationSize(value.structType) + + FfiConverterUInt64.allocationSize(value.version) + + FfiConverterArrayBuffer.allocationSize(value.contents) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type MoveStructConnection = {pageInfo: PageInfo;nodes: Array; +} + +export const MoveStructConnection = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link MoveStructConnection}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link MoveStructConnection}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeMoveStructConnection = (() => { + type TypeName = MoveStructConnection; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + pageInfo: FfiConverterTypePageInfo.read(from), + nodes: (new FfiConverterArray(FfiConverterTypeMoveStructQuery)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypePageInfo.write(value.pageInfo, into); + (new FfiConverterArray(FfiConverterTypeMoveStructQuery)).write(value.nodes, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypePageInfo.allocationSize(value.pageInfo) + + (new FfiConverterArray(FfiConverterTypeMoveStructQuery)).allocationSize(value.nodes) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type MoveStructQuery = {abilities?: Array;name: string;fields?: Array;typeParameters?: Array; +} + +export const MoveStructQuery = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link MoveStructQuery}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link MoveStructQuery}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeMoveStructQuery = (() => { + type TypeName = MoveStructQuery; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + abilities: (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeMoveAbility)))).read(from), + name: FfiConverterString.read(from), + fields: (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeMoveField)))).read(from), + typeParameters: (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeMoveStructTypeParameter)))).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeMoveAbility)))).write(value.abilities, into); + FfiConverterString.write(value.name, into); + (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeMoveField)))).write(value.fields, into); + (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeMoveStructTypeParameter)))).write(value.typeParameters, into); + + } + allocationSize(value: TypeName): number { + return ( + (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeMoveAbility)))).allocationSize(value.abilities) + + FfiConverterString.allocationSize(value.name) + + (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeMoveField)))).allocationSize(value.fields) + + (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeMoveStructTypeParameter)))).allocationSize(value.typeParameters) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type MoveStructTypeParameter = {constraints: Array;isPhantom: boolean; +} + +export const MoveStructTypeParameter = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link MoveStructTypeParameter}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link MoveStructTypeParameter}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeMoveStructTypeParameter = (() => { + type TypeName = MoveStructTypeParameter; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + constraints: (new FfiConverterArray(FfiConverterTypeMoveAbility)).read(from), + isPhantom: FfiConverterBool.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + (new FfiConverterArray(FfiConverterTypeMoveAbility)).write(value.constraints, into); + FfiConverterBool.write(value.isPhantom, into); + + } + allocationSize(value: TypeName): number { + return ( + (new FfiConverterArray(FfiConverterTypeMoveAbility)).allocationSize(value.constraints) + + FfiConverterBool.allocationSize(value.isPhantom) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * The result of executing a Move View Function. + * + * Execution errors are captured in the `error` field, in which case the + * `results` field will be `None`. On success, the `results` field will contain + * the return values of the Move view function, and the `error` field will be + * `None`. + */ +export type MoveViewResult = { +/** + * Execution error from executing the Move view function. + */error?: string; +/** + * The return values of the Move view function, resolved and formatted as + * JSON. + */results?: Array; +} + +export const MoveViewResult = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link MoveViewResult}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link MoveViewResult}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeMoveViewResult = (() => { + type TypeName = MoveViewResult; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + error: (new FfiConverterOptional(FfiConverterString)).read(from), + results: (new FfiConverterOptional((new FfiConverterArray(FfiConverterString)))).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + (new FfiConverterOptional(FfiConverterString)).write(value.error, into); + (new FfiConverterOptional((new FfiConverterArray(FfiConverterString)))).write(value.results, into); + + } + allocationSize(value: TypeName): number { + return ( + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.error) + + (new FfiConverterOptional((new FfiConverterArray(FfiConverterString)))).allocationSize(value.results) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * A page of items returned by the GraphQL server. + */ +export type NameRegistrationPage = { +/** + * Information about the page, such as the cursor and whether there are + * more pages. + */pageInfo: PageInfo; +/** + * The data returned by the server. + */data: Array; +} + +export const NameRegistrationPage = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link NameRegistrationPage}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link NameRegistrationPage}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeNameRegistrationPage = (() => { + type TypeName = NameRegistrationPage; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + pageInfo: FfiConverterTypePageInfo.read(from), + data: (new FfiConverterArray(FfiConverterTypeNameRegistration)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypePageInfo.write(value.pageInfo, into); + (new FfiConverterArray(FfiConverterTypeNameRegistration)).write(value.data, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypePageInfo.allocationSize(value.pageInfo) + + (new FfiConverterArray(FfiConverterTypeNameRegistration)).allocationSize(value.data) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type ObjectFilter = {typeTag?: string;owner?: Address;objectIds?: Array; +} + +export const ObjectFilter = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link ObjectFilter}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link ObjectFilter}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeObjectFilter = (() => { + type TypeName = ObjectFilter; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + typeTag: (new FfiConverterOptional(FfiConverterString)).read(from), + owner: (new FfiConverterOptional(FfiConverterTypeAddress)).read(from), + objectIds: (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeObjectId)))).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + (new FfiConverterOptional(FfiConverterString)).write(value.typeTag, into); + (new FfiConverterOptional(FfiConverterTypeAddress)).write(value.owner, into); + (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeObjectId)))).write(value.objectIds, into); + + } + allocationSize(value: TypeName): number { + return ( + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.typeTag) + + (new FfiConverterOptional(FfiConverterTypeAddress)).allocationSize(value.owner) + + (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeObjectId)))).allocationSize(value.objectIds) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * A page of items returned by the GraphQL server. + */ +export type ObjectPage = { +/** + * Information about the page, such as the cursor and whether there are + * more pages. + */pageInfo: PageInfo; +/** + * The data returned by the server. + */data: Array; +} + +export const ObjectPage = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link ObjectPage}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link ObjectPage}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeObjectPage = (() => { + type TypeName = ObjectPage; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + pageInfo: FfiConverterTypePageInfo.read(from), + data: (new FfiConverterArray(FfiConverterTypeObject)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypePageInfo.write(value.pageInfo, into); + (new FfiConverterArray(FfiConverterTypeObject)).write(value.data, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypePageInfo.allocationSize(value.pageInfo) + + (new FfiConverterArray(FfiConverterTypeObject)).allocationSize(value.data) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type ObjectRef = {address: ObjectId;digest: string;version: /*u64*/bigint; +} + +export const ObjectRef = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link ObjectRef}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link ObjectRef}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeObjectRef = (() => { + type TypeName = ObjectRef; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + address: FfiConverterTypeObjectId.read(from), + digest: FfiConverterString.read(from), + version: FfiConverterUInt64.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypeObjectId.write(value.address, into); + FfiConverterString.write(value.digest, into); + FfiConverterUInt64.write(value.version, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypeObjectId.allocationSize(value.address) + + FfiConverterString.allocationSize(value.digest) + + FfiConverterUInt64.allocationSize(value.version) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * Reference to an object + * + * Contains sufficient information to uniquely identify a specific object. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * object-ref = object-id u64 digest + * ``` + */ +export type ObjectReference = {objectId: ObjectId;version: /*u64*/bigint;digest: Digest; +} + +export const ObjectReference = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link ObjectReference}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link ObjectReference}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeObjectReference = (() => { + type TypeName = ObjectReference; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + objectId: FfiConverterTypeObjectId.read(from), + version: FfiConverterUInt64.read(from), + digest: FfiConverterTypeDigest.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypeObjectId.write(value.objectId, into); + FfiConverterUInt64.write(value.version, into); + FfiConverterTypeDigest.write(value.digest, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypeObjectId.allocationSize(value.objectId) + + FfiConverterUInt64.allocationSize(value.version) + + FfiConverterTypeDigest.allocationSize(value.digest) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type OpenMoveType = {repr: string; +} + +export const OpenMoveType = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link OpenMoveType}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link OpenMoveType}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeOpenMoveType = (() => { + type TypeName = OpenMoveType; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + repr: FfiConverterString.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterString.write(value.repr, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterString.allocationSize(value.repr) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * Information about pagination in a connection. + */ +export type PageInfo = { +/** + * When paginating backwards, are there more items? + */hasPreviousPage: boolean; +/** + * Are there more items when paginating forwards? + */hasNextPage: boolean; +/** + * When paginating backwards, the cursor to continue. + */startCursor?: string; +/** + * When paginating forwards, the cursor to continue. + */endCursor?: string; +} + +export const PageInfo = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link PageInfo}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link PageInfo}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypePageInfo = (() => { + type TypeName = PageInfo; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + hasPreviousPage: FfiConverterBool.read(from), + hasNextPage: FfiConverterBool.read(from), + startCursor: (new FfiConverterOptional(FfiConverterString)).read(from), + endCursor: (new FfiConverterOptional(FfiConverterString)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterBool.write(value.hasPreviousPage, into); + FfiConverterBool.write(value.hasNextPage, into); + (new FfiConverterOptional(FfiConverterString)).write(value.startCursor, into); + (new FfiConverterOptional(FfiConverterString)).write(value.endCursor, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterBool.allocationSize(value.hasPreviousPage) + + FfiConverterBool.allocationSize(value.hasNextPage) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.startCursor) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.endCursor) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * Pagination options for querying the GraphQL server. It defaults to forward + * pagination with the GraphQL server's max page size. + */ +export type PaginationFilter = { +/** + * The direction of pagination. + */direction: Direction; +/** + * An opaque cursor used for pagination. + */cursor?: string; +/** + * The maximum number of items to return. If this is omitted, it will + * lazily query the service configuration for the max page size. + */limit?: /*i32*/number; +} + +export const PaginationFilter = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link PaginationFilter}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link PaginationFilter}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypePaginationFilter = (() => { + type TypeName = PaginationFilter; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + direction: FfiConverterTypeDirection.read(from), + cursor: (new FfiConverterOptional(FfiConverterString)).read(from), + limit: (new FfiConverterOptional(FfiConverterInt32)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypeDirection.write(value.direction, into); + (new FfiConverterOptional(FfiConverterString)).write(value.cursor, into); + (new FfiConverterOptional(FfiConverterInt32)).write(value.limit, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypeDirection.allocationSize(value.direction) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.cursor) + + (new FfiConverterOptional(FfiConverterInt32)).allocationSize(value.limit) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * A key-value protocol configuration attribute. + */ +export type ProtocolConfigAttr = {key: string;value?: string; +} + +export const ProtocolConfigAttr = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link ProtocolConfigAttr}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link ProtocolConfigAttr}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeProtocolConfigAttr = (() => { + type TypeName = ProtocolConfigAttr; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + key: FfiConverterString.read(from), + value: (new FfiConverterOptional(FfiConverterString)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterString.write(value.key, into); + (new FfiConverterOptional(FfiConverterString)).write(value.value, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterString.allocationSize(value.key) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.value) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * Feature flags are a form of boolean configuration that are usually used to + * gate features while they are in development. Once a lag has been enabled, it + * is rare for it to be disabled. + */ +export type ProtocolConfigFeatureFlag = {key: string;value: boolean; +} + +export const ProtocolConfigFeatureFlag = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link ProtocolConfigFeatureFlag}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link ProtocolConfigFeatureFlag}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeProtocolConfigFeatureFlag = (() => { + type TypeName = ProtocolConfigFeatureFlag; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + key: FfiConverterString.read(from), + value: FfiConverterBool.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterString.write(value.key, into); + FfiConverterBool.write(value.value, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterString.allocationSize(value.key) + + FfiConverterBool.allocationSize(value.value) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * Information about the configuration of the protocol. + * Constants that control how the chain operates. + * These can only change during protocol upgrades which happen on epoch + * boundaries. + */ +export type ProtocolConfigs = { +/** + * The protocol is not required to change on every epoch boundary, so the + * protocol version tracks which change to the protocol these configs + * are from. + */protocolVersion: /*u64*/bigint; +/** + * List all available feature flags and their values. Feature flags are a + * form of boolean configuration that are usually used to gate features + * while they are in development. Once a flag has been enabled, it is + * rare for it to be disabled. + */featureFlags: Array; +/** + * List all available configurations and their values. These configurations + * can take any value (but they will all be represented in string + * form), and do not include feature flags. + */configs: Array; +} + +export const ProtocolConfigs = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link ProtocolConfigs}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link ProtocolConfigs}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeProtocolConfigs = (() => { + type TypeName = ProtocolConfigs; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + protocolVersion: FfiConverterUInt64.read(from), + featureFlags: (new FfiConverterArray(FfiConverterTypeProtocolConfigFeatureFlag)).read(from), + configs: (new FfiConverterArray(FfiConverterTypeProtocolConfigAttr)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterUInt64.write(value.protocolVersion, into); + (new FfiConverterArray(FfiConverterTypeProtocolConfigFeatureFlag)).write(value.featureFlags, into); + (new FfiConverterArray(FfiConverterTypeProtocolConfigAttr)).write(value.configs, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterUInt64.allocationSize(value.protocolVersion) + + (new FfiConverterArray(FfiConverterTypeProtocolConfigFeatureFlag)).allocationSize(value.featureFlags) + + (new FfiConverterArray(FfiConverterTypeProtocolConfigAttr)).allocationSize(value.configs) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type Query = {query: string;variables?: string; +} + +export const Query = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link Query}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link Query}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeQuery = (() => { + type TypeName = Query; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + query: FfiConverterString.read(from), + variables: (new FfiConverterOptional(FfiConverterString)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterString.write(value.query, into); + (new FfiConverterOptional(FfiConverterString)).write(value.variables, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterString.allocationSize(value.query) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.variables) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * Randomness update + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * randomness-state-update = u64 u64 bytes u64 + * ``` + */ +export type RandomnessStateUpdate = { +/** + * Epoch of the randomness state update transaction + */epoch: /*u64*/bigint; +/** + * Randomness round of the update + */randomnessRound: /*u64*/bigint; +/** + * Updated random bytes + */randomBytes: ArrayBuffer; +/** + * The initial version of the randomness object that it was shared at + */randomnessObjInitialSharedVersion: /*u64*/bigint; +} + +export const RandomnessStateUpdate = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link RandomnessStateUpdate}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link RandomnessStateUpdate}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeRandomnessStateUpdate = (() => { + type TypeName = RandomnessStateUpdate; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + epoch: FfiConverterUInt64.read(from), + randomnessRound: FfiConverterUInt64.read(from), + randomBytes: FfiConverterArrayBuffer.read(from), + randomnessObjInitialSharedVersion: FfiConverterUInt64.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterUInt64.write(value.epoch, into); + FfiConverterUInt64.write(value.randomnessRound, into); + FfiConverterArrayBuffer.write(value.randomBytes, into); + FfiConverterUInt64.write(value.randomnessObjInitialSharedVersion, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterUInt64.allocationSize(value.epoch) + + FfiConverterUInt64.allocationSize(value.randomnessRound) + + FfiConverterArrayBuffer.allocationSize(value.randomBytes) + + FfiConverterUInt64.allocationSize(value.randomnessObjInitialSharedVersion) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type ServiceConfig = { +/** + * Default number of elements allowed on a single page of a connection. + */defaultPageSize: /*i32*/number; +/** + * List of all features that are enabled on this RPC service. + */enabledFeatures: Array; +/** + * Maximum estimated cost of a database query used to serve a GraphQL + * request. This is measured in the same units that the database uses + * in EXPLAIN queries. + * Maximum nesting allowed in struct fields when calculating the layout of + * a single Move Type. + */maxMoveValueDepth: /*i32*/number; +/** + * The maximum number of output nodes in a GraphQL response. + * Non-connection nodes have a count of 1, while connection nodes are + * counted as the specified 'first' or 'last' number of items, or the + * default_page_size as set by the server if those arguments are not + * set. Counts accumulate multiplicatively down the query tree. For + * example, if a query starts with a connection of first: 10 and has a + * field to a connection with last: 20, the count at the second level + * would be 200 nodes. This is then summed to the count of 10 nodes + * at the first level, for a total of 210 nodes. + */maxOutputNodes: /*i32*/number; +/** + * Maximum number of elements allowed on a single page of a connection. + */maxPageSize: /*i32*/number; +/** + * The maximum depth a GraphQL query can be to be accepted by this service. + */maxQueryDepth: /*i32*/number; +/** + * The maximum number of nodes (field names) the service will accept in a + * single query. + */maxQueryNodes: /*i32*/number; +/** + * Maximum length of a query payload string. + */maxQueryPayloadSize: /*i32*/number; +/** + * Maximum nesting allowed in type arguments in Move Types resolved by this + * service. + */maxTypeArgumentDepth: /*i32*/number; +/** + * Maximum number of type arguments passed into a generic instantiation of + * a Move Type resolved by this service. + */maxTypeArgumentWidth: /*i32*/number; +/** + * Maximum number of structs that need to be processed when calculating the + * layout of a single Move Type. + */maxTypeNodes: /*i32*/number; +/** + * Maximum time in milliseconds spent waiting for a response from fullnode + * after issuing a transaction to execute. Note that the transaction + * may still succeed even in the case of a timeout. Transactions are + * idempotent, so a transaction that times out should be resubmitted + * until the network returns a definite response (success or failure, not + * timeout). + */mutationTimeoutMs: /*i32*/number; +/** + * Maximum time in milliseconds that will be spent to serve one query + * request. + */requestTimeoutMs: /*i32*/number; +} + +export const ServiceConfig = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link ServiceConfig}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link ServiceConfig}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeServiceConfig = (() => { + type TypeName = ServiceConfig; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + defaultPageSize: FfiConverterInt32.read(from), + enabledFeatures: (new FfiConverterArray(FfiConverterTypeFeature)).read(from), + maxMoveValueDepth: FfiConverterInt32.read(from), + maxOutputNodes: FfiConverterInt32.read(from), + maxPageSize: FfiConverterInt32.read(from), + maxQueryDepth: FfiConverterInt32.read(from), + maxQueryNodes: FfiConverterInt32.read(from), + maxQueryPayloadSize: FfiConverterInt32.read(from), + maxTypeArgumentDepth: FfiConverterInt32.read(from), + maxTypeArgumentWidth: FfiConverterInt32.read(from), + maxTypeNodes: FfiConverterInt32.read(from), + mutationTimeoutMs: FfiConverterInt32.read(from), + requestTimeoutMs: FfiConverterInt32.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterInt32.write(value.defaultPageSize, into); + (new FfiConverterArray(FfiConverterTypeFeature)).write(value.enabledFeatures, into); + FfiConverterInt32.write(value.maxMoveValueDepth, into); + FfiConverterInt32.write(value.maxOutputNodes, into); + FfiConverterInt32.write(value.maxPageSize, into); + FfiConverterInt32.write(value.maxQueryDepth, into); + FfiConverterInt32.write(value.maxQueryNodes, into); + FfiConverterInt32.write(value.maxQueryPayloadSize, into); + FfiConverterInt32.write(value.maxTypeArgumentDepth, into); + FfiConverterInt32.write(value.maxTypeArgumentWidth, into); + FfiConverterInt32.write(value.maxTypeNodes, into); + FfiConverterInt32.write(value.mutationTimeoutMs, into); + FfiConverterInt32.write(value.requestTimeoutMs, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterInt32.allocationSize(value.defaultPageSize) + + (new FfiConverterArray(FfiConverterTypeFeature)).allocationSize(value.enabledFeatures) + + FfiConverterInt32.allocationSize(value.maxMoveValueDepth) + + FfiConverterInt32.allocationSize(value.maxOutputNodes) + + FfiConverterInt32.allocationSize(value.maxPageSize) + + FfiConverterInt32.allocationSize(value.maxQueryDepth) + + FfiConverterInt32.allocationSize(value.maxQueryNodes) + + FfiConverterInt32.allocationSize(value.maxQueryPayloadSize) + + FfiConverterInt32.allocationSize(value.maxTypeArgumentDepth) + + FfiConverterInt32.allocationSize(value.maxTypeArgumentWidth) + + FfiConverterInt32.allocationSize(value.maxTypeNodes) + + FfiConverterInt32.allocationSize(value.mutationTimeoutMs) + + FfiConverterInt32.allocationSize(value.requestTimeoutMs) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type SignedTransaction = {transaction: Transaction;signatures: Array; +} + +export const SignedTransaction = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link SignedTransaction}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link SignedTransaction}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeSignedTransaction = (() => { + type TypeName = SignedTransaction; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + transaction: FfiConverterTypeTransaction.read(from), + signatures: (new FfiConverterArray(FfiConverterTypeUserSignature)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypeTransaction.write(value.transaction, into); + (new FfiConverterArray(FfiConverterTypeUserSignature)).write(value.signatures, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypeTransaction.allocationSize(value.transaction) + + (new FfiConverterArray(FfiConverterTypeUserSignature)).allocationSize(value.signatures) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * A page of items returned by the GraphQL server. + */ +export type SignedTransactionPage = { +/** + * Information about the page, such as the cursor and whether there are + * more pages. + */pageInfo: PageInfo; +/** + * The data returned by the server. + */data: Array; +} + +export const SignedTransactionPage = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link SignedTransactionPage}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link SignedTransactionPage}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeSignedTransactionPage = (() => { + type TypeName = SignedTransactionPage; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + pageInfo: FfiConverterTypePageInfo.read(from), + data: (new FfiConverterArray(FfiConverterTypeSignedTransaction)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypePageInfo.write(value.pageInfo, into); + (new FfiConverterArray(FfiConverterTypeSignedTransaction)).write(value.data, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypePageInfo.allocationSize(value.pageInfo) + + (new FfiConverterArray(FfiConverterTypeSignedTransaction)).allocationSize(value.data) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type TransactionDataEffects = {tx: SignedTransaction;effects: TransactionEffects; +} + +export const TransactionDataEffects = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link TransactionDataEffects}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link TransactionDataEffects}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeTransactionDataEffects = (() => { + type TypeName = TransactionDataEffects; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + tx: FfiConverterTypeSignedTransaction.read(from), + effects: FfiConverterTypeTransactionEffects.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypeSignedTransaction.write(value.tx, into); + FfiConverterTypeTransactionEffects.write(value.effects, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypeSignedTransaction.allocationSize(value.tx) + + FfiConverterTypeTransactionEffects.allocationSize(value.effects) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * A page of items returned by the GraphQL server. + */ +export type TransactionDataEffectsPage = { +/** + * Information about the page, such as the cursor and whether there are + * more pages. + */pageInfo: PageInfo; +/** + * The data returned by the server. + */data: Array; +} + +export const TransactionDataEffectsPage = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link TransactionDataEffectsPage}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link TransactionDataEffectsPage}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeTransactionDataEffectsPage = (() => { + type TypeName = TransactionDataEffectsPage; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + pageInfo: FfiConverterTypePageInfo.read(from), + data: (new FfiConverterArray(FfiConverterTypeTransactionDataEffects)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypePageInfo.write(value.pageInfo, into); + (new FfiConverterArray(FfiConverterTypeTransactionDataEffects)).write(value.data, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypePageInfo.allocationSize(value.pageInfo) + + (new FfiConverterArray(FfiConverterTypeTransactionDataEffects)).allocationSize(value.data) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * A page of items returned by the GraphQL server. + */ +export type TransactionEffectsPage = { +/** + * Information about the page, such as the cursor and whether there are + * more pages. + */pageInfo: PageInfo; +/** + * The data returned by the server. + */data: Array; +} + +export const TransactionEffectsPage = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link TransactionEffectsPage}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link TransactionEffectsPage}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeTransactionEffectsPage = (() => { + type TypeName = TransactionEffectsPage; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + pageInfo: FfiConverterTypePageInfo.read(from), + data: (new FfiConverterArray(FfiConverterTypeTransactionEffects)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypePageInfo.write(value.pageInfo, into); + (new FfiConverterArray(FfiConverterTypeTransactionEffects)).write(value.data, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypePageInfo.allocationSize(value.pageInfo) + + (new FfiConverterArray(FfiConverterTypeTransactionEffects)).allocationSize(value.data) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * Version 1 of TransactionEffects + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * effects-v1 = execution-status + * u64 ; epoch + * gas-cost-summary + * digest ; transaction digest + * (option u32) ; gas object index + * (option digest) ; events digest + * (vector digest) ; list of transaction dependencies + * u64 ; lamport version + * (vector changed-object) + * (vector unchanged-shared-object) + * (option digest) ; auxiliary data digest + * ``` + */ +export type TransactionEffectsV1 = { +/** + * The status of the execution + */status: ExecutionStatus; +/** + * The epoch when this transaction was executed. + */epoch: /*u64*/bigint; +/** + * The gas used by this transaction + */gasUsed: GasCostSummary; +/** + * The transaction digest + */transactionDigest: Digest; +/** + * The updated gas object reference, as an index into the `changed_objects` + * vector. Having a dedicated field for convenient access. + * System transaction that don't require gas will leave this as None. + */gasObjectIndex?: /*u32*/number; +/** + * The digest of the events emitted during execution, + * can be None if the transaction does not emit any event. + */eventsDigest?: Digest; +/** + * The set of transaction digests this transaction depends on. + */dependencies: Array; +/** + * The version number of all the written Move objects by this transaction. + */lamportVersion: /*u64*/bigint; +/** + * Objects whose state are changed in the object store. + */changedObjects: Array; +/** + * Shared objects that are not mutated in this transaction. Unlike owned + * objects, read-only shared objects' version are not committed in the + * transaction, and in order for a node to catch up and execute it + * without consensus sequencing, the version needs to be committed in + * the effects. + */unchangedSharedObjects: Array; +/** + * Auxiliary data that are not protocol-critical, generated as part of the + * effects but are stored separately. Storing it separately allows us + * to avoid bloating the effects with data that are not critical. + * It also provides more flexibility on the format and type of the data. + */auxiliaryDataDigest?: Digest; +} + +export const TransactionEffectsV1 = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link TransactionEffectsV1}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link TransactionEffectsV1}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeTransactionEffectsV1 = (() => { + type TypeName = TransactionEffectsV1; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + status: FfiConverterTypeExecutionStatus.read(from), + epoch: FfiConverterUInt64.read(from), + gasUsed: FfiConverterTypeGasCostSummary.read(from), + transactionDigest: FfiConverterTypeDigest.read(from), + gasObjectIndex: (new FfiConverterOptional(FfiConverterUInt32)).read(from), + eventsDigest: (new FfiConverterOptional(FfiConverterTypeDigest)).read(from), + dependencies: (new FfiConverterArray(FfiConverterTypeDigest)).read(from), + lamportVersion: FfiConverterUInt64.read(from), + changedObjects: (new FfiConverterArray(FfiConverterTypeChangedObject)).read(from), + unchangedSharedObjects: (new FfiConverterArray(FfiConverterTypeUnchangedSharedObject)).read(from), + auxiliaryDataDigest: (new FfiConverterOptional(FfiConverterTypeDigest)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypeExecutionStatus.write(value.status, into); + FfiConverterUInt64.write(value.epoch, into); + FfiConverterTypeGasCostSummary.write(value.gasUsed, into); + FfiConverterTypeDigest.write(value.transactionDigest, into); + (new FfiConverterOptional(FfiConverterUInt32)).write(value.gasObjectIndex, into); + (new FfiConverterOptional(FfiConverterTypeDigest)).write(value.eventsDigest, into); + (new FfiConverterArray(FfiConverterTypeDigest)).write(value.dependencies, into); + FfiConverterUInt64.write(value.lamportVersion, into); + (new FfiConverterArray(FfiConverterTypeChangedObject)).write(value.changedObjects, into); + (new FfiConverterArray(FfiConverterTypeUnchangedSharedObject)).write(value.unchangedSharedObjects, into); + (new FfiConverterOptional(FfiConverterTypeDigest)).write(value.auxiliaryDataDigest, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypeExecutionStatus.allocationSize(value.status) + + FfiConverterUInt64.allocationSize(value.epoch) + + FfiConverterTypeGasCostSummary.allocationSize(value.gasUsed) + + FfiConverterTypeDigest.allocationSize(value.transactionDigest) + + (new FfiConverterOptional(FfiConverterUInt32)).allocationSize(value.gasObjectIndex) + + (new FfiConverterOptional(FfiConverterTypeDigest)).allocationSize(value.eventsDigest) + + (new FfiConverterArray(FfiConverterTypeDigest)).allocationSize(value.dependencies) + + FfiConverterUInt64.allocationSize(value.lamportVersion) + + (new FfiConverterArray(FfiConverterTypeChangedObject)).allocationSize(value.changedObjects) + + (new FfiConverterArray(FfiConverterTypeUnchangedSharedObject)).allocationSize(value.unchangedSharedObjects) + + (new FfiConverterOptional(FfiConverterTypeDigest)).allocationSize(value.auxiliaryDataDigest) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type TransactionMetadata = {gasBudget?: /*u64*/bigint;gasObjects?: Array;gasPrice?: /*u64*/bigint;gasSponsor?: Address;sender?: Address; +} + +export const TransactionMetadata = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link TransactionMetadata}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link TransactionMetadata}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeTransactionMetadata = (() => { + type TypeName = TransactionMetadata; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + gasBudget: (new FfiConverterOptional(FfiConverterUInt64)).read(from), + gasObjects: (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeObjectRef)))).read(from), + gasPrice: (new FfiConverterOptional(FfiConverterUInt64)).read(from), + gasSponsor: (new FfiConverterOptional(FfiConverterTypeAddress)).read(from), + sender: (new FfiConverterOptional(FfiConverterTypeAddress)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + (new FfiConverterOptional(FfiConverterUInt64)).write(value.gasBudget, into); + (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeObjectRef)))).write(value.gasObjects, into); + (new FfiConverterOptional(FfiConverterUInt64)).write(value.gasPrice, into); + (new FfiConverterOptional(FfiConverterTypeAddress)).write(value.gasSponsor, into); + (new FfiConverterOptional(FfiConverterTypeAddress)).write(value.sender, into); + + } + allocationSize(value: TypeName): number { + return ( + (new FfiConverterOptional(FfiConverterUInt64)).allocationSize(value.gasBudget) + + (new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeObjectRef)))).allocationSize(value.gasObjects) + + (new FfiConverterOptional(FfiConverterUInt64)).allocationSize(value.gasPrice) + + (new FfiConverterOptional(FfiConverterTypeAddress)).allocationSize(value.gasSponsor) + + (new FfiConverterOptional(FfiConverterTypeAddress)).allocationSize(value.sender) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * The result of an async sign call containing the `UserSignature`. + */ +export type TransactionSignerFnOutput = {signature: UserSignature; +} + +export const TransactionSignerFnOutput = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link TransactionSignerFnOutput}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link TransactionSignerFnOutput}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeTransactionSignerFnOutput = (() => { + type TypeName = TransactionSignerFnOutput; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + signature: FfiConverterTypeUserSignature.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypeUserSignature.write(value.signature, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypeUserSignature.allocationSize(value.signature) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type TransactionsFilter = {function_?: string;kind?: TransactionBlockKindInput;afterCheckpoint?: /*u64*/bigint;atCheckpoint?: /*u64*/bigint;beforeCheckpoint?: /*u64*/bigint;signAddress?: Address;recvAddress?: Address;inputObject?: ObjectId;changedObject?: ObjectId;transactionIds?: Array;wrappedOrDeletedObject?: ObjectId; +} + +export const TransactionsFilter = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link TransactionsFilter}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link TransactionsFilter}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeTransactionsFilter = (() => { + type TypeName = TransactionsFilter; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + function_: (new FfiConverterOptional(FfiConverterString)).read(from), + kind: (new FfiConverterOptional(FfiConverterTypeTransactionBlockKindInput)).read(from), + afterCheckpoint: (new FfiConverterOptional(FfiConverterUInt64)).read(from), + atCheckpoint: (new FfiConverterOptional(FfiConverterUInt64)).read(from), + beforeCheckpoint: (new FfiConverterOptional(FfiConverterUInt64)).read(from), + signAddress: (new FfiConverterOptional(FfiConverterTypeAddress)).read(from), + recvAddress: (new FfiConverterOptional(FfiConverterTypeAddress)).read(from), + inputObject: (new FfiConverterOptional(FfiConverterTypeObjectId)).read(from), + changedObject: (new FfiConverterOptional(FfiConverterTypeObjectId)).read(from), + transactionIds: (new FfiConverterOptional((new FfiConverterArray(FfiConverterString)))).read(from), + wrappedOrDeletedObject: (new FfiConverterOptional(FfiConverterTypeObjectId)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + (new FfiConverterOptional(FfiConverterString)).write(value.function_, into); + (new FfiConverterOptional(FfiConverterTypeTransactionBlockKindInput)).write(value.kind, into); + (new FfiConverterOptional(FfiConverterUInt64)).write(value.afterCheckpoint, into); + (new FfiConverterOptional(FfiConverterUInt64)).write(value.atCheckpoint, into); + (new FfiConverterOptional(FfiConverterUInt64)).write(value.beforeCheckpoint, into); + (new FfiConverterOptional(FfiConverterTypeAddress)).write(value.signAddress, into); + (new FfiConverterOptional(FfiConverterTypeAddress)).write(value.recvAddress, into); + (new FfiConverterOptional(FfiConverterTypeObjectId)).write(value.inputObject, into); + (new FfiConverterOptional(FfiConverterTypeObjectId)).write(value.changedObject, into); + (new FfiConverterOptional((new FfiConverterArray(FfiConverterString)))).write(value.transactionIds, into); + (new FfiConverterOptional(FfiConverterTypeObjectId)).write(value.wrappedOrDeletedObject, into); + + } + allocationSize(value: TypeName): number { + return ( + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.function_) + + (new FfiConverterOptional(FfiConverterTypeTransactionBlockKindInput)).allocationSize(value.kind) + + (new FfiConverterOptional(FfiConverterUInt64)).allocationSize(value.afterCheckpoint) + + (new FfiConverterOptional(FfiConverterUInt64)).allocationSize(value.atCheckpoint) + + (new FfiConverterOptional(FfiConverterUInt64)).allocationSize(value.beforeCheckpoint) + + (new FfiConverterOptional(FfiConverterTypeAddress)).allocationSize(value.signAddress) + + (new FfiConverterOptional(FfiConverterTypeAddress)).allocationSize(value.recvAddress) + + (new FfiConverterOptional(FfiConverterTypeObjectId)).allocationSize(value.inputObject) + + (new FfiConverterOptional(FfiConverterTypeObjectId)).allocationSize(value.changedObject) + + (new FfiConverterOptional((new FfiConverterArray(FfiConverterString)))).allocationSize(value.transactionIds) + + (new FfiConverterOptional(FfiConverterTypeObjectId)).allocationSize(value.wrappedOrDeletedObject) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * Identifies a struct and the module it was defined in + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * type-origin = identifier identifier object-id + * ``` + */ +export type TypeOrigin = {moduleName: Identifier;structName: Identifier;package_: ObjectId; +} + +export const TypeOrigin = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link TypeOrigin}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link TypeOrigin}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeTypeOrigin = (() => { + type TypeName = TypeOrigin; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + moduleName: FfiConverterTypeIdentifier.read(from), + structName: FfiConverterTypeIdentifier.read(from), + package_: FfiConverterTypeObjectId.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypeIdentifier.write(value.moduleName, into); + FfiConverterTypeIdentifier.write(value.structName, into); + FfiConverterTypeObjectId.write(value.package_, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypeIdentifier.allocationSize(value.moduleName) + + FfiConverterTypeIdentifier.allocationSize(value.structName) + + FfiConverterTypeObjectId.allocationSize(value.package_) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * A shared object that wasn't changed during execution + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * unchanged-shared-object = object-id unchanged-shared-object-kind + * ``` + */ +export type UnchangedSharedObject = {objectId: ObjectId;kind: UnchangedSharedKind; +} + +export const UnchangedSharedObject = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link UnchangedSharedObject}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link UnchangedSharedObject}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeUnchangedSharedObject = (() => { + type TypeName = UnchangedSharedObject; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + objectId: FfiConverterTypeObjectId.read(from), + kind: FfiConverterTypeUnchangedSharedKind.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypeObjectId.write(value.objectId, into); + FfiConverterTypeUnchangedSharedKind.write(value.kind, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypeObjectId.allocationSize(value.objectId) + + FfiConverterTypeUnchangedSharedKind.allocationSize(value.kind) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * Upgraded package info for the linkage table + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * upgrade-info = object-id u64 + * ``` + */ +export type UpgradeInfo = { +/** + * Id of the upgraded packages + */upgradedId: ObjectId; +/** + * Version of the upgraded package + */upgradedVersion: /*u64*/bigint; +} + +export const UpgradeInfo = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link UpgradeInfo}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link UpgradeInfo}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeUpgradeInfo = (() => { + type TypeName = UpgradeInfo; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + upgradedId: FfiConverterTypeObjectId.read(from), + upgradedVersion: FfiConverterUInt64.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypeObjectId.write(value.upgradedId, into); + FfiConverterUInt64.write(value.upgradedVersion, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypeObjectId.allocationSize(value.upgradedId) + + FfiConverterUInt64.allocationSize(value.upgradedVersion) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * Represents a validator in the system. + */ +export type Validator = { +/** + * The APY of this validator in basis points. + * To get the APY in percentage, divide by 100. + */apy?: /*i32*/number; +/** + * The validator's address. + */address: Address; +/** + * The fee charged by the validator for staking services. + */commissionRate?: /*i32*/number; +/** + * Validator's credentials. + */credentials?: ValidatorCredentials; +/** + * Validator's description. + */description?: string; +/** + * Number of exchange rates in the table. + */exchangeRatesSize?: /*u64*/bigint; +/** + * The reference gas price for this epoch. + */gasPrice?: /*u64*/bigint; +/** + * Validator's name. + */name?: string; +/** + * Validator's url containing their custom image. + */imageUrl?: string; +/** + * The proposed next epoch fee for the validator's staking services. + */nextEpochCommissionRate?: /*i32*/number; +/** + * Validator's credentials for the next epoch. + */nextEpochCredentials?: ValidatorCredentials; +/** + * The validator's gas price quote for the next epoch. + */nextEpochGasPrice?: /*u64*/bigint; +/** + * The total number of IOTA tokens in this pool plus + * the pending stake amount for this epoch. + */nextEpochStake?: /*u64*/bigint; +/** + * The validator's current valid `Cap` object. Validators can delegate + * the operation ability to another address. The address holding this `Cap` + * object can then update the reference gas price and tallying rule on + * behalf of the validator. + */operationCap?: ArrayBuffer; +/** + * Pending pool token withdrawn during the current epoch, emptied at epoch + * boundaries. Zero for past epochs. + */pendingPoolTokenWithdraw?: /*u64*/bigint; +/** + * Pending stake amount for the current epoch, emptied at epoch boundaries. + * Zero for past epochs. + */pendingStake?: /*u64*/bigint; +/** + * Pending stake withdrawn during the current epoch, emptied at epoch + * boundaries. Zero for past epochs. + */pendingTotalIotaWithdraw?: /*u64*/bigint; +/** + * Total number of pool tokens issued by the pool. + */poolTokenBalance?: /*u64*/bigint; +/** + * Validator's homepage URL. + */projectUrl?: string; +/** + * The epoch stake rewards will be added here at the end of each epoch. + */rewardsPool?: /*u64*/bigint; +/** + * The epoch at which this pool became active. + */stakingPoolActivationEpoch?: /*u64*/bigint; +/** + * The ID of this validator's `0x3::staking_pool::StakingPool`. + */stakingPoolId: ObjectId; +/** + * The total number of IOTA tokens in this pool. + */stakingPoolIotaBalance?: /*u64*/bigint; +/** + * The voting power of this validator in basis points (e.g., 100 = 1% + * voting power). + */votingPower?: /*i32*/number; +} + +export const Validator = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link Validator}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link Validator}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeValidator = (() => { + type TypeName = Validator; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + apy: (new FfiConverterOptional(FfiConverterInt32)).read(from), + address: FfiConverterTypeAddress.read(from), + commissionRate: (new FfiConverterOptional(FfiConverterInt32)).read(from), + credentials: (new FfiConverterOptional(FfiConverterTypeValidatorCredentials)).read(from), + description: (new FfiConverterOptional(FfiConverterString)).read(from), + exchangeRatesSize: (new FfiConverterOptional(FfiConverterUInt64)).read(from), + gasPrice: (new FfiConverterOptional(FfiConverterUInt64)).read(from), + name: (new FfiConverterOptional(FfiConverterString)).read(from), + imageUrl: (new FfiConverterOptional(FfiConverterString)).read(from), + nextEpochCommissionRate: (new FfiConverterOptional(FfiConverterInt32)).read(from), + nextEpochCredentials: (new FfiConverterOptional(FfiConverterTypeValidatorCredentials)).read(from), + nextEpochGasPrice: (new FfiConverterOptional(FfiConverterUInt64)).read(from), + nextEpochStake: (new FfiConverterOptional(FfiConverterUInt64)).read(from), + operationCap: (new FfiConverterOptional(FfiConverterArrayBuffer)).read(from), + pendingPoolTokenWithdraw: (new FfiConverterOptional(FfiConverterUInt64)).read(from), + pendingStake: (new FfiConverterOptional(FfiConverterUInt64)).read(from), + pendingTotalIotaWithdraw: (new FfiConverterOptional(FfiConverterUInt64)).read(from), + poolTokenBalance: (new FfiConverterOptional(FfiConverterUInt64)).read(from), + projectUrl: (new FfiConverterOptional(FfiConverterString)).read(from), + rewardsPool: (new FfiConverterOptional(FfiConverterUInt64)).read(from), + stakingPoolActivationEpoch: (new FfiConverterOptional(FfiConverterUInt64)).read(from), + stakingPoolId: FfiConverterTypeObjectId.read(from), + stakingPoolIotaBalance: (new FfiConverterOptional(FfiConverterUInt64)).read(from), + votingPower: (new FfiConverterOptional(FfiConverterInt32)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + (new FfiConverterOptional(FfiConverterInt32)).write(value.apy, into); + FfiConverterTypeAddress.write(value.address, into); + (new FfiConverterOptional(FfiConverterInt32)).write(value.commissionRate, into); + (new FfiConverterOptional(FfiConverterTypeValidatorCredentials)).write(value.credentials, into); + (new FfiConverterOptional(FfiConverterString)).write(value.description, into); + (new FfiConverterOptional(FfiConverterUInt64)).write(value.exchangeRatesSize, into); + (new FfiConverterOptional(FfiConverterUInt64)).write(value.gasPrice, into); + (new FfiConverterOptional(FfiConverterString)).write(value.name, into); + (new FfiConverterOptional(FfiConverterString)).write(value.imageUrl, into); + (new FfiConverterOptional(FfiConverterInt32)).write(value.nextEpochCommissionRate, into); + (new FfiConverterOptional(FfiConverterTypeValidatorCredentials)).write(value.nextEpochCredentials, into); + (new FfiConverterOptional(FfiConverterUInt64)).write(value.nextEpochGasPrice, into); + (new FfiConverterOptional(FfiConverterUInt64)).write(value.nextEpochStake, into); + (new FfiConverterOptional(FfiConverterArrayBuffer)).write(value.operationCap, into); + (new FfiConverterOptional(FfiConverterUInt64)).write(value.pendingPoolTokenWithdraw, into); + (new FfiConverterOptional(FfiConverterUInt64)).write(value.pendingStake, into); + (new FfiConverterOptional(FfiConverterUInt64)).write(value.pendingTotalIotaWithdraw, into); + (new FfiConverterOptional(FfiConverterUInt64)).write(value.poolTokenBalance, into); + (new FfiConverterOptional(FfiConverterString)).write(value.projectUrl, into); + (new FfiConverterOptional(FfiConverterUInt64)).write(value.rewardsPool, into); + (new FfiConverterOptional(FfiConverterUInt64)).write(value.stakingPoolActivationEpoch, into); + FfiConverterTypeObjectId.write(value.stakingPoolId, into); + (new FfiConverterOptional(FfiConverterUInt64)).write(value.stakingPoolIotaBalance, into); + (new FfiConverterOptional(FfiConverterInt32)).write(value.votingPower, into); + + } + allocationSize(value: TypeName): number { + return ( + (new FfiConverterOptional(FfiConverterInt32)).allocationSize(value.apy) + + FfiConverterTypeAddress.allocationSize(value.address) + + (new FfiConverterOptional(FfiConverterInt32)).allocationSize(value.commissionRate) + + (new FfiConverterOptional(FfiConverterTypeValidatorCredentials)).allocationSize(value.credentials) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.description) + + (new FfiConverterOptional(FfiConverterUInt64)).allocationSize(value.exchangeRatesSize) + + (new FfiConverterOptional(FfiConverterUInt64)).allocationSize(value.gasPrice) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.name) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.imageUrl) + + (new FfiConverterOptional(FfiConverterInt32)).allocationSize(value.nextEpochCommissionRate) + + (new FfiConverterOptional(FfiConverterTypeValidatorCredentials)).allocationSize(value.nextEpochCredentials) + + (new FfiConverterOptional(FfiConverterUInt64)).allocationSize(value.nextEpochGasPrice) + + (new FfiConverterOptional(FfiConverterUInt64)).allocationSize(value.nextEpochStake) + + (new FfiConverterOptional(FfiConverterArrayBuffer)).allocationSize(value.operationCap) + + (new FfiConverterOptional(FfiConverterUInt64)).allocationSize(value.pendingPoolTokenWithdraw) + + (new FfiConverterOptional(FfiConverterUInt64)).allocationSize(value.pendingStake) + + (new FfiConverterOptional(FfiConverterUInt64)).allocationSize(value.pendingTotalIotaWithdraw) + + (new FfiConverterOptional(FfiConverterUInt64)).allocationSize(value.poolTokenBalance) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.projectUrl) + + (new FfiConverterOptional(FfiConverterUInt64)).allocationSize(value.rewardsPool) + + (new FfiConverterOptional(FfiConverterUInt64)).allocationSize(value.stakingPoolActivationEpoch) + + FfiConverterTypeObjectId.allocationSize(value.stakingPoolId) + + (new FfiConverterOptional(FfiConverterUInt64)).allocationSize(value.stakingPoolIotaBalance) + + (new FfiConverterOptional(FfiConverterInt32)).allocationSize(value.votingPower) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * The Validator Set for a particular epoch. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * validator-committee = u64 ; epoch + * (vector validator-committee-member) + * ``` + */ +export type ValidatorCommittee = {epoch: /*u64*/bigint;members: Array; +} + +export const ValidatorCommittee = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link ValidatorCommittee}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link ValidatorCommittee}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeValidatorCommittee = (() => { + type TypeName = ValidatorCommittee; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + epoch: FfiConverterUInt64.read(from), + members: (new FfiConverterArray(FfiConverterTypeValidatorCommitteeMember)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterUInt64.write(value.epoch, into); + (new FfiConverterArray(FfiConverterTypeValidatorCommitteeMember)).write(value.members, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterUInt64.allocationSize(value.epoch) + + (new FfiConverterArray(FfiConverterTypeValidatorCommitteeMember)).allocationSize(value.members) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * A member of a Validator Committee + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * validator-committee-member = bls-public-key + * u64 ; stake + * ``` + */ +export type ValidatorCommitteeMember = {publicKey: Bls12381PublicKey;stake: /*u64*/bigint; +} + +export const ValidatorCommitteeMember = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link ValidatorCommitteeMember}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link ValidatorCommitteeMember}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeValidatorCommitteeMember = (() => { + type TypeName = ValidatorCommitteeMember; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + publicKey: FfiConverterTypeBls12381PublicKey.read(from), + stake: FfiConverterUInt64.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypeBls12381PublicKey.write(value.publicKey, into); + FfiConverterUInt64.write(value.stake, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypeBls12381PublicKey.allocationSize(value.publicKey) + + FfiConverterUInt64.allocationSize(value.stake) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type ValidatorConnection = {pageInfo: PageInfo;nodes: Array; +} + +export const ValidatorConnection = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link ValidatorConnection}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link ValidatorConnection}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeValidatorConnection = (() => { + type TypeName = ValidatorConnection; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + pageInfo: FfiConverterTypePageInfo.read(from), + nodes: (new FfiConverterArray(FfiConverterTypeValidator)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypePageInfo.write(value.pageInfo, into); + (new FfiConverterArray(FfiConverterTypeValidator)).write(value.nodes, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypePageInfo.allocationSize(value.pageInfo) + + (new FfiConverterArray(FfiConverterTypeValidator)).allocationSize(value.nodes) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * The credentials related fields associated with a validator. + */ +export type ValidatorCredentials = {authorityPubKey?: string;networkPubKey?: string;protocolPubKey?: string;proofOfPossession?: string;netAddress?: string;p2pAddress?: string;primaryAddress?: string; +} + +export const ValidatorCredentials = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link ValidatorCredentials}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link ValidatorCredentials}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeValidatorCredentials = (() => { + type TypeName = ValidatorCredentials; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + authorityPubKey: (new FfiConverterOptional(FfiConverterString)).read(from), + networkPubKey: (new FfiConverterOptional(FfiConverterString)).read(from), + protocolPubKey: (new FfiConverterOptional(FfiConverterString)).read(from), + proofOfPossession: (new FfiConverterOptional(FfiConverterString)).read(from), + netAddress: (new FfiConverterOptional(FfiConverterString)).read(from), + p2pAddress: (new FfiConverterOptional(FfiConverterString)).read(from), + primaryAddress: (new FfiConverterOptional(FfiConverterString)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + (new FfiConverterOptional(FfiConverterString)).write(value.authorityPubKey, into); + (new FfiConverterOptional(FfiConverterString)).write(value.networkPubKey, into); + (new FfiConverterOptional(FfiConverterString)).write(value.protocolPubKey, into); + (new FfiConverterOptional(FfiConverterString)).write(value.proofOfPossession, into); + (new FfiConverterOptional(FfiConverterString)).write(value.netAddress, into); + (new FfiConverterOptional(FfiConverterString)).write(value.p2pAddress, into); + (new FfiConverterOptional(FfiConverterString)).write(value.primaryAddress, into); + + } + allocationSize(value: TypeName): number { + return ( + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.authorityPubKey) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.networkPubKey) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.protocolPubKey) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.proofOfPossession) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.netAddress) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.p2pAddress) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.primaryAddress) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * A page of items returned by the GraphQL server. + */ +export type ValidatorPage = { +/** + * Information about the page, such as the cursor and whether there are + * more pages. + */pageInfo: PageInfo; +/** + * The data returned by the server. + */data: Array; +} + +export const ValidatorPage = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link ValidatorPage}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link ValidatorPage}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeValidatorPage = (() => { + type TypeName = ValidatorPage; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + pageInfo: FfiConverterTypePageInfo.read(from), + data: (new FfiConverterArray(FfiConverterTypeValidator)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterTypePageInfo.write(value.pageInfo, into); + (new FfiConverterArray(FfiConverterTypeValidator)).write(value.data, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterTypePageInfo.allocationSize(value.pageInfo) + + (new FfiConverterArray(FfiConverterTypeValidator)).allocationSize(value.data) + + ); + } + } + return new FFIConverter(); +})(); + + + +export type ValidatorSet = { +/** + * Object ID of the `Table` storing the inactive staking pools. + */inactivePoolsId?: ObjectId; +/** + * Size of the inactive pools `Table`. + */inactivePoolsSize?: /*i32*/number; +/** + * Object ID of the wrapped object `TableVec` storing the pending active + * validators. + */pendingActiveValidatorsId?: ObjectId; +/** + * Size of the pending active validators table. + */pendingActiveValidatorsSize?: /*i32*/number; +/** + * Validators that are pending removal from the active validator set, + * expressed as indices in to `activeValidators`. + */pendingRemovals?: Array; +/** + * Object ID of the `Table` storing the mapping from staking pool ids to + * the addresses of the corresponding validators. This is needed + * because a validator's address can potentially change but the object + * ID of its pool will not. + */stakingPoolMappingsId?: ObjectId; +/** + * Size of the stake pool mappings `Table`. + */stakingPoolMappingsSize?: /*i32*/number; +/** + * Total amount of stake for all active validators at the beginning of the + * epoch. + */totalStake?: string; +/** + * Size of the validator candidates `Table`. + */validatorCandidatesSize?: /*i32*/number; +/** + * Object ID of the `Table` storing the validator candidates. + */validatorCandidatesId?: ObjectId; +} + +export const ValidatorSet = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link ValidatorSet}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link ValidatorSet}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeValidatorSet = (() => { + type TypeName = ValidatorSet; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + inactivePoolsId: (new FfiConverterOptional(FfiConverterTypeObjectId)).read(from), + inactivePoolsSize: (new FfiConverterOptional(FfiConverterInt32)).read(from), + pendingActiveValidatorsId: (new FfiConverterOptional(FfiConverterTypeObjectId)).read(from), + pendingActiveValidatorsSize: (new FfiConverterOptional(FfiConverterInt32)).read(from), + pendingRemovals: (new FfiConverterOptional((new FfiConverterArray(FfiConverterInt32)))).read(from), + stakingPoolMappingsId: (new FfiConverterOptional(FfiConverterTypeObjectId)).read(from), + stakingPoolMappingsSize: (new FfiConverterOptional(FfiConverterInt32)).read(from), + totalStake: (new FfiConverterOptional(FfiConverterString)).read(from), + validatorCandidatesSize: (new FfiConverterOptional(FfiConverterInt32)).read(from), + validatorCandidatesId: (new FfiConverterOptional(FfiConverterTypeObjectId)).read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + (new FfiConverterOptional(FfiConverterTypeObjectId)).write(value.inactivePoolsId, into); + (new FfiConverterOptional(FfiConverterInt32)).write(value.inactivePoolsSize, into); + (new FfiConverterOptional(FfiConverterTypeObjectId)).write(value.pendingActiveValidatorsId, into); + (new FfiConverterOptional(FfiConverterInt32)).write(value.pendingActiveValidatorsSize, into); + (new FfiConverterOptional((new FfiConverterArray(FfiConverterInt32)))).write(value.pendingRemovals, into); + (new FfiConverterOptional(FfiConverterTypeObjectId)).write(value.stakingPoolMappingsId, into); + (new FfiConverterOptional(FfiConverterInt32)).write(value.stakingPoolMappingsSize, into); + (new FfiConverterOptional(FfiConverterString)).write(value.totalStake, into); + (new FfiConverterOptional(FfiConverterInt32)).write(value.validatorCandidatesSize, into); + (new FfiConverterOptional(FfiConverterTypeObjectId)).write(value.validatorCandidatesId, into); + + } + allocationSize(value: TypeName): number { + return ( + (new FfiConverterOptional(FfiConverterTypeObjectId)).allocationSize(value.inactivePoolsId) + + (new FfiConverterOptional(FfiConverterInt32)).allocationSize(value.inactivePoolsSize) + + (new FfiConverterOptional(FfiConverterTypeObjectId)).allocationSize(value.pendingActiveValidatorsId) + + (new FfiConverterOptional(FfiConverterInt32)).allocationSize(value.pendingActiveValidatorsSize) + + (new FfiConverterOptional((new FfiConverterArray(FfiConverterInt32)))).allocationSize(value.pendingRemovals) + + (new FfiConverterOptional(FfiConverterTypeObjectId)).allocationSize(value.stakingPoolMappingsId) + + (new FfiConverterOptional(FfiConverterInt32)).allocationSize(value.stakingPoolMappingsSize) + + (new FfiConverterOptional(FfiConverterString)).allocationSize(value.totalStake) + + (new FfiConverterOptional(FfiConverterInt32)).allocationSize(value.validatorCandidatesSize) + + (new FfiConverterOptional(FfiConverterTypeObjectId)).allocationSize(value.validatorCandidatesId) + + ); + } + } + return new FFIConverter(); +})(); + + + +/** + * A claim of the iss in a zklogin proof + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * zklogin-claim = string u8 + * ``` + */ +export type ZkLoginClaim = {value: string;indexMod4: /*u8*/number; +} + +export const ZkLoginClaim = (() => { + const defaults = () => ({}); // FIXME: add defaults here! + const create = (() => { + return uniffiCreateRecord>( + defaults + ); + })(); + return Object.freeze({ + /** + * Create a frozen instance of {@link ZkLoginClaim}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + create, + + /** + * Create a frozen instance of {@link ZkLoginClaim}, with defaults specified + * in Rust, in the {@link iota_sdk_ffi} crate. + */ + new: create, + + /** + * Defaults specified in the {@link iota_sdk_ffi} crate. + */ + defaults: () => Object.freeze(defaults()) as Partial, + }); +})(); + +const FfiConverterTypeZkLoginClaim = (() => { + type TypeName = ZkLoginClaim; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeName { + return { + value: FfiConverterString.read(from), + indexMod4: FfiConverterUInt8.read(from), + + }; + } + write(value: TypeName, into: RustBuffer): void { + FfiConverterString.write(value.value, into); + FfiConverterUInt8.write(value.indexMod4, into); + + } + allocationSize(value: TypeName): number { + return ( + FfiConverterString.allocationSize(value.value) + + FfiConverterUInt8.allocationSize(value.indexMod4) + + ); + } + } + return new FFIConverter(); +})(); + + + +// ========== +// Enum definitions: +// ========== + + +export type BatchSendStatusType = + | "inProgress" + | "succeeded" + | "discarded" + +export const FfiConverterTypeBatchSendStatusType = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): BatchSendStatusType { + switch (ordinalConverter.read(from)) { + case 1: return "inProgress"; + case 2: return "succeeded"; + case 3: return "discarded"; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: BatchSendStatusType, into: RustBuffer): void { + switch (value) { + case "inProgress": ordinalConverter.write(1, into); break; + case "succeeded": ordinalConverter.write(2, into); break; + case "discarded": ordinalConverter.write(3, into); break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: BatchSendStatusType): number { + return ordinalConverter.allocationSize(0); + } + } + return new FFIConverter(); +})(); + +/** + * An error with an argument to a command + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * command-argument-error = type-mismatch + * =/ invalid-bcs-bytes + * =/ invalid-usage-of-pure-argument + * =/ invalid-argument-to-private-entry-function + * =/ index-out-of-bounds + * =/ secondary-index-out-of-bound + * =/ invalid-result-arity + * =/ invalid-gas-coin-usage + * =/ invalid-value-usage + * =/ invalid-object-by-value + * =/ invalid-object-by-mut-ref + * =/ shared-object-operation-not-allowed + * + * type-mismatch = %x00 + * invalid-bcs-bytes = %x01 + * invalid-usage-of-pure-argument = %x02 + * invalid-argument-to-private-entry-function = %x03 + * index-out-of-bounds = %x04 u16 + * secondary-index-out-of-bound = %x05 u16 u16 + * invalid-result-arity = %x06 u16 + * invalid-gas-coin-usage = %x07 + * invalid-value-usage = %x08 + * invalid-object-by-value = %x09 + * invalid-object-by-mut-ref = %x0a + * shared-object-operation-not-allowed = %x0b + * ``` + */ +export type CommandArgumentError = + /** + * The type of the value does not match the expected type + */ + | { + tag: "typeMismatch" + } + /** + * The argument cannot be deserialized into a value of the specified type + */ + | { + tag: "invalidBcsBytes" + } + /** + * The argument cannot be instantiated from raw bytes + */ + | { + tag: "invalidUsageOfPureArgument" + } + /** + * Invalid argument to private entry function. + * Private entry functions cannot take arguments from other Move functions. + */ + | { + tag: "invalidArgumentToPrivateEntryFunction" + } + /** + * Out of bounds access to input or results + */ + | { + tag: "indexOutOfBounds", + inner: Readonly<{index: /*u16*/number}> + } + /** + * Out of bounds access to subresult + */ + | { + tag: "secondaryIndexOutOfBounds", + inner: Readonly<{result: /*u16*/number; subresult: /*u16*/number}> + } + /** + * Invalid usage of result. + * Expected a single result but found either no return value or multiple. + */ + | { + tag: "invalidResultArity", + inner: Readonly<{result: /*u16*/number}> + } + /** + * Invalid usage of Gas coin. + * The Gas coin can only be used by-value with a TransferObjects command. + */ + | { + tag: "invalidGasCoinUsage" + } + /** + * Invalid usage of move value. + */ + | { + tag: "invalidValueUsage" + } + /** + * Immutable objects cannot be passed by-value. + */ + | { + tag: "invalidObjectByValue" + } + /** + * Immutable objects cannot be passed by mutable reference, &mut. + */ + | { + tag: "invalidObjectByMutRef" + } + /** + * Shared object operations such a wrapping, freezing, or converting to + * owned are not allowed. + */ + | { + tag: "sharedObjectOperationNotAllowed" + } + /** + * Invalid argument arity. Expected a single argument but found a result + * that expanded to multiple arguments. + */ + | { + tag: "invalidArgumentArity" + } + +export const FfiConverterTypeCommandArgumentError = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): CommandArgumentError { + switch (ordinalConverter.read(from)) { + case 1: + return { + tag: "typeMismatch" + }; + case 2: + return { + tag: "invalidBcsBytes" + }; + case 3: + return { + tag: "invalidUsageOfPureArgument" + }; + case 4: + return { + tag: "invalidArgumentToPrivateEntryFunction" + }; + case 5: + return { + tag: "indexOutOfBounds", + inner: { + index: FfiConverterUInt16.read(from) + } + }; + case 6: + return { + tag: "secondaryIndexOutOfBounds", + inner: { + result: FfiConverterUInt16.read(from), + subresult: FfiConverterUInt16.read(from) + } + }; + case 7: + return { + tag: "invalidResultArity", + inner: { + result: FfiConverterUInt16.read(from) + } + }; + case 8: + return { + tag: "invalidGasCoinUsage" + }; + case 9: + return { + tag: "invalidValueUsage" + }; + case 10: + return { + tag: "invalidObjectByValue" + }; + case 11: + return { + tag: "invalidObjectByMutRef" + }; + case 12: + return { + tag: "sharedObjectOperationNotAllowed" + }; + case 13: + return { + tag: "invalidArgumentArity" + }; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: CommandArgumentError, into: RustBuffer): void { + switch (value.tag) { + case "typeMismatch": + ordinalConverter.write(1, into); + break; + case "invalidBcsBytes": + ordinalConverter.write(2, into); + break; + case "invalidUsageOfPureArgument": + ordinalConverter.write(3, into); + break; + case "invalidArgumentToPrivateEntryFunction": + ordinalConverter.write(4, into); + break; + case "indexOutOfBounds": + ordinalConverter.write(5, into); + FfiConverterUInt16.write(value.inner.index, into); + break; + case "secondaryIndexOutOfBounds": + ordinalConverter.write(6, into); + FfiConverterUInt16.write(value.inner.result, into); + FfiConverterUInt16.write(value.inner.subresult, into); + break; + case "invalidResultArity": + ordinalConverter.write(7, into); + FfiConverterUInt16.write(value.inner.result, into); + break; + case "invalidGasCoinUsage": + ordinalConverter.write(8, into); + break; + case "invalidValueUsage": + ordinalConverter.write(9, into); + break; + case "invalidObjectByValue": + ordinalConverter.write(10, into); + break; + case "invalidObjectByMutRef": + ordinalConverter.write(11, into); + break; + case "sharedObjectOperationNotAllowed": + ordinalConverter.write(12, into); + break; + case "invalidArgumentArity": + ordinalConverter.write(13, into); + break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: CommandArgumentError): number { + switch (value.tag) { + case "typeMismatch": + return ordinalConverter.allocationSize(1); + case "invalidBcsBytes": + return ordinalConverter.allocationSize(2); + case "invalidUsageOfPureArgument": + return ordinalConverter.allocationSize(3); + case "invalidArgumentToPrivateEntryFunction": + return ordinalConverter.allocationSize(4); + case "indexOutOfBounds": + return ordinalConverter.allocationSize(5) + + FfiConverterUInt16.allocationSize(value.inner.index); + case "secondaryIndexOutOfBounds": + return ordinalConverter.allocationSize(6) + + FfiConverterUInt16.allocationSize(value.inner.result) + + FfiConverterUInt16.allocationSize(value.inner.subresult); + case "invalidResultArity": + return ordinalConverter.allocationSize(7) + + FfiConverterUInt16.allocationSize(value.inner.result); + case "invalidGasCoinUsage": + return ordinalConverter.allocationSize(8); + case "invalidValueUsage": + return ordinalConverter.allocationSize(9); + case "invalidObjectByValue": + return ordinalConverter.allocationSize(10); + case "invalidObjectByMutRef": + return ordinalConverter.allocationSize(11); + case "sharedObjectOperationNotAllowed": + return ordinalConverter.allocationSize(12); + case "invalidArgumentArity": + return ordinalConverter.allocationSize(13); + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + } + return new FFIConverter(); +})(); + +/** + * Pagination direction. + */ +export type Direction = + | "forward" + | "backward" + +export const FfiConverterTypeDirection = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): Direction { + switch (ordinalConverter.read(from)) { + case 1: return "forward"; + case 2: return "backward"; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: Direction, into: RustBuffer): void { + switch (value) { + case "forward": ordinalConverter.write(1, into); break; + case "backward": ordinalConverter.write(2, into); break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: Direction): number { + return ordinalConverter.allocationSize(0); + } + } + return new FFIConverter(); +})(); + +/** + * An error that can occur during the execution of a transaction + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * + * execution-error = insufficient-gas + * =/ invalid-gas-object + * =/ invariant-violation + * =/ feature-not-yet-supported + * =/ object-too-big + * =/ package-too-big + * =/ circular-object-ownership + * =/ insufficient-coin-balance + * =/ coin-balance-overflow + * =/ publish-error-non-zero-address + * =/ iota-move-verification-error + * =/ move-primitive-runtime-error + * =/ move-abort + * =/ vm-verification-or-deserialization-error + * =/ vm-invariant-violation + * =/ function-not-found + * =/ arity-mismatch + * =/ type-arity-mismatch + * =/ non-entry-function-invoked + * =/ command-argument-error + * =/ type-argument-error + * =/ unused-value-without-drop + * =/ invalid-public-function-return-type + * =/ invalid-transfer-object + * =/ effects-too-large + * =/ publish-upgrade-missing-dependency + * =/ publish-upgrade-dependency-downgrade + * =/ package-upgrade-error + * =/ written-objects-too-large + * =/ certificate-denied + * =/ iota-move-verification-timeout + * =/ shared-object-operation-not-allowed + * =/ input-object-deleted + * =/ execution-cancelled-due-to-shared-object-congestion + * =/ address-denied-for-coin + * =/ coin-type-global-pause + * =/ execution-cancelled-due-to-randomness-unavailable + * + * insufficient-gas = %x00 + * invalid-gas-object = %x01 + * invariant-violation = %x02 + * feature-not-yet-supported = %x03 + * object-too-big = %x04 u64 u64 + * package-too-big = %x05 u64 u64 + * circular-object-ownership = %x06 object-id + * insufficient-coin-balance = %x07 + * coin-balance-overflow = %x08 + * publish-error-non-zero-address = %x09 + * iota-move-verification-error = %x0a + * move-primitive-runtime-error = %x0b (option move-location) + * move-abort = %x0c move-location u64 + * vm-verification-or-deserialization-error = %x0d + * vm-invariant-violation = %x0e + * function-not-found = %x0f + * arity-mismatch = %x10 + * type-arity-mismatch = %x11 + * non-entry-function-invoked = %x12 + * command-argument-error = %x13 u16 command-argument-error + * type-argument-error = %x14 u16 type-argument-error + * unused-value-without-drop = %x15 u16 u16 + * invalid-public-function-return-type = %x16 u16 + * invalid-transfer-object = %x17 + * effects-too-large = %x18 u64 u64 + * publish-upgrade-missing-dependency = %x19 + * publish-upgrade-dependency-downgrade = %x1a + * package-upgrade-error = %x1b package-upgrade-error + * written-objects-too-large = %x1c u64 u64 + * certificate-denied = %x1d + * iota-move-verification-timeout = %x1e + * shared-object-operation-not-allowed = %x1f + * input-object-deleted = %x20 + * execution-cancelled-due-to-shared-object-congestion = %x21 (vector object-id) + * address-denied-for-coin = %x22 address string + * coin-type-global-pause = %x23 string + * execution-cancelled-due-to-randomness-unavailable = %x24 + * ``` + */ +export type ExecutionError = + /** + * Insufficient Gas + */ + | { + tag: "insufficientGas" + } + /** + * Invalid Gas Object. + */ + | { + tag: "invalidGasObject" + } + /** + * Invariant Violation + */ + | { + tag: "invariantViolation" + } + /** + * Attempted to used feature that is not supported yet + */ + | { + tag: "featureNotYetSupported" + } + /** + * Move object is larger than the maximum allowed size + */ + | { + tag: "objectTooBig", + inner: Readonly<{objectSize: /*u64*/bigint; maxObjectSize: /*u64*/bigint}> + } + /** + * Package is larger than the maximum allowed size + */ + | { + tag: "packageTooBig", + inner: Readonly<{objectSize: /*u64*/bigint; maxObjectSize: /*u64*/bigint}> + } + /** + * Circular Object Ownership + */ + | { + tag: "circularObjectOwnership", + inner: Readonly<{object: ObjectId}> + } + /** + * Insufficient coin balance for requested operation + */ + | { + tag: "insufficientCoinBalance" + } + /** + * Coin balance overflowed an u64 + */ + | { + tag: "coinBalanceOverflow" + } + /** + * Publish Error, Non-zero Address. + * The modules in the package must have their self-addresses set to zero. + */ + | { + tag: "publishErrorNonZeroAddress" + } + /** + * IOTA Move Bytecode Verification Error. + */ + | { + tag: "iotaMoveVerification" + } + /** + * Error from a non-abort instruction. + * Possible causes: + * Arithmetic error, stack overflow, max value depth, etc." + */ + | { + tag: "movePrimitiveRuntime", + inner: Readonly<{location: MoveLocation | undefined}> + } + /** + * Move runtime abort + */ + | { + tag: "moveAbort", + inner: Readonly<{location: MoveLocation; code: /*u64*/bigint}> + } + /** + * Bytecode verification error. + */ + | { + tag: "vmVerificationOrDeserialization" + } + /** + * MoveVm invariant violation + */ + | { + tag: "vmInvariantViolation" + } + /** + * Function not found + */ + | { + tag: "functionNotFound" + } + /** + * Arity mismatch for Move function. + * The number of arguments does not match the number of parameters + */ + | { + tag: "arityMismatch" + } + /** + * Type arity mismatch for Move function. + * Mismatch between the number of actual versus expected type arguments. + */ + | { + tag: "typeArityMismatch" + } + /** + * Non Entry Function Invoked. Move Call must start with an entry function. + */ + | { + tag: "nonEntryFunctionInvoked" + } + /** + * Invalid command argument + */ + | { + tag: "commandArgument", + inner: Readonly<{argument: /*u16*/number; kind: CommandArgumentError}> + } + /** + * Type argument error + */ + | { + tag: "typeArgument", + inner: Readonly<{typeArgument: /*u16*/number; kind: TypeArgumentError}> + } + /** + * Unused result without the drop ability. + */ + | { + tag: "unusedValueWithoutDrop", + inner: Readonly<{result: /*u16*/number; subresult: /*u16*/number}> + } + /** + * Invalid public Move function signature. + * Unsupported return type for return value + */ + | { + tag: "invalidPublicFunctionReturnType", + inner: Readonly<{index: /*u16*/number}> + } + /** + * Invalid Transfer Object, object does not have public transfer. + */ + | { + tag: "invalidTransferObject" + } + /** + * Effects from the transaction are too large + */ + | { + tag: "effectsTooLarge", + inner: Readonly<{currentSize: /*u64*/bigint; maxSize: /*u64*/bigint}> + } + /** + * Publish or Upgrade is missing dependency + */ + | { + tag: "publishUpgradeMissingDependency" + } + /** + * Publish or Upgrade dependency downgrade. + * + * Indirect (transitive) dependency of published or upgraded package has + * been assigned an on-chain version that is less than the version + * required by one of the package's transitive dependencies. + */ + | { + tag: "publishUpgradeDependencyDowngrade" + } + /** + * Invalid package upgrade + */ + | { + tag: "packageUpgrade", + inner: Readonly<{kind: PackageUpgradeError}> + } + /** + * Indicates the transaction tried to write objects too large to storage + */ + | { + tag: "writtenObjectsTooLarge", + inner: Readonly<{objectSize: /*u64*/bigint; maxObjectSize: /*u64*/bigint}> + } + /** + * Certificate is on the deny list + */ + | { + tag: "certificateDenied" + } + /** + * IOTA Move Bytecode verification timed out. + */ + | { + tag: "iotaMoveVerificationTimeout" + } + /** + * The requested shared object operation is not allowed + */ + | { + tag: "sharedObjectOperationNotAllowed" + } + /** + * Requested shared object has been deleted + */ + | { + tag: "inputObjectDeleted" + } + /** + * Certificate is cancelled due to congestion on shared objects + */ + | { + tag: "executionCancelledDueToSharedObjectCongestion", + inner: Readonly<{congestedObjects: Array}> + } + /** + * Certificate is cancelled due to congestion on shared objects; + * suggested gas price can be used to give this certificate more priority. + */ + | { + tag: "executionCancelledDueToSharedObjectCongestionV2", + inner: Readonly<{congestedObjects: Array; suggestedGasPrice: /*u64*/bigint}> + } + /** + * Address is denied for this coin type + */ + | { + tag: "addressDeniedForCoin", + inner: Readonly<{address: Address; coinType: string}> + } + /** + * Coin type is globally paused for use + */ + | { + tag: "coinTypeGlobalPause", + inner: Readonly<{coinType: string}> + } + /** + * Certificate is cancelled because randomness could not be generated this + * epoch + */ + | { + tag: "executionCancelledDueToRandomnessUnavailable" + } + /** + * A valid linkage was unable to be determined for the transaction or one + * of its commands. + */ + | { + tag: "invalidLinkage" + } + +export const FfiConverterTypeExecutionError = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): ExecutionError { + switch (ordinalConverter.read(from)) { + case 1: + return { + tag: "insufficientGas" + }; + case 2: + return { + tag: "invalidGasObject" + }; + case 3: + return { + tag: "invariantViolation" + }; + case 4: + return { + tag: "featureNotYetSupported" + }; + case 5: + return { + tag: "objectTooBig", + inner: { + objectSize: FfiConverterUInt64.read(from), + maxObjectSize: FfiConverterUInt64.read(from) + } + }; + case 6: + return { + tag: "packageTooBig", + inner: { + objectSize: FfiConverterUInt64.read(from), + maxObjectSize: FfiConverterUInt64.read(from) + } + }; + case 7: + return { + tag: "circularObjectOwnership", + inner: { + object: FfiConverterTypeObjectId.read(from) + } + }; + case 8: + return { + tag: "insufficientCoinBalance" + }; + case 9: + return { + tag: "coinBalanceOverflow" + }; + case 10: + return { + tag: "publishErrorNonZeroAddress" + }; + case 11: + return { + tag: "iotaMoveVerification" + }; + case 12: + return { + tag: "movePrimitiveRuntime", + inner: { + location: (new FfiConverterOptional(FfiConverterTypeMoveLocation)).read(from) + } + }; + case 13: + return { + tag: "moveAbort", + inner: { + location: FfiConverterTypeMoveLocation.read(from), + code: FfiConverterUInt64.read(from) + } + }; + case 14: + return { + tag: "vmVerificationOrDeserialization" + }; + case 15: + return { + tag: "vmInvariantViolation" + }; + case 16: + return { + tag: "functionNotFound" + }; + case 17: + return { + tag: "arityMismatch" + }; + case 18: + return { + tag: "typeArityMismatch" + }; + case 19: + return { + tag: "nonEntryFunctionInvoked" + }; + case 20: + return { + tag: "commandArgument", + inner: { + argument: FfiConverterUInt16.read(from), + kind: FfiConverterTypeCommandArgumentError.read(from) + } + }; + case 21: + return { + tag: "typeArgument", + inner: { + typeArgument: FfiConverterUInt16.read(from), + kind: FfiConverterTypeTypeArgumentError.read(from) + } + }; + case 22: + return { + tag: "unusedValueWithoutDrop", + inner: { + result: FfiConverterUInt16.read(from), + subresult: FfiConverterUInt16.read(from) + } + }; + case 23: + return { + tag: "invalidPublicFunctionReturnType", + inner: { + index: FfiConverterUInt16.read(from) + } + }; + case 24: + return { + tag: "invalidTransferObject" + }; + case 25: + return { + tag: "effectsTooLarge", + inner: { + currentSize: FfiConverterUInt64.read(from), + maxSize: FfiConverterUInt64.read(from) + } + }; + case 26: + return { + tag: "publishUpgradeMissingDependency" + }; + case 27: + return { + tag: "publishUpgradeDependencyDowngrade" + }; + case 28: + return { + tag: "packageUpgrade", + inner: { + kind: FfiConverterTypePackageUpgradeError.read(from) + } + }; + case 29: + return { + tag: "writtenObjectsTooLarge", + inner: { + objectSize: FfiConverterUInt64.read(from), + maxObjectSize: FfiConverterUInt64.read(from) + } + }; + case 30: + return { + tag: "certificateDenied" + }; + case 31: + return { + tag: "iotaMoveVerificationTimeout" + }; + case 32: + return { + tag: "sharedObjectOperationNotAllowed" + }; + case 33: + return { + tag: "inputObjectDeleted" + }; + case 34: + return { + tag: "executionCancelledDueToSharedObjectCongestion", + inner: { + congestedObjects: (new FfiConverterArray(FfiConverterTypeObjectId)).read(from) + } + }; + case 35: + return { + tag: "executionCancelledDueToSharedObjectCongestionV2", + inner: { + congestedObjects: (new FfiConverterArray(FfiConverterTypeObjectId)).read(from), + suggestedGasPrice: FfiConverterUInt64.read(from) + } + }; + case 36: + return { + tag: "addressDeniedForCoin", + inner: { + address: FfiConverterTypeAddress.read(from), + coinType: FfiConverterString.read(from) + } + }; + case 37: + return { + tag: "coinTypeGlobalPause", + inner: { + coinType: FfiConverterString.read(from) + } + }; + case 38: + return { + tag: "executionCancelledDueToRandomnessUnavailable" + }; + case 39: + return { + tag: "invalidLinkage" + }; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: ExecutionError, into: RustBuffer): void { + switch (value.tag) { + case "insufficientGas": + ordinalConverter.write(1, into); + break; + case "invalidGasObject": + ordinalConverter.write(2, into); + break; + case "invariantViolation": + ordinalConverter.write(3, into); + break; + case "featureNotYetSupported": + ordinalConverter.write(4, into); + break; + case "objectTooBig": + ordinalConverter.write(5, into); + FfiConverterUInt64.write(value.inner.objectSize, into); + FfiConverterUInt64.write(value.inner.maxObjectSize, into); + break; + case "packageTooBig": + ordinalConverter.write(6, into); + FfiConverterUInt64.write(value.inner.objectSize, into); + FfiConverterUInt64.write(value.inner.maxObjectSize, into); + break; + case "circularObjectOwnership": + ordinalConverter.write(7, into); + FfiConverterTypeObjectId.write(value.inner.object, into); + break; + case "insufficientCoinBalance": + ordinalConverter.write(8, into); + break; + case "coinBalanceOverflow": + ordinalConverter.write(9, into); + break; + case "publishErrorNonZeroAddress": + ordinalConverter.write(10, into); + break; + case "iotaMoveVerification": + ordinalConverter.write(11, into); + break; + case "movePrimitiveRuntime": + ordinalConverter.write(12, into); + (new FfiConverterOptional(FfiConverterTypeMoveLocation)).write(value.inner.location, into); + break; + case "moveAbort": + ordinalConverter.write(13, into); + FfiConverterTypeMoveLocation.write(value.inner.location, into); + FfiConverterUInt64.write(value.inner.code, into); + break; + case "vmVerificationOrDeserialization": + ordinalConverter.write(14, into); + break; + case "vmInvariantViolation": + ordinalConverter.write(15, into); + break; + case "functionNotFound": + ordinalConverter.write(16, into); + break; + case "arityMismatch": + ordinalConverter.write(17, into); + break; + case "typeArityMismatch": + ordinalConverter.write(18, into); + break; + case "nonEntryFunctionInvoked": + ordinalConverter.write(19, into); + break; + case "commandArgument": + ordinalConverter.write(20, into); + FfiConverterUInt16.write(value.inner.argument, into); + FfiConverterTypeCommandArgumentError.write(value.inner.kind, into); + break; + case "typeArgument": + ordinalConverter.write(21, into); + FfiConverterUInt16.write(value.inner.typeArgument, into); + FfiConverterTypeTypeArgumentError.write(value.inner.kind, into); + break; + case "unusedValueWithoutDrop": + ordinalConverter.write(22, into); + FfiConverterUInt16.write(value.inner.result, into); + FfiConverterUInt16.write(value.inner.subresult, into); + break; + case "invalidPublicFunctionReturnType": + ordinalConverter.write(23, into); + FfiConverterUInt16.write(value.inner.index, into); + break; + case "invalidTransferObject": + ordinalConverter.write(24, into); + break; + case "effectsTooLarge": + ordinalConverter.write(25, into); + FfiConverterUInt64.write(value.inner.currentSize, into); + FfiConverterUInt64.write(value.inner.maxSize, into); + break; + case "publishUpgradeMissingDependency": + ordinalConverter.write(26, into); + break; + case "publishUpgradeDependencyDowngrade": + ordinalConverter.write(27, into); + break; + case "packageUpgrade": + ordinalConverter.write(28, into); + FfiConverterTypePackageUpgradeError.write(value.inner.kind, into); + break; + case "writtenObjectsTooLarge": + ordinalConverter.write(29, into); + FfiConverterUInt64.write(value.inner.objectSize, into); + FfiConverterUInt64.write(value.inner.maxObjectSize, into); + break; + case "certificateDenied": + ordinalConverter.write(30, into); + break; + case "iotaMoveVerificationTimeout": + ordinalConverter.write(31, into); + break; + case "sharedObjectOperationNotAllowed": + ordinalConverter.write(32, into); + break; + case "inputObjectDeleted": + ordinalConverter.write(33, into); + break; + case "executionCancelledDueToSharedObjectCongestion": + ordinalConverter.write(34, into); + (new FfiConverterArray(FfiConverterTypeObjectId)).write(value.inner.congestedObjects, into); + break; + case "executionCancelledDueToSharedObjectCongestionV2": + ordinalConverter.write(35, into); + (new FfiConverterArray(FfiConverterTypeObjectId)).write(value.inner.congestedObjects, into); + FfiConverterUInt64.write(value.inner.suggestedGasPrice, into); + break; + case "addressDeniedForCoin": + ordinalConverter.write(36, into); + FfiConverterTypeAddress.write(value.inner.address, into); + FfiConverterString.write(value.inner.coinType, into); + break; + case "coinTypeGlobalPause": + ordinalConverter.write(37, into); + FfiConverterString.write(value.inner.coinType, into); + break; + case "executionCancelledDueToRandomnessUnavailable": + ordinalConverter.write(38, into); + break; + case "invalidLinkage": + ordinalConverter.write(39, into); + break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: ExecutionError): number { + switch (value.tag) { + case "insufficientGas": + return ordinalConverter.allocationSize(1); + case "invalidGasObject": + return ordinalConverter.allocationSize(2); + case "invariantViolation": + return ordinalConverter.allocationSize(3); + case "featureNotYetSupported": + return ordinalConverter.allocationSize(4); + case "objectTooBig": + return ordinalConverter.allocationSize(5) + + FfiConverterUInt64.allocationSize(value.inner.objectSize) + + FfiConverterUInt64.allocationSize(value.inner.maxObjectSize); + case "packageTooBig": + return ordinalConverter.allocationSize(6) + + FfiConverterUInt64.allocationSize(value.inner.objectSize) + + FfiConverterUInt64.allocationSize(value.inner.maxObjectSize); + case "circularObjectOwnership": + return ordinalConverter.allocationSize(7) + + FfiConverterTypeObjectId.allocationSize(value.inner.object); + case "insufficientCoinBalance": + return ordinalConverter.allocationSize(8); + case "coinBalanceOverflow": + return ordinalConverter.allocationSize(9); + case "publishErrorNonZeroAddress": + return ordinalConverter.allocationSize(10); + case "iotaMoveVerification": + return ordinalConverter.allocationSize(11); + case "movePrimitiveRuntime": + return ordinalConverter.allocationSize(12) + + (new FfiConverterOptional(FfiConverterTypeMoveLocation)).allocationSize(value.inner.location); + case "moveAbort": + return ordinalConverter.allocationSize(13) + + FfiConverterTypeMoveLocation.allocationSize(value.inner.location) + + FfiConverterUInt64.allocationSize(value.inner.code); + case "vmVerificationOrDeserialization": + return ordinalConverter.allocationSize(14); + case "vmInvariantViolation": + return ordinalConverter.allocationSize(15); + case "functionNotFound": + return ordinalConverter.allocationSize(16); + case "arityMismatch": + return ordinalConverter.allocationSize(17); + case "typeArityMismatch": + return ordinalConverter.allocationSize(18); + case "nonEntryFunctionInvoked": + return ordinalConverter.allocationSize(19); + case "commandArgument": + return ordinalConverter.allocationSize(20) + + FfiConverterUInt16.allocationSize(value.inner.argument) + + FfiConverterTypeCommandArgumentError.allocationSize(value.inner.kind); + case "typeArgument": + return ordinalConverter.allocationSize(21) + + FfiConverterUInt16.allocationSize(value.inner.typeArgument) + + FfiConverterTypeTypeArgumentError.allocationSize(value.inner.kind); + case "unusedValueWithoutDrop": + return ordinalConverter.allocationSize(22) + + FfiConverterUInt16.allocationSize(value.inner.result) + + FfiConverterUInt16.allocationSize(value.inner.subresult); + case "invalidPublicFunctionReturnType": + return ordinalConverter.allocationSize(23) + + FfiConverterUInt16.allocationSize(value.inner.index); + case "invalidTransferObject": + return ordinalConverter.allocationSize(24); + case "effectsTooLarge": + return ordinalConverter.allocationSize(25) + + FfiConverterUInt64.allocationSize(value.inner.currentSize) + + FfiConverterUInt64.allocationSize(value.inner.maxSize); + case "publishUpgradeMissingDependency": + return ordinalConverter.allocationSize(26); + case "publishUpgradeDependencyDowngrade": + return ordinalConverter.allocationSize(27); + case "packageUpgrade": + return ordinalConverter.allocationSize(28) + + FfiConverterTypePackageUpgradeError.allocationSize(value.inner.kind); + case "writtenObjectsTooLarge": + return ordinalConverter.allocationSize(29) + + FfiConverterUInt64.allocationSize(value.inner.objectSize) + + FfiConverterUInt64.allocationSize(value.inner.maxObjectSize); + case "certificateDenied": + return ordinalConverter.allocationSize(30); + case "iotaMoveVerificationTimeout": + return ordinalConverter.allocationSize(31); + case "sharedObjectOperationNotAllowed": + return ordinalConverter.allocationSize(32); + case "inputObjectDeleted": + return ordinalConverter.allocationSize(33); + case "executionCancelledDueToSharedObjectCongestion": + return ordinalConverter.allocationSize(34) + + (new FfiConverterArray(FfiConverterTypeObjectId)).allocationSize(value.inner.congestedObjects); + case "executionCancelledDueToSharedObjectCongestionV2": + return ordinalConverter.allocationSize(35) + + (new FfiConverterArray(FfiConverterTypeObjectId)).allocationSize(value.inner.congestedObjects) + + FfiConverterUInt64.allocationSize(value.inner.suggestedGasPrice); + case "addressDeniedForCoin": + return ordinalConverter.allocationSize(36) + + FfiConverterTypeAddress.allocationSize(value.inner.address) + + FfiConverterString.allocationSize(value.inner.coinType); + case "coinTypeGlobalPause": + return ordinalConverter.allocationSize(37) + + FfiConverterString.allocationSize(value.inner.coinType); + case "executionCancelledDueToRandomnessUnavailable": + return ordinalConverter.allocationSize(38); + case "invalidLinkage": + return ordinalConverter.allocationSize(39); + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + } + return new FFIConverter(); +})(); + +/** + * The status of an executed Transaction + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * execution-status = success / failure + * success = %x00 + * failure = %x01 execution-error (option u64) + * ``` + */ +export type ExecutionStatus = + /** + * The Transaction successfully executed. + */ + | { + tag: "success" + } + /** + * The Transaction didn't execute successfully. + * + * Failed transactions are still committed to the blockchain but any + * intended effects are rolled back to prior to this transaction + * executing with the caveat that gas objects are still smashed and gas + * usage is still charged. + */ + | { + tag: "failure", + inner: Readonly<{error: ExecutionError; command: /*u64*/bigint | undefined}> + } + +export const FfiConverterTypeExecutionStatus = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): ExecutionStatus { + switch (ordinalConverter.read(from)) { + case 1: + return { + tag: "success" + }; + case 2: + return { + tag: "failure", + inner: { + error: FfiConverterTypeExecutionError.read(from), + command: (new FfiConverterOptional(FfiConverterUInt64)).read(from) + } + }; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: ExecutionStatus, into: RustBuffer): void { + switch (value.tag) { + case "success": + ordinalConverter.write(1, into); + break; + case "failure": + ordinalConverter.write(2, into); + FfiConverterTypeExecutionError.write(value.inner.error, into); + (new FfiConverterOptional(FfiConverterUInt64)).write(value.inner.command, into); + break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: ExecutionStatus): number { + switch (value.tag) { + case "success": + return ordinalConverter.allocationSize(1); + case "failure": + return ordinalConverter.allocationSize(2) + + FfiConverterTypeExecutionError.allocationSize(value.inner.error) + + (new FfiConverterOptional(FfiConverterUInt64)).allocationSize(value.inner.command); + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + } + return new FFIConverter(); +})(); + +export type Feature = + | "analytics" + | "coins" + | "dynamicFields" + | "subscriptions" + | "systemState" + +export const FfiConverterTypeFeature = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): Feature { + switch (ordinalConverter.read(from)) { + case 1: return "analytics"; + case 2: return "coins"; + case 3: return "dynamicFields"; + case 4: return "subscriptions"; + case 5: return "systemState"; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: Feature, into: RustBuffer): void { + switch (value) { + case "analytics": ordinalConverter.write(1, into); break; + case "coins": ordinalConverter.write(2, into); break; + case "dynamicFields": ordinalConverter.write(3, into); break; + case "subscriptions": ordinalConverter.write(4, into); break; + case "systemState": ordinalConverter.write(5, into); break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: Feature): number { + return ordinalConverter.allocationSize(0); + } + } + return new FFIConverter(); +})(); + +/** + * A 1-byte domain separator for hashing Object ID in IOTA. It starts from + * 0xf0 to ensure no hashing collision for any ObjectID vs IotaAddress which is + * derived as the hash of `flag || pubkey`. + */ +export type HashingIntentScope = + | "childObjectId" + | "regularObjectId" + +export const FfiConverterTypeHashingIntentScope = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): HashingIntentScope { + switch (ordinalConverter.read(from)) { + case 1: return "childObjectId"; + case 2: return "regularObjectId"; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: HashingIntentScope, into: RustBuffer): void { + switch (value) { + case "childObjectId": ordinalConverter.write(1, into); break; + case "regularObjectId": ordinalConverter.write(2, into); break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: HashingIntentScope): number { + return ordinalConverter.allocationSize(0); + } + } + return new FFIConverter(); +})(); + +/** + * Defines what happened to an ObjectId during execution + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * id-operation = id-operation-none + * =/ id-operation-created + * =/ id-operation-deleted + * + * id-operation-none = %x00 + * id-operation-created = %x01 + * id-operation-deleted = %x02 + * ``` + */ +export type IdOperation = + | "none" + | "created" + | "deleted" + +export const FfiConverterTypeIdOperation = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): IdOperation { + switch (ordinalConverter.read(from)) { + case 1: return "none"; + case 2: return "created"; + case 3: return "deleted"; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: IdOperation, into: RustBuffer): void { + switch (value) { + case "none": ordinalConverter.write(1, into); break; + case "created": ordinalConverter.write(2, into); break; + case "deleted": ordinalConverter.write(3, into); break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: IdOperation): number { + return ordinalConverter.allocationSize(0); + } + } + return new FFIConverter(); +})(); + +/** + * Byte signifying the application id of an Intent + * + * This enum specifies the application ID. Two intents in two different + * applications (i.e., IOTA, Ethereum etc) should never collide, so + * that even when a signing key is reused, nobody can take a signature + * designated for app_1 and present it as a valid signature for an (any) intent + * in app_2. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * intent-app-id = u8 + * ``` + */ +export type IntentAppId = + | "iota" + | "consensus" + +export const FfiConverterTypeIntentAppId = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): IntentAppId { + switch (ordinalConverter.read(from)) { + case 1: return "iota"; + case 2: return "consensus"; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: IntentAppId, into: RustBuffer): void { + switch (value) { + case "iota": ordinalConverter.write(1, into); break; + case "consensus": ordinalConverter.write(2, into); break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: IntentAppId): number { + return ordinalConverter.allocationSize(0); + } + } + return new FFIConverter(); +})(); + +/** + * Intent errors. + */ +export type IntentError = + /** + * Invalid bytes for Intent + */ + | "bytes" + /** + * Invalid hex string for Intent + */ + | "hex" + /** + * Invalid Scope for Intent + */ + | "scope" + /** + * Invalid Version for Intent + */ + | "version" + /** + * Invalid AppId for Intent + */ + | "appId" + +export const FfiConverterTypeIntentError = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): IntentError { + switch (ordinalConverter.read(from)) { + case 1: return "bytes"; + case 2: return "hex"; + case 3: return "scope"; + case 4: return "version"; + case 5: return "appId"; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: IntentError, into: RustBuffer): void { + switch (value) { + case "bytes": ordinalConverter.write(1, into); break; + case "hex": ordinalConverter.write(2, into); break; + case "scope": ordinalConverter.write(3, into); break; + case "version": ordinalConverter.write(4, into); break; + case "appId": ordinalConverter.write(5, into); break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: IntentError): number { + return ordinalConverter.allocationSize(0); + } + } + return new FFIConverter(); +})(); + +/** + * Byte signifying the scope of an Intent + * + * This enum specifies the intent scope. Two intents for different scopes + * should never collide, so no signature provided for one intent scope can be + * used for another, even when the serialized data itself may be the same. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * intent-scope = u8 + * ``` + */ +export type IntentScope = + /** + * Used for a user signature on a transaction data. + */ + | "transactionData" + /** + * Used for an authority signature on transaction effects. + */ + | "transactionEffects" + /** + * Used for an authority signature on a checkpoint summary. + */ + | "checkpointSummary" + /** + * Used for a user signature on a personal message. + */ + | "personalMessage" + /** + * Used for an authority signature on a user signed transaction. + */ + | "senderSignedTransaction" + /** + * Used as a signature representing an authority's proof of possession of + * its authority key. + */ + | "proofOfPossession" + /** + * Deprecated. Should not be reused. Introduced for bridge purposes but was + * never included in messages. + */ + | "bridgeEventDeprecated" + /** + * Used for consensus authority signature on block's digest. + */ + | "consensusBlock" + /** + * Used for reporting peer addresses in discovery + */ + | "discoveryPeers" + /** + * Used for authority capabilities from non-committee authorities. + */ + | "authorityCapabilities" + +export const FfiConverterTypeIntentScope = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): IntentScope { + switch (ordinalConverter.read(from)) { + case 1: return "transactionData"; + case 2: return "transactionEffects"; + case 3: return "checkpointSummary"; + case 4: return "personalMessage"; + case 5: return "senderSignedTransaction"; + case 6: return "proofOfPossession"; + case 7: return "bridgeEventDeprecated"; + case 8: return "consensusBlock"; + case 9: return "discoveryPeers"; + case 10: return "authorityCapabilities"; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: IntentScope, into: RustBuffer): void { + switch (value) { + case "transactionData": ordinalConverter.write(1, into); break; + case "transactionEffects": ordinalConverter.write(2, into); break; + case "checkpointSummary": ordinalConverter.write(3, into); break; + case "personalMessage": ordinalConverter.write(4, into); break; + case "senderSignedTransaction": ordinalConverter.write(5, into); break; + case "proofOfPossession": ordinalConverter.write(6, into); break; + case "bridgeEventDeprecated": ordinalConverter.write(7, into); break; + case "consensusBlock": ordinalConverter.write(8, into); break; + case "discoveryPeers": ordinalConverter.write(9, into); break; + case "authorityCapabilities": ordinalConverter.write(10, into); break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: IntentScope): number { + return ordinalConverter.allocationSize(0); + } + } + return new FFIConverter(); +})(); + +/** + * Byte signifying the version of an Intent + * + * The version here is to distinguish between signing different versions of the + * struct or enum. Serialized output between two different versions of the same + * struct/enum might accidentally (or maliciously on purpose) match. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * intent-version = u8 + * ``` + */ +export type IntentVersion = + | "v0" + +export const FfiConverterTypeIntentVersion = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): IntentVersion { + switch (ordinalConverter.read(from)) { + case 1: return "v0"; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: IntentVersion, into: RustBuffer): void { + switch (value) { + case "v0": ordinalConverter.write(1, into); break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: IntentVersion): number { + return ordinalConverter.allocationSize(0); + } + } + return new FFIConverter(); +})(); + +export type MnemonicLength = + | "words12" + | "words24" + +export const FfiConverterTypeMnemonicLength = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): MnemonicLength { + switch (ordinalConverter.read(from)) { + case 1: return "words12"; + case 2: return "words24"; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: MnemonicLength, into: RustBuffer): void { + switch (value) { + case "words12": ordinalConverter.write(1, into); break; + case "words24": ordinalConverter.write(2, into); break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: MnemonicLength): number { + return ordinalConverter.allocationSize(0); + } + } + return new FFIConverter(); +})(); + +export type MoveAbility = + | "copy" + | "drop" + | "key" + | "store" + +export const FfiConverterTypeMoveAbility = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): MoveAbility { + switch (ordinalConverter.read(from)) { + case 1: return "copy"; + case 2: return "drop"; + case 3: return "key"; + case 4: return "store"; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: MoveAbility, into: RustBuffer): void { + switch (value) { + case "copy": ordinalConverter.write(1, into); break; + case "drop": ordinalConverter.write(2, into); break; + case "key": ordinalConverter.write(3, into); break; + case "store": ordinalConverter.write(4, into); break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: MoveAbility): number { + return ordinalConverter.allocationSize(0); + } + } + return new FFIConverter(); +})(); + +export type MoveVisibility = + | "public_" + | "private_" + | "friend" + +export const FfiConverterTypeMoveVisibility = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): MoveVisibility { + switch (ordinalConverter.read(from)) { + case 1: return "public_"; + case 2: return "private_"; + case 3: return "friend"; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: MoveVisibility, into: RustBuffer): void { + switch (value) { + case "public_": ordinalConverter.write(1, into); break; + case "private_": ordinalConverter.write(2, into); break; + case "friend": ordinalConverter.write(3, into); break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: MoveVisibility): number { + return ordinalConverter.allocationSize(0); + } + } + return new FFIConverter(); +})(); + +/** + * Two different view options for a name. + * `At` -> `test@example` | `Dot` -> `test.example.iota` + */ +export type NameFormat = + | "at" + | "dot" + +export const FfiConverterTypeNameFormat = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): NameFormat { + switch (ordinalConverter.read(from)) { + case 1: return "at"; + case 2: return "dot"; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: NameFormat, into: RustBuffer): void { + switch (value) { + case "at": ordinalConverter.write(1, into); break; + case "dot": ordinalConverter.write(2, into); break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: NameFormat): number { + return ordinalConverter.allocationSize(0); + } + } + return new FFIConverter(); +})(); + +/** + * State of an object prior to execution + * + * If an object exists (at root-level) in the store prior to this transaction, + * it should be Data, otherwise it's Missing, e.g. wrapped objects should be + * Missing. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * object-in = object-in-missing / object-in-data + * + * object-in-missing = %x00 + * object-in-data = %x01 u64 digest owner + * ``` + */ +export type ObjectIn = + | { + tag: "missing" + } + /** + * The old version, digest and owner. + */ + | { + tag: "data", + inner: Readonly<{version: /*u64*/bigint; digest: Digest; owner: Owner}> + } + +export const FfiConverterTypeObjectIn = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): ObjectIn { + switch (ordinalConverter.read(from)) { + case 1: + return { + tag: "missing" + }; + case 2: + return { + tag: "data", + inner: { + version: FfiConverterUInt64.read(from), + digest: FfiConverterTypeDigest.read(from), + owner: FfiConverterTypeOwner.read(from) + } + }; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: ObjectIn, into: RustBuffer): void { + switch (value.tag) { + case "missing": + ordinalConverter.write(1, into); + break; + case "data": + ordinalConverter.write(2, into); + FfiConverterUInt64.write(value.inner.version, into); + FfiConverterTypeDigest.write(value.inner.digest, into); + FfiConverterTypeOwner.write(value.inner.owner, into); + break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: ObjectIn): number { + switch (value.tag) { + case "missing": + return ordinalConverter.allocationSize(1); + case "data": + return ordinalConverter.allocationSize(2) + + FfiConverterUInt64.allocationSize(value.inner.version) + + FfiConverterTypeDigest.allocationSize(value.inner.digest) + + FfiConverterTypeOwner.allocationSize(value.inner.owner); + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + } + return new FFIConverter(); +})(); + +/** + * State of an object after execution + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * object-out = object-out-missing + * =/ object-out-object-write + * =/ object-out-package-write + * + * + * object-out-missing = %x00 + * object-out-object-write = %x01 digest owner + * object-out-package-write = %x02 version digest + * ``` + */ +export type ObjectOut = + /** + * Same definition as in ObjectIn. + */ + | { + tag: "missing" + } + /** + * Any written object, including all of mutated, created, unwrapped today. + */ + | { + tag: "objectWrite", + inner: Readonly<{digest: Digest; owner: Owner}> + } + /** + * Packages writes need to be tracked separately with version because + * we don't use lamport version for package publish and upgrades. + */ + | { + tag: "packageWrite", + inner: Readonly<{version: /*u64*/bigint; digest: Digest}> + } + +export const FfiConverterTypeObjectOut = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): ObjectOut { + switch (ordinalConverter.read(from)) { + case 1: + return { + tag: "missing" + }; + case 2: + return { + tag: "objectWrite", + inner: { + digest: FfiConverterTypeDigest.read(from), + owner: FfiConverterTypeOwner.read(from) + } + }; + case 3: + return { + tag: "packageWrite", + inner: { + version: FfiConverterUInt64.read(from), + digest: FfiConverterTypeDigest.read(from) + } + }; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: ObjectOut, into: RustBuffer): void { + switch (value.tag) { + case "missing": + ordinalConverter.write(1, into); + break; + case "objectWrite": + ordinalConverter.write(2, into); + FfiConverterTypeDigest.write(value.inner.digest, into); + FfiConverterTypeOwner.write(value.inner.owner, into); + break; + case "packageWrite": + ordinalConverter.write(3, into); + FfiConverterUInt64.write(value.inner.version, into); + FfiConverterTypeDigest.write(value.inner.digest, into); + break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: ObjectOut): number { + switch (value.tag) { + case "missing": + return ordinalConverter.allocationSize(1); + case "objectWrite": + return ordinalConverter.allocationSize(2) + + FfiConverterTypeDigest.allocationSize(value.inner.digest) + + FfiConverterTypeOwner.allocationSize(value.inner.owner); + case "packageWrite": + return ordinalConverter.allocationSize(3) + + FfiConverterUInt64.allocationSize(value.inner.version) + + FfiConverterTypeDigest.allocationSize(value.inner.digest); + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + } + return new FFIConverter(); +})(); + +/** + * An error with a upgrading a package + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * package-upgrade-error = unable-to-fetch-package / + * not-a-package / + * incompatible-upgrade / + * digest-does-not-match / + * unknown-upgrade-policy / + * package-id-does-not-match + * + * unable-to-fetch-package = %x00 object-id + * not-a-package = %x01 object-id + * incompatible-upgrade = %x02 + * digest-does-not-match = %x03 digest + * unknown-upgrade-policy = %x04 u8 + * package-id-does-not-match = %x05 object-id object-id + * ``` + */ +export type PackageUpgradeError = + /** + * Unable to fetch package + */ + | { + tag: "unableToFetchPackage", + inner: Readonly<{packageId: ObjectId}> + } + /** + * Object is not a package + */ + | { + tag: "notAPackage", + inner: Readonly<{objectId: ObjectId}> + } + /** + * Package upgrade is incompatible with previous version + */ + | { + tag: "incompatibleUpgrade" + } + /** + * Digest in upgrade ticket and computed digest differ + */ + | { + tag: "digestDoesNotMatch", + inner: Readonly<{digest: Digest}> + } + /** + * Upgrade policy is not valid + */ + | { + tag: "unknownUpgradePolicy", + inner: Readonly<{policy: /*u8*/number}> + } + /** + * PackageId does not matach PackageId in upgrade ticket + */ + | { + tag: "packageIdDoesNotMatch", + inner: Readonly<{packageId: ObjectId; ticketId: ObjectId}> + } + +export const FfiConverterTypePackageUpgradeError = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): PackageUpgradeError { + switch (ordinalConverter.read(from)) { + case 1: + return { + tag: "unableToFetchPackage", + inner: { + packageId: FfiConverterTypeObjectId.read(from) + } + }; + case 2: + return { + tag: "notAPackage", + inner: { + objectId: FfiConverterTypeObjectId.read(from) + } + }; + case 3: + return { + tag: "incompatibleUpgrade" + }; + case 4: + return { + tag: "digestDoesNotMatch", + inner: { + digest: FfiConverterTypeDigest.read(from) + } + }; + case 5: + return { + tag: "unknownUpgradePolicy", + inner: { + policy: FfiConverterUInt8.read(from) + } + }; + case 6: + return { + tag: "packageIdDoesNotMatch", + inner: { + packageId: FfiConverterTypeObjectId.read(from), + ticketId: FfiConverterTypeObjectId.read(from) + } + }; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: PackageUpgradeError, into: RustBuffer): void { + switch (value.tag) { + case "unableToFetchPackage": + ordinalConverter.write(1, into); + FfiConverterTypeObjectId.write(value.inner.packageId, into); + break; + case "notAPackage": + ordinalConverter.write(2, into); + FfiConverterTypeObjectId.write(value.inner.objectId, into); + break; + case "incompatibleUpgrade": + ordinalConverter.write(3, into); + break; + case "digestDoesNotMatch": + ordinalConverter.write(4, into); + FfiConverterTypeDigest.write(value.inner.digest, into); + break; + case "unknownUpgradePolicy": + ordinalConverter.write(5, into); + FfiConverterUInt8.write(value.inner.policy, into); + break; + case "packageIdDoesNotMatch": + ordinalConverter.write(6, into); + FfiConverterTypeObjectId.write(value.inner.packageId, into); + FfiConverterTypeObjectId.write(value.inner.ticketId, into); + break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: PackageUpgradeError): number { + switch (value.tag) { + case "unableToFetchPackage": + return ordinalConverter.allocationSize(1) + + FfiConverterTypeObjectId.allocationSize(value.inner.packageId); + case "notAPackage": + return ordinalConverter.allocationSize(2) + + FfiConverterTypeObjectId.allocationSize(value.inner.objectId); + case "incompatibleUpgrade": + return ordinalConverter.allocationSize(3); + case "digestDoesNotMatch": + return ordinalConverter.allocationSize(4) + + FfiConverterTypeDigest.allocationSize(value.inner.digest); + case "unknownUpgradePolicy": + return ordinalConverter.allocationSize(5) + + FfiConverterUInt8.allocationSize(value.inner.policy); + case "packageIdDoesNotMatch": + return ordinalConverter.allocationSize(6) + + FfiConverterTypeObjectId.allocationSize(value.inner.packageId) + + FfiConverterTypeObjectId.allocationSize(value.inner.ticketId); + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + } + return new FFIConverter(); +})(); + +export type SdkFfiError = + | "generic" + +export const FfiConverterTypeSdkFfiError = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): SdkFfiError { + switch (ordinalConverter.read(from)) { + case 1: return "generic"; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: SdkFfiError, into: RustBuffer): void { + switch (value) { + case "generic": ordinalConverter.write(1, into); break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: SdkFfiError): number { + return ordinalConverter.allocationSize(0); + } + } + return new FFIConverter(); +})(); + +/** + * Flag use to disambiguate the signature schemes supported by IOTA. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * signature-scheme = ed25519-flag / secp256k1-flag / secp256r1-flag / + * multisig-flag / bls-flag / zklogin-auth-flag / passkey-auth-flag / + * move-auth-flag + * ed25519-flag = %x00 + * secp256k1-flag = %x01 + * secp256r1-flag = %x02 + * multisig-flag = %x03 + * bls-flag = %x04 + * zklogin-auth-flag = %x05 + * passkey-auth-flag = %x06 + * move-auth-flag = %x07 + * ``` + */ +export type SignatureScheme = + | "ed25519" + | "secp256k1" + | "secp256r1" + | "multisig" + | "bls12381" + | "zkLoginAuthenticator" + | "passkeyAuthenticator" + | "moveAuthenticator" + +export const FfiConverterTypeSignatureScheme = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): SignatureScheme { + switch (ordinalConverter.read(from)) { + case 1: return "ed25519"; + case 2: return "secp256k1"; + case 3: return "secp256r1"; + case 4: return "multisig"; + case 5: return "bls12381"; + case 6: return "zkLoginAuthenticator"; + case 7: return "passkeyAuthenticator"; + case 8: return "moveAuthenticator"; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: SignatureScheme, into: RustBuffer): void { + switch (value) { + case "ed25519": ordinalConverter.write(1, into); break; + case "secp256k1": ordinalConverter.write(2, into); break; + case "secp256r1": ordinalConverter.write(3, into); break; + case "multisig": ordinalConverter.write(4, into); break; + case "bls12381": ordinalConverter.write(5, into); break; + case "zkLoginAuthenticator": ordinalConverter.write(6, into); break; + case "passkeyAuthenticator": ordinalConverter.write(7, into); break; + case "moveAuthenticator": ordinalConverter.write(8, into); break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: SignatureScheme): number { + return ordinalConverter.allocationSize(0); + } + } + return new FFIConverter(); +})(); + +/** + * A transaction argument used in programmable transactions. + */ +export type TransactionArgument = + /** + * Reference to the gas coin. + */ + | { + tag: "gasCoin" + } + /** + * An input to the programmable transaction block. + */ + | { + tag: "input", + inner: Readonly<{index: /*u32*/number}> + } + /** + * The result of another transaction command. + */ + | { + tag: "result", + inner: Readonly<{cmd: /*u32*/number; index: /*u32*/number | undefined}> + } + +export const FfiConverterTypeTransactionArgument = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TransactionArgument { + switch (ordinalConverter.read(from)) { + case 1: + return { + tag: "gasCoin" + }; + case 2: + return { + tag: "input", + inner: { + index: FfiConverterUInt32.read(from) + } + }; + case 3: + return { + tag: "result", + inner: { + cmd: FfiConverterUInt32.read(from), + index: (new FfiConverterOptional(FfiConverterUInt32)).read(from) + } + }; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: TransactionArgument, into: RustBuffer): void { + switch (value.tag) { + case "gasCoin": + ordinalConverter.write(1, into); + break; + case "input": + ordinalConverter.write(2, into); + FfiConverterUInt32.write(value.inner.index, into); + break; + case "result": + ordinalConverter.write(3, into); + FfiConverterUInt32.write(value.inner.cmd, into); + (new FfiConverterOptional(FfiConverterUInt32)).write(value.inner.index, into); + break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: TransactionArgument): number { + switch (value.tag) { + case "gasCoin": + return ordinalConverter.allocationSize(1); + case "input": + return ordinalConverter.allocationSize(2) + + FfiConverterUInt32.allocationSize(value.inner.index); + case "result": + return ordinalConverter.allocationSize(3) + + FfiConverterUInt32.allocationSize(value.inner.cmd) + + (new FfiConverterOptional(FfiConverterUInt32)).allocationSize(value.inner.index); + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + } + return new FFIConverter(); +})(); + +export type TransactionBlockKindInput = + | "systemTx" + | "programmableTx" + | "genesis" + | "consensusCommitPrologueV1" + | "authenticatorStateUpdateV1" + | "randomnessStateUpdate" + | "endOfEpochTx" + +export const FfiConverterTypeTransactionBlockKindInput = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TransactionBlockKindInput { + switch (ordinalConverter.read(from)) { + case 1: return "systemTx"; + case 2: return "programmableTx"; + case 3: return "genesis"; + case 4: return "consensusCommitPrologueV1"; + case 5: return "authenticatorStateUpdateV1"; + case 6: return "randomnessStateUpdate"; + case 7: return "endOfEpochTx"; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: TransactionBlockKindInput, into: RustBuffer): void { + switch (value) { + case "systemTx": ordinalConverter.write(1, into); break; + case "programmableTx": ordinalConverter.write(2, into); break; + case "genesis": ordinalConverter.write(3, into); break; + case "consensusCommitPrologueV1": ordinalConverter.write(4, into); break; + case "authenticatorStateUpdateV1": ordinalConverter.write(5, into); break; + case "randomnessStateUpdate": ordinalConverter.write(6, into); break; + case "endOfEpochTx": ordinalConverter.write(7, into); break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: TransactionBlockKindInput): number { + return ordinalConverter.allocationSize(0); + } + } + return new FFIConverter(); +})(); + +/** + * A TTL for a transaction + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * transaction-expiration = %x00 ; none + * =/ %x01 u64 ; epoch + * ``` + */ +export type TransactionExpiration = + /** + * The transaction has no expiration + */ + | { + tag: "none" + } + /** + * Validators won't sign a transaction unless the expiration Epoch + * is greater than or equal to the current epoch + */ + | { + tag: "epoch", + inner: Readonly<[/*u64*/bigint]> + } + +export const FfiConverterTypeTransactionExpiration = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TransactionExpiration { + switch (ordinalConverter.read(from)) { + case 1: + return { + tag: "none" + }; + case 2: + return { + tag: "epoch", + inner: [ + FfiConverterUInt64.read(from) + ] + }; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: TransactionExpiration, into: RustBuffer): void { + switch (value.tag) { + case "none": + ordinalConverter.write(1, into); + break; + case "epoch": + ordinalConverter.write(2, into); + FfiConverterUInt64.write(value.inner[0], into); + break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: TransactionExpiration): number { + switch (value.tag) { + case "none": + return ordinalConverter.allocationSize(1); + case "epoch": + return ordinalConverter.allocationSize(2) + + FfiConverterUInt64.allocationSize(value.inner[0]); + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + } + return new FFIConverter(); +})(); + +/** + * An error with a type argument + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * type-argument-error = type-not-found / constraint-not-satisfied + * type-not-found = %x00 + * constraint-not-satisfied = %x01 + * ``` + */ +export type TypeArgumentError = + /** + * A type was not found in the module specified + */ + | "typeNotFound" + /** + * A type provided did not match the specified constraint + */ + | "constraintNotSatisfied" + +export const FfiConverterTypeTypeArgumentError = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): TypeArgumentError { + switch (ordinalConverter.read(from)) { + case 1: return "typeNotFound"; + case 2: return "constraintNotSatisfied"; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: TypeArgumentError, into: RustBuffer): void { + switch (value) { + case "typeNotFound": ordinalConverter.write(1, into); break; + case "constraintNotSatisfied": ordinalConverter.write(2, into); break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: TypeArgumentError): number { + return ordinalConverter.allocationSize(0); + } + } + return new FFIConverter(); +})(); + +/** + * Type of unchanged shared object + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * unchanged-shared-object-kind = read-only-root + * =/ mutate-deleted + * =/ read-deleted + * =/ cancelled + * =/ per-epoch-config + * + * read-only-root = %x00 u64 digest + * mutate-deleted = %x01 u64 + * read-deleted = %x02 u64 + * cancelled = %x03 u64 + * per-epoch-config = %x04 + * ``` + */ +export type UnchangedSharedKind = + /** + * Read-only shared objects from the input. We don't really need + * ObjectDigest for protocol correctness, but it will make it easier to + * verify untrusted read. + */ + | { + tag: "readOnlyRoot", + inner: Readonly<{version: /*u64*/bigint; digest: Digest}> + } + /** + * Deleted shared objects that appear mutably/owned in the input. + */ + | { + tag: "mutateDeleted", + inner: Readonly<{version: /*u64*/bigint}> + } + /** + * Deleted shared objects that appear as read-only in the input. + */ + | { + tag: "readDeleted", + inner: Readonly<{version: /*u64*/bigint}> + } + /** + * Shared objects in cancelled transaction. The sequence number embed + * cancellation reason. + */ + | { + tag: "cancelled", + inner: Readonly<{version: /*u64*/bigint}> + } + /** + * Read of a per-epoch config object that should remain the same during an + * epoch. + */ + | { + tag: "perEpochConfig" + } + +export const FfiConverterTypeUnchangedSharedKind = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): UnchangedSharedKind { + switch (ordinalConverter.read(from)) { + case 1: + return { + tag: "readOnlyRoot", + inner: { + version: FfiConverterUInt64.read(from), + digest: FfiConverterTypeDigest.read(from) + } + }; + case 2: + return { + tag: "mutateDeleted", + inner: { + version: FfiConverterUInt64.read(from) + } + }; + case 3: + return { + tag: "readDeleted", + inner: { + version: FfiConverterUInt64.read(from) + } + }; + case 4: + return { + tag: "cancelled", + inner: { + version: FfiConverterUInt64.read(from) + } + }; + case 5: + return { + tag: "perEpochConfig" + }; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: UnchangedSharedKind, into: RustBuffer): void { + switch (value.tag) { + case "readOnlyRoot": + ordinalConverter.write(1, into); + FfiConverterUInt64.write(value.inner.version, into); + FfiConverterTypeDigest.write(value.inner.digest, into); + break; + case "mutateDeleted": + ordinalConverter.write(2, into); + FfiConverterUInt64.write(value.inner.version, into); + break; + case "readDeleted": + ordinalConverter.write(3, into); + FfiConverterUInt64.write(value.inner.version, into); + break; + case "cancelled": + ordinalConverter.write(4, into); + FfiConverterUInt64.write(value.inner.version, into); + break; + case "perEpochConfig": + ordinalConverter.write(5, into); + break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: UnchangedSharedKind): number { + switch (value.tag) { + case "readOnlyRoot": + return ordinalConverter.allocationSize(1) + + FfiConverterUInt64.allocationSize(value.inner.version) + + FfiConverterTypeDigest.allocationSize(value.inner.digest); + case "mutateDeleted": + return ordinalConverter.allocationSize(2) + + FfiConverterUInt64.allocationSize(value.inner.version); + case "readDeleted": + return ordinalConverter.allocationSize(3) + + FfiConverterUInt64.allocationSize(value.inner.version); + case "cancelled": + return ordinalConverter.allocationSize(4) + + FfiConverterUInt64.allocationSize(value.inner.version); + case "perEpochConfig": + return ordinalConverter.allocationSize(5); + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + } + return new FFIConverter(); +})(); + +/** + * Determines what to wait for after executing a transaction. + * + * Users should almost always use WaitForTx::Finalized (the default). + * The GraphQL client interacts with the indexer, not the fullnode directly. + * Using WaitForTx::IndexedOnNode only guarantees the transaction is + * indexed on the fullnode (meaning you can submit transactions that reference + * objects created by this transaction), but subsequent queries using the + * transaction ID can still fail until the transaction is indexed on the + * indexer. + */ +export type WaitForTx = + /** + * Indicates that the transaction effects will be usable in subsequent + * transactions (you can reference objects created by this transaction), + * and that the transaction itself is indexed on the fullnode. + * + * **Warning:** This does not guarantee the transaction is indexed on the + * indexer. Since the GraphQL client queries the indexer, subsequent + * queries with this transaction ID may still fail. Prefer + * WaitForTx::Finalized unless you have a specific reason to use this. + */ + | "indexedOnNode" + /** + * Indicates that the transaction has been included in a checkpoint, and + * all queries may include it. + */ + | "finalized" + +export const FfiConverterTypeWaitForTx = (() => { + const ordinalConverter = FfiConverterInt32; + class FFIConverter extends AbstractFfiConverterByteArray { + read(from: RustBuffer): WaitForTx { + switch (ordinalConverter.read(from)) { + case 1: return "indexedOnNode"; + case 2: return "finalized"; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + write(value: WaitForTx, into: RustBuffer): void { + switch (value) { + case "indexedOnNode": ordinalConverter.write(1, into); break; + case "finalized": ordinalConverter.write(2, into); break; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + allocationSize(value: WaitForTx): number { + return ordinalConverter.allocationSize(0); + } + } + return new FFIConverter(); +})(); + + +// ========== +// Object definitions: +// ========== + + +export type AddressInterface = { + toBytes(): ArrayBuffer; + +/** + * Returns the string representation of this address using the + * canonical display, with or without a `0x` prefix. + */toCanonicalString(withPrefix: boolean): string; + toHex(): string; + +/** + * Returns the shortest possible string representation of the address (i.e. + * with leading zeroes trimmed). + */toShortString(withPrefix: boolean): string; + +}; + + +/** + * Unique identifier for an Account on the IOTA blockchain. + * + * An `Address` is a 32-byte pseudonymous identifier used to uniquely identify + * an account and asset-ownership on the IOTA blockchain. Often, human-readable + * addresses are encoded in hexadecimal with a `0x` prefix. For example, this + * is a valid IOTA address: + * `0x02a212de6a9dfa3a69e22387acfbafbb1a9e591bd9d636e7895dcfc8de05f331`. + * + * # Deriving an Address + * + * Addresses are cryptographically derived from a number of user account + * authenticators, the simplest of which is an + * `Ed25519PublicKey`. + * + * Deriving an address consists of the Blake2b256 hash of the sequence of bytes + * of its corresponding authenticator, prefixed with a domain-separator (except + * ed25519, for compatibility reasons). For each other authenticator, this + * domain-separator is the single byte-value of its + * `SignatureScheme` flag. E.g. `hash(signature schema flag || authenticator + * bytes)`. + * + * Each authenticator has a method for deriving its `Address` as well as + * documentation for the specifics of how the derivation is done. See + * `Ed25519PublicKey::derive_address` for an example. + * + * ## Relationship to ObjectIds + * + * `ObjectId`s and `Address`es share the same 32-byte addressable space but + * are derived leveraging different domain-separator values to ensure that, + * cryptographically, there won't be any overlap, e.g. there can't be a + * valid `Object` who's `ObjectId` is equal to that of the `Address` of a user + * account. + * + * # BCS + * + * An `Address`'s BCS serialized form is defined by the following: + * + * ```text + * address = 32OCTET + * ``` + */ +export class Address extends UniffiAbstractObject implements AddressInterface { + readonly [uniffiTypeNameSymbol] = 'Address'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static framework(): Address { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_address_framework([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeAddress.lift(returnValue); + } + + static fromBytes(bytes: ArrayBuffer): Address { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_address_from_bytes([ + bytesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeAddress.lift(returnValue); + } +/** + * Parses an Address from a hex string, with or without a `0x` prefix. + * The string can be of variable length; if it's shorter than 64 hex + * characters, it will be left-padded with `0`s. + */ + + static fromHex(hex: string): Address { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let hexArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(hex)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_address_from_hex([ + hexArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeAddress.lift(returnValue); + } + + static generate(): Address { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_address_generate([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeAddress.lift(returnValue); + } + + static std(): Address { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_address_std([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeAddress.lift(returnValue); + } + + static system(): Address { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_address_system([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeAddress.lift(returnValue); + } + + static zero(): Address { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_address_zero([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeAddress.lift(returnValue); + }// Methods: + + toBytes(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_address_to_bytes([ + uniffiTypeAddressObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Returns the string representation of this address using the + * canonical display, with or without a `0x` prefix. + */toCanonicalString(withPrefix: boolean): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let withPrefixArg = FfiConverterBool.lower(withPrefix); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_address_to_canonical_string([ + uniffiTypeAddressObjectFactory.clonePointer(this), withPrefixArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + toHex(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_address_to_hex([ + uniffiTypeAddressObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Returns the shortest possible string representation of the address (i.e. + * with leading zeroes trimmed). + */toShortString(withPrefix: boolean): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let withPrefixArg = FfiConverterBool.lower(withPrefix); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_address_to_short_string([ + uniffiTypeAddressObjectFactory.clonePointer(this), withPrefixArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + toString(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_address_uniffi_trait_display([ + uniffiTypeAddressObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeAddressObjectFactory.pointer(this); + uniffiTypeAddressObjectFactory.freePointer(pointer); + uniffiTypeAddressObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Address { + return uniffiTypeAddressObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeAddressObjectFactory: UniffiObjectFactory
= + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeAddressObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Address { + const instance = Object.create(Address.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Address'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Address): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Address): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_address([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_address([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Address { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Address' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeAddress = new FfiConverterObject( + uniffiTypeAddressObjectFactory +); + + +export type ArgumentInterface = { + +/** + * Get the nested result for this result at the given index. Returns None + * if this is not a Result. + */getNestedResult(ix: /*u16*/number): Argument | undefined; + +}; + + +/** + * An argument to a programmable transaction command + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * argument = argument-gas + * =/ argument-input + * =/ argument-result + * =/ argument-nested-result + * + * argument-gas = %x00 + * argument-input = %x01 u16 + * argument-result = %x02 u16 + * argument-nested-result = %x03 u16 u16 + * ``` + */ +export class Argument extends UniffiAbstractObject implements ArgumentInterface { + readonly [uniffiTypeNameSymbol] = 'Argument'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + +/** + * The gas coin. The gas coin can only be used by-ref, except for with + * `TransferObjects`, which can use it by-value. + */ + + static newGas(): Argument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_argument_new_gas([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeArgument.lift(returnValue); + } +/** + * One of the input objects or primitive values (from + * `ProgrammableTransaction` inputs) + */ + + static newInput(input: /*u16*/number): Argument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let inputArg = FfiConverterUInt16.lower(input); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_argument_new_input([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeArgument.lift(returnValue); + } +/** + * Like a `Result` but it accesses a nested result. Currently, the only + * usage of this is to access a value from a Move call with multiple + * return values. + */ + + static newNestedResult(commandIndex: /*u16*/number, subresultIndex: /*u16*/number): Argument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let commandIndexArg = FfiConverterUInt16.lower(commandIndex); + let subresultIndexArg = FfiConverterUInt16.lower(subresultIndex); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_argument_new_nested_result([ + commandIndexArg, subresultIndexArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeArgument.lift(returnValue); + } +/** + * The result of another command (from `ProgrammableTransaction` commands) + */ + + static newResult(result: /*u16*/number): Argument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let resultArg = FfiConverterUInt16.lower(result); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_argument_new_result([ + resultArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeArgument.lift(returnValue); + }// Methods: + + +/** + * Get the nested result for this result at the given index. Returns None + * if this is not a Result. + */getNestedResult(ix: /*u16*/number): Argument | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let ixArg = FfiConverterUInt16.lower(ix); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_argument_get_nested_result([ + uniffiTypeArgumentObjectFactory.clonePointer(this), ixArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeArgument).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeArgumentObjectFactory.pointer(this); + uniffiTypeArgumentObjectFactory.freePointer(pointer); + uniffiTypeArgumentObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Argument { + return uniffiTypeArgumentObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeArgumentObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeArgumentObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Argument { + const instance = Object.create(Argument.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Argument'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Argument): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Argument): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_argument([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_argument([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Argument { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Argument' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeArgument = new FfiConverterObject( + uniffiTypeArgumentObjectFactory +); + + +export type Bls12381PrivateKeyInterface = { + publicKey(): Bls12381PublicKey; + scheme(): SignatureScheme; + signCheckpointSummary(summary: CheckpointSummary): ValidatorSignature; + trySign(message: ArrayBuffer): Bls12381Signature; + verifyingKey(): Bls12381VerifyingKey; + +}; + + +export class Bls12381PrivateKey extends UniffiAbstractObject implements Bls12381PrivateKeyInterface { + readonly [uniffiTypeNameSymbol] = 'Bls12381PrivateKey'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static generate(): Bls12381PrivateKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_bls12381privatekey_generate([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeBls12381PrivateKey.lift(returnValue); + } + constructor(bytes: ArrayBuffer) { + super(); + + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + const pointer =uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_bls12381privatekey_new([ + bytesArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeBls12381PrivateKeyObjectFactory.bless(pointer); + }// Methods: + + publicKey(): Bls12381PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_bls12381privatekey_public_key([ + uniffiTypeBls12381PrivateKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeBls12381PublicKey.lift(returnValue); + } + + scheme(): SignatureScheme { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_bls12381privatekey_scheme([ + uniffiTypeBls12381PrivateKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSignatureScheme.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + signCheckpointSummary(summary: CheckpointSummary): ValidatorSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let summaryArg = FfiConverterTypeCheckpointSummary.lower(summary); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_bls12381privatekey_sign_checkpoint_summary([ + uniffiTypeBls12381PrivateKeyObjectFactory.clonePointer(this), summaryArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeValidatorSignature.lift(returnValue); + } + + trySign(message: ArrayBuffer): Bls12381Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_bls12381privatekey_try_sign([ + uniffiTypeBls12381PrivateKeyObjectFactory.clonePointer(this), messageArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeBls12381Signature.lift(returnValue); + } + + verifyingKey(): Bls12381VerifyingKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_bls12381privatekey_verifying_key([ + uniffiTypeBls12381PrivateKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeBls12381VerifyingKey.lift(returnValue); + } + + + // UniffiTrait implementations: + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeBls12381PrivateKeyObjectFactory.pointer(this); + uniffiTypeBls12381PrivateKeyObjectFactory.freePointer(pointer); + uniffiTypeBls12381PrivateKeyObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Bls12381PrivateKey { + return uniffiTypeBls12381PrivateKeyObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeBls12381PrivateKeyObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeBls12381PrivateKeyObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Bls12381PrivateKey { + const instance = Object.create(Bls12381PrivateKey.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Bls12381PrivateKey'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Bls12381PrivateKey): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Bls12381PrivateKey): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_bls12381privatekey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_bls12381privatekey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Bls12381PrivateKey { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Bls12381PrivateKey' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeBls12381PrivateKey = new FfiConverterObject( + uniffiTypeBls12381PrivateKeyObjectFactory +); + + +export type Bls12381PublicKeyInterface = { + toBytes(): ArrayBuffer; + +}; + + +/** + * A bls12381 min-sig public key. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * bls-public-key = %x60 96OCTET + * ``` + * + * Due to historical reasons, even though a min-sig `Bls12381PublicKey` has a + * fixed-length of 96, IOTA's binary representation of a min-sig + * `Bls12381PublicKey` is prefixed with its length meaning its serialized + * binary form (in bcs) is 97 bytes long vs a more compact 96 bytes. + */ +export class Bls12381PublicKey extends UniffiAbstractObject implements Bls12381PublicKeyInterface { + readonly [uniffiTypeNameSymbol] = 'Bls12381PublicKey'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static fromBytes(bytes: ArrayBuffer): Bls12381PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_bls12381publickey_from_bytes([ + bytesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeBls12381PublicKey.lift(returnValue); + } + + static fromStr(s: string): Bls12381PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let sArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(s)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_bls12381publickey_from_str([ + sArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeBls12381PublicKey.lift(returnValue); + } + + static generate(): Bls12381PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_bls12381publickey_generate([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeBls12381PublicKey.lift(returnValue); + }// Methods: + + toBytes(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_bls12381publickey_to_bytes([ + uniffiTypeBls12381PublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeBls12381PublicKeyObjectFactory.pointer(this); + uniffiTypeBls12381PublicKeyObjectFactory.freePointer(pointer); + uniffiTypeBls12381PublicKeyObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Bls12381PublicKey { + return uniffiTypeBls12381PublicKeyObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeBls12381PublicKeyObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeBls12381PublicKeyObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Bls12381PublicKey { + const instance = Object.create(Bls12381PublicKey.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Bls12381PublicKey'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Bls12381PublicKey): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Bls12381PublicKey): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_bls12381publickey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_bls12381publickey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Bls12381PublicKey { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Bls12381PublicKey' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeBls12381PublicKey = new FfiConverterObject( + uniffiTypeBls12381PublicKeyObjectFactory +); + + +export type Bls12381SignatureInterface = { + toBytes(): ArrayBuffer; + +}; + + +/** + * A bls12381 min-sig public key. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * bls-public-key = %x60 96OCTET + * ``` + * + * Due to historical reasons, even though a min-sig `Bls12381PublicKey` has a + * fixed-length of 96, IOTA's binary representation of a min-sig + * `Bls12381PublicKey` is prefixed with its length meaning its serialized + * binary form (in bcs) is 97 bytes long vs a more compact 96 bytes. + */ +export class Bls12381Signature extends UniffiAbstractObject implements Bls12381SignatureInterface { + readonly [uniffiTypeNameSymbol] = 'Bls12381Signature'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static fromBytes(bytes: ArrayBuffer): Bls12381Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_bls12381signature_from_bytes([ + bytesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeBls12381Signature.lift(returnValue); + } + + static fromStr(s: string): Bls12381Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let sArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(s)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_bls12381signature_from_str([ + sArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeBls12381Signature.lift(returnValue); + } + + static generate(): Bls12381Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_bls12381signature_generate([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeBls12381Signature.lift(returnValue); + }// Methods: + + toBytes(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_bls12381signature_to_bytes([ + uniffiTypeBls12381SignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeBls12381SignatureObjectFactory.pointer(this); + uniffiTypeBls12381SignatureObjectFactory.freePointer(pointer); + uniffiTypeBls12381SignatureObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Bls12381Signature { + return uniffiTypeBls12381SignatureObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeBls12381SignatureObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeBls12381SignatureObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Bls12381Signature { + const instance = Object.create(Bls12381Signature.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Bls12381Signature'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Bls12381Signature): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Bls12381Signature): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_bls12381signature([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_bls12381signature([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Bls12381Signature { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Bls12381Signature' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeBls12381Signature = new FfiConverterObject( + uniffiTypeBls12381SignatureObjectFactory +); + + +export type Bls12381VerifyingKeyInterface = { + publicKey(): Bls12381PublicKey; + verify(message: ArrayBuffer, signature: Bls12381Signature): void; + +}; + + +export class Bls12381VerifyingKey extends UniffiAbstractObject implements Bls12381VerifyingKeyInterface { + readonly [uniffiTypeNameSymbol] = 'Bls12381VerifyingKey'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(publicKey: Bls12381PublicKey) { + super(); + + let publicKeyArg = FfiConverterTypeBls12381PublicKey.lower(publicKey); + const pointer =uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_bls12381verifyingkey_new([ + publicKeyArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeBls12381VerifyingKeyObjectFactory.bless(pointer); + }// Methods: + + publicKey(): Bls12381PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_bls12381verifyingkey_public_key([ + uniffiTypeBls12381VerifyingKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeBls12381PublicKey.lift(returnValue); + } + + verify(message: ArrayBuffer, signature: Bls12381Signature): void { + /* Regular function call: */ + uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + let signatureArg = FfiConverterTypeBls12381Signature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_bls12381verifyingkey_verify([ + uniffiTypeBls12381VerifyingKeyObjectFactory.clonePointer(this), messageArg, signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + + // UniffiTrait implementations: + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeBls12381VerifyingKeyObjectFactory.pointer(this); + uniffiTypeBls12381VerifyingKeyObjectFactory.freePointer(pointer); + uniffiTypeBls12381VerifyingKeyObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Bls12381VerifyingKey { + return uniffiTypeBls12381VerifyingKeyObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeBls12381VerifyingKeyObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeBls12381VerifyingKeyObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Bls12381VerifyingKey { + const instance = Object.create(Bls12381VerifyingKey.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Bls12381VerifyingKey'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Bls12381VerifyingKey): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Bls12381VerifyingKey): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_bls12381verifyingkey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_bls12381verifyingkey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Bls12381VerifyingKey { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Bls12381VerifyingKey' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeBls12381VerifyingKey = new FfiConverterObject( + uniffiTypeBls12381VerifyingKeyObjectFactory +); + + +export type Bn254FieldElementInterface = { + padded(): ArrayBuffer; + unpadded(): ArrayBuffer; + +}; + + +/** + * A point on the BN254 elliptic curve. + * + * This is a 32-byte, or 256-bit, value that is generally represented as + * radix10 when a human-readable display format is needed, and is represented + * as a 32-byte big-endian value while in memory. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * bn254-field-element = *DIGIT ; which is then interpreted as a radix10 encoded 32-byte value + * ``` + */ +export class Bn254FieldElement extends UniffiAbstractObject implements Bn254FieldElementInterface { + readonly [uniffiTypeNameSymbol] = 'Bn254FieldElement'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static fromBytes(bytes: ArrayBuffer): Bn254FieldElement { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_bn254fieldelement_from_bytes([ + bytesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeBn254FieldElement.lift(returnValue); + } + + static fromStr(s: string): Bn254FieldElement { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let sArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(s)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_bn254fieldelement_from_str([ + sArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeBn254FieldElement.lift(returnValue); + } + + static fromStrRadix10(s: string): Bn254FieldElement { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let sArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(s)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_bn254fieldelement_from_str_radix_10([ + sArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeBn254FieldElement.lift(returnValue); + }// Methods: + + padded(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_bn254fieldelement_padded([ + uniffiTypeBn254FieldElementObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + unpadded(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_bn254fieldelement_unpadded([ + uniffiTypeBn254FieldElementObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeBn254FieldElementObjectFactory.pointer(this); + uniffiTypeBn254FieldElementObjectFactory.freePointer(pointer); + uniffiTypeBn254FieldElementObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Bn254FieldElement { + return uniffiTypeBn254FieldElementObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeBn254FieldElementObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeBn254FieldElementObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Bn254FieldElement { + const instance = Object.create(Bn254FieldElement.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Bn254FieldElement'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Bn254FieldElement): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Bn254FieldElement): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_bn254fieldelement([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_bn254fieldelement([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Bn254FieldElement { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Bn254FieldElement' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeBn254FieldElement = new FfiConverterObject( + uniffiTypeBn254FieldElementObjectFactory +); + + +export type CancelledTransactionInterface = { + digest(): Digest; + versionAssignments(): Array; + +}; + + +/** + * A transaction that was cancelled + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * cancelled-transaction = digest (vector version-assignment) + * ``` + */ +export class CancelledTransaction extends UniffiAbstractObject implements CancelledTransactionInterface { + readonly [uniffiTypeNameSymbol] = 'CancelledTransaction'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(digest: Digest, versionAssignments: Array) { + super(); + + let digestArg = FfiConverterTypeDigest.lower(digest); + let versionAssignmentsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeVersionAssignment)).lower(versionAssignments)).toStruct(); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_cancelledtransaction_new([ + digestArg, versionAssignmentsArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeCancelledTransactionObjectFactory.bless(pointer); + }// Methods: + + digest(): Digest { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_cancelledtransaction_digest([ + uniffiTypeCancelledTransactionObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeDigest.lift(returnValue); + } + + versionAssignments(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_cancelledtransaction_version_assignments([ + uniffiTypeCancelledTransactionObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeVersionAssignment)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeCancelledTransactionObjectFactory.pointer(this); + uniffiTypeCancelledTransactionObjectFactory.freePointer(pointer); + uniffiTypeCancelledTransactionObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is CancelledTransaction { + return uniffiTypeCancelledTransactionObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeCancelledTransactionObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeCancelledTransactionObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): CancelledTransaction { + const instance = Object.create(CancelledTransaction.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'CancelledTransaction'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: CancelledTransaction): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: CancelledTransaction): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_cancelledtransaction([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_cancelledtransaction([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is CancelledTransaction { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'CancelledTransaction' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeCancelledTransaction = new FfiConverterObject( + uniffiTypeCancelledTransactionObjectFactory +); + + +export type ChangeEpochInterface = { + +/** + * The total amount of gas charged for computation during the epoch. + */computationCharge(): /*u64*/bigint; + +/** + * The next (to become) epoch ID. + */epoch(): /*u64*/bigint; + +/** + * Unix timestamp when epoch started + */epochStartTimestampMs(): /*u64*/bigint; + +/** + * The non-refundable storage fee. + */nonRefundableStorageFee(): /*u64*/bigint; + +/** + * The protocol version in effect in the new epoch. + */protocolVersion(): /*u64*/bigint; + +/** + * The total amount of gas charged for storage during the epoch. + */storageCharge(): /*u64*/bigint; + +/** + * The amount of storage rebate refunded to the txn senders. + */storageRebate(): /*u64*/bigint; + +/** + * System packages (specifically framework and move stdlib) that are + * written before the new epoch starts. + */systemPackages(): Array; + +}; + + +/** + * System transaction used to change the epoch + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * change-epoch = u64 ; next epoch + * u64 ; protocol version + * u64 ; storage charge + * u64 ; computation charge + * u64 ; storage rebate + * u64 ; non-refundable storage fee + * u64 ; epoch start timestamp + * (vector system-package) + * ``` + */ +export class ChangeEpoch extends UniffiAbstractObject implements ChangeEpochInterface { + readonly [uniffiTypeNameSymbol] = 'ChangeEpoch'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(epoch: /*u64*/bigint, protocolVersion: /*u64*/bigint, storageCharge: /*u64*/bigint, computationCharge: /*u64*/bigint, storageRebate: /*u64*/bigint, nonRefundableStorageFee: /*u64*/bigint, epochStartTimestampMs: /*u64*/bigint, systemPackages: Array) { + super(); + + let epochArg = FfiConverterUInt64.lower(epoch); + let protocolVersionArg = FfiConverterUInt64.lower(protocolVersion); + let storageChargeArg = FfiConverterUInt64.lower(storageCharge); + let computationChargeArg = FfiConverterUInt64.lower(computationCharge); + let storageRebateArg = FfiConverterUInt64.lower(storageRebate); + let nonRefundableStorageFeeArg = FfiConverterUInt64.lower(nonRefundableStorageFee); + let epochStartTimestampMsArg = FfiConverterUInt64.lower(epochStartTimestampMs); + let systemPackagesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeSystemPackage)).lower(systemPackages)).toStruct(); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_changeepoch_new([ + epochArg, protocolVersionArg, storageChargeArg, computationChargeArg, storageRebateArg, nonRefundableStorageFeeArg, epochStartTimestampMsArg, systemPackagesArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeChangeEpochObjectFactory.bless(pointer); + }// Methods: + + +/** + * The total amount of gas charged for computation during the epoch. + */computationCharge(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepoch_computation_charge([ + uniffiTypeChangeEpochObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * The next (to become) epoch ID. + */epoch(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepoch_epoch([ + uniffiTypeChangeEpochObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * Unix timestamp when epoch started + */epochStartTimestampMs(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepoch_epoch_start_timestamp_ms([ + uniffiTypeChangeEpochObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * The non-refundable storage fee. + */nonRefundableStorageFee(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepoch_non_refundable_storage_fee([ + uniffiTypeChangeEpochObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * The protocol version in effect in the new epoch. + */protocolVersion(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepoch_protocol_version([ + uniffiTypeChangeEpochObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * The total amount of gas charged for storage during the epoch. + */storageCharge(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepoch_storage_charge([ + uniffiTypeChangeEpochObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * The amount of storage rebate refunded to the txn senders. + */storageRebate(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepoch_storage_rebate([ + uniffiTypeChangeEpochObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * System packages (specifically framework and move stdlib) that are + * written before the new epoch starts. + */systemPackages(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepoch_system_packages([ + uniffiTypeChangeEpochObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeSystemPackage)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeChangeEpochObjectFactory.pointer(this); + uniffiTypeChangeEpochObjectFactory.freePointer(pointer); + uniffiTypeChangeEpochObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is ChangeEpoch { + return uniffiTypeChangeEpochObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeChangeEpochObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeChangeEpochObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): ChangeEpoch { + const instance = Object.create(ChangeEpoch.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'ChangeEpoch'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: ChangeEpoch): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: ChangeEpoch): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_changeepoch([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_changeepoch([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is ChangeEpoch { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'ChangeEpoch' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeChangeEpoch = new FfiConverterObject( + uniffiTypeChangeEpochObjectFactory +); + + +export type ChangeEpochV2Interface = { + +/** + * The total amount of gas charged for computation during the epoch. + */computationCharge(): /*u64*/bigint; + +/** + * The total amount of gas burned for computation during the epoch. + */computationChargeBurned(): /*u64*/bigint; + +/** + * The next (to become) epoch ID. + */epoch(): /*u64*/bigint; + +/** + * Unix timestamp when epoch started + */epochStartTimestampMs(): /*u64*/bigint; + +/** + * The non-refundable storage fee. + */nonRefundableStorageFee(): /*u64*/bigint; + +/** + * The protocol version in effect in the new epoch. + */protocolVersion(): /*u64*/bigint; + +/** + * The total amount of gas charged for storage during the epoch. + */storageCharge(): /*u64*/bigint; + +/** + * The amount of storage rebate refunded to the txn senders. + */storageRebate(): /*u64*/bigint; + +/** + * System packages (specifically framework and move stdlib) that are + * written before the new epoch starts. + */systemPackages(): Array; + +}; + + +/** + * System transaction used to change the epoch + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * change-epoch = u64 ; next epoch + * u64 ; protocol version + * u64 ; storage charge + * u64 ; computation charge + * u64 ; computation charge burned + * u64 ; storage rebate + * u64 ; non-refundable storage fee + * u64 ; epoch start timestamp + * (vector system-package) + * ``` + */ +export class ChangeEpochV2 extends UniffiAbstractObject implements ChangeEpochV2Interface { + readonly [uniffiTypeNameSymbol] = 'ChangeEpochV2'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(epoch: /*u64*/bigint, protocolVersion: /*u64*/bigint, storageCharge: /*u64*/bigint, computationCharge: /*u64*/bigint, computationChargeBurned: /*u64*/bigint, storageRebate: /*u64*/bigint, nonRefundableStorageFee: /*u64*/bigint, epochStartTimestampMs: /*u64*/bigint, systemPackages: Array) { + super(); + + let epochArg = FfiConverterUInt64.lower(epoch); + let protocolVersionArg = FfiConverterUInt64.lower(protocolVersion); + let storageChargeArg = FfiConverterUInt64.lower(storageCharge); + let computationChargeArg = FfiConverterUInt64.lower(computationCharge); + let computationChargeBurnedArg = FfiConverterUInt64.lower(computationChargeBurned); + let storageRebateArg = FfiConverterUInt64.lower(storageRebate); + let nonRefundableStorageFeeArg = FfiConverterUInt64.lower(nonRefundableStorageFee); + let epochStartTimestampMsArg = FfiConverterUInt64.lower(epochStartTimestampMs); + let systemPackagesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeSystemPackage)).lower(systemPackages)).toStruct(); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_changeepochv2_new([ + epochArg, protocolVersionArg, storageChargeArg, computationChargeArg, computationChargeBurnedArg, storageRebateArg, nonRefundableStorageFeeArg, epochStartTimestampMsArg, systemPackagesArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeChangeEpochV2ObjectFactory.bless(pointer); + }// Methods: + + +/** + * The total amount of gas charged for computation during the epoch. + */computationCharge(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv2_computation_charge([ + uniffiTypeChangeEpochV2ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * The total amount of gas burned for computation during the epoch. + */computationChargeBurned(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv2_computation_charge_burned([ + uniffiTypeChangeEpochV2ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * The next (to become) epoch ID. + */epoch(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv2_epoch([ + uniffiTypeChangeEpochV2ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * Unix timestamp when epoch started + */epochStartTimestampMs(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv2_epoch_start_timestamp_ms([ + uniffiTypeChangeEpochV2ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * The non-refundable storage fee. + */nonRefundableStorageFee(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv2_non_refundable_storage_fee([ + uniffiTypeChangeEpochV2ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * The protocol version in effect in the new epoch. + */protocolVersion(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv2_protocol_version([ + uniffiTypeChangeEpochV2ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * The total amount of gas charged for storage during the epoch. + */storageCharge(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv2_storage_charge([ + uniffiTypeChangeEpochV2ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * The amount of storage rebate refunded to the txn senders. + */storageRebate(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv2_storage_rebate([ + uniffiTypeChangeEpochV2ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * System packages (specifically framework and move stdlib) that are + * written before the new epoch starts. + */systemPackages(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv2_system_packages([ + uniffiTypeChangeEpochV2ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeSystemPackage)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeChangeEpochV2ObjectFactory.pointer(this); + uniffiTypeChangeEpochV2ObjectFactory.freePointer(pointer); + uniffiTypeChangeEpochV2ObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is ChangeEpochV2 { + return uniffiTypeChangeEpochV2ObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeChangeEpochV2ObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeChangeEpochV2ObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): ChangeEpochV2 { + const instance = Object.create(ChangeEpochV2.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'ChangeEpochV2'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: ChangeEpochV2): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: ChangeEpochV2): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_changeepochv2([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_changeepochv2([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is ChangeEpochV2 { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'ChangeEpochV2' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeChangeEpochV2 = new FfiConverterObject( + uniffiTypeChangeEpochV2ObjectFactory +); + + +export type ChangeEpochV3Interface = { + +/** + * The total amount of gas charged for computation during the epoch. + */computationCharge(): /*u64*/bigint; + +/** + * The total amount of gas burned for computation during the epoch. + */computationChargeBurned(): /*u64*/bigint; + +/** + * Vector of active validator indices eligible to take part in committee + * selection because they support the new, target protocol version. + */eligibleActiveValidators(): Array; + +/** + * The next (to become) epoch ID. + */epoch(): /*u64*/bigint; + +/** + * Unix timestamp when epoch started + */epochStartTimestampMs(): /*u64*/bigint; + +/** + * The non-refundable storage fee. + */nonRefundableStorageFee(): /*u64*/bigint; + +/** + * The protocol version in effect in the new epoch. + */protocolVersion(): /*u64*/bigint; + +/** + * The total amount of gas charged for storage during the epoch. + */storageCharge(): /*u64*/bigint; + +/** + * The amount of storage rebate refunded to the txn senders. + */storageRebate(): /*u64*/bigint; + +/** + * System packages (specifically framework and move stdlib) that are + * written before the new epoch starts. + */systemPackages(): Array; + +}; + + +export class ChangeEpochV3 extends UniffiAbstractObject implements ChangeEpochV3Interface { + readonly [uniffiTypeNameSymbol] = 'ChangeEpochV3'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(epoch: /*u64*/bigint, protocolVersion: /*u64*/bigint, storageCharge: /*u64*/bigint, computationCharge: /*u64*/bigint, computationChargeBurned: /*u64*/bigint, storageRebate: /*u64*/bigint, nonRefundableStorageFee: /*u64*/bigint, epochStartTimestampMs: /*u64*/bigint, systemPackages: Array, eligibleActiveValidators: Array) { + super(); + + let epochArg = FfiConverterUInt64.lower(epoch); + let protocolVersionArg = FfiConverterUInt64.lower(protocolVersion); + let storageChargeArg = FfiConverterUInt64.lower(storageCharge); + let computationChargeArg = FfiConverterUInt64.lower(computationCharge); + let computationChargeBurnedArg = FfiConverterUInt64.lower(computationChargeBurned); + let storageRebateArg = FfiConverterUInt64.lower(storageRebate); + let nonRefundableStorageFeeArg = FfiConverterUInt64.lower(nonRefundableStorageFee); + let epochStartTimestampMsArg = FfiConverterUInt64.lower(epochStartTimestampMs); + let systemPackagesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeSystemPackage)).lower(systemPackages)).toStruct(); + let eligibleActiveValidatorsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterUInt64)).lower(eligibleActiveValidators)).toStruct(); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_changeepochv3_new([ + epochArg, protocolVersionArg, storageChargeArg, computationChargeArg, computationChargeBurnedArg, storageRebateArg, nonRefundableStorageFeeArg, epochStartTimestampMsArg, systemPackagesArg, eligibleActiveValidatorsArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeChangeEpochV3ObjectFactory.bless(pointer); + }// Methods: + + +/** + * The total amount of gas charged for computation during the epoch. + */computationCharge(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv3_computation_charge([ + uniffiTypeChangeEpochV3ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * The total amount of gas burned for computation during the epoch. + */computationChargeBurned(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv3_computation_charge_burned([ + uniffiTypeChangeEpochV3ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * Vector of active validator indices eligible to take part in committee + * selection because they support the new, target protocol version. + */eligibleActiveValidators(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv3_eligible_active_validators([ + uniffiTypeChangeEpochV3ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterUInt64)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * The next (to become) epoch ID. + */epoch(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv3_epoch([ + uniffiTypeChangeEpochV3ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * Unix timestamp when epoch started + */epochStartTimestampMs(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv3_epoch_start_timestamp_ms([ + uniffiTypeChangeEpochV3ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * The non-refundable storage fee. + */nonRefundableStorageFee(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv3_non_refundable_storage_fee([ + uniffiTypeChangeEpochV3ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * The protocol version in effect in the new epoch. + */protocolVersion(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv3_protocol_version([ + uniffiTypeChangeEpochV3ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * The total amount of gas charged for storage during the epoch. + */storageCharge(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv3_storage_charge([ + uniffiTypeChangeEpochV3ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * The amount of storage rebate refunded to the txn senders. + */storageRebate(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv3_storage_rebate([ + uniffiTypeChangeEpochV3ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * System packages (specifically framework and move stdlib) that are + * written before the new epoch starts. + */systemPackages(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv3_system_packages([ + uniffiTypeChangeEpochV3ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeSystemPackage)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeChangeEpochV3ObjectFactory.pointer(this); + uniffiTypeChangeEpochV3ObjectFactory.freePointer(pointer); + uniffiTypeChangeEpochV3ObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is ChangeEpochV3 { + return uniffiTypeChangeEpochV3ObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeChangeEpochV3ObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeChangeEpochV3ObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): ChangeEpochV3 { + const instance = Object.create(ChangeEpochV3.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'ChangeEpochV3'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: ChangeEpochV3): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: ChangeEpochV3): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_changeepochv3([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_changeepochv3([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is ChangeEpochV3 { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'ChangeEpochV3' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeChangeEpochV3 = new FfiConverterObject( + uniffiTypeChangeEpochV3ObjectFactory +); + + +export type ChangeEpochV4Interface = { + +/** + * Whether to adjust validator rewards based on score. + */adjustRewardsByScore(): boolean; + +/** + * The total amount of gas charged for computation during the epoch. + */computationCharge(): /*u64*/bigint; + +/** + * The total amount of gas burned for computation during the epoch. + */computationChargeBurned(): /*u64*/bigint; + +/** + * Vector of active validator indices eligible to take part in committee + * selection because they support the new, target protocol version. + */eligibleActiveValidators(): Array; + +/** + * The next (to become) epoch ID. + */epoch(): /*u64*/bigint; + +/** + * Unix timestamp when epoch started + */epochStartTimestampMs(): /*u64*/bigint; + +/** + * The non-refundable storage fee. + */nonRefundableStorageFee(): /*u64*/bigint; + +/** + * The protocol version in effect in the new epoch. + */protocolVersion(): /*u64*/bigint; + +/** + * Vector of scores relative to the past epoch performance of each + * validator, ordered by the past epoch's validator index. + */scores(): Array; + +/** + * The total amount of gas charged for storage during the epoch. + */storageCharge(): /*u64*/bigint; + +/** + * The amount of storage rebate refunded to the txn senders. + */storageRebate(): /*u64*/bigint; + +/** + * System packages (specifically framework and move stdlib) that are + * written before the new epoch starts. + */systemPackages(): Array; + +}; + + +export class ChangeEpochV4 extends UniffiAbstractObject implements ChangeEpochV4Interface { + readonly [uniffiTypeNameSymbol] = 'ChangeEpochV4'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(epoch: /*u64*/bigint, protocolVersion: /*u64*/bigint, storageCharge: /*u64*/bigint, computationCharge: /*u64*/bigint, computationChargeBurned: /*u64*/bigint, storageRebate: /*u64*/bigint, nonRefundableStorageFee: /*u64*/bigint, epochStartTimestampMs: /*u64*/bigint, systemPackages: Array, eligibleActiveValidators: Array, scores: Array, adjustRewardsByScore: boolean) { + super(); + + let epochArg = FfiConverterUInt64.lower(epoch); + let protocolVersionArg = FfiConverterUInt64.lower(protocolVersion); + let storageChargeArg = FfiConverterUInt64.lower(storageCharge); + let computationChargeArg = FfiConverterUInt64.lower(computationCharge); + let computationChargeBurnedArg = FfiConverterUInt64.lower(computationChargeBurned); + let storageRebateArg = FfiConverterUInt64.lower(storageRebate); + let nonRefundableStorageFeeArg = FfiConverterUInt64.lower(nonRefundableStorageFee); + let epochStartTimestampMsArg = FfiConverterUInt64.lower(epochStartTimestampMs); + let systemPackagesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeSystemPackage)).lower(systemPackages)).toStruct(); + let eligibleActiveValidatorsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterUInt64)).lower(eligibleActiveValidators)).toStruct(); + let scoresArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterUInt64)).lower(scores)).toStruct(); + let adjustRewardsByScoreArg = FfiConverterBool.lower(adjustRewardsByScore); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_changeepochv4_new([ + epochArg, protocolVersionArg, storageChargeArg, computationChargeArg, computationChargeBurnedArg, storageRebateArg, nonRefundableStorageFeeArg, epochStartTimestampMsArg, systemPackagesArg, eligibleActiveValidatorsArg, scoresArg, adjustRewardsByScoreArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeChangeEpochV4ObjectFactory.bless(pointer); + }// Methods: + + +/** + * Whether to adjust validator rewards based on score. + */adjustRewardsByScore(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv4_adjust_rewards_by_score([ + uniffiTypeChangeEpochV4ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + +/** + * The total amount of gas charged for computation during the epoch. + */computationCharge(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv4_computation_charge([ + uniffiTypeChangeEpochV4ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * The total amount of gas burned for computation during the epoch. + */computationChargeBurned(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv4_computation_charge_burned([ + uniffiTypeChangeEpochV4ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * Vector of active validator indices eligible to take part in committee + * selection because they support the new, target protocol version. + */eligibleActiveValidators(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv4_eligible_active_validators([ + uniffiTypeChangeEpochV4ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterUInt64)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * The next (to become) epoch ID. + */epoch(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv4_epoch([ + uniffiTypeChangeEpochV4ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * Unix timestamp when epoch started + */epochStartTimestampMs(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv4_epoch_start_timestamp_ms([ + uniffiTypeChangeEpochV4ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * The non-refundable storage fee. + */nonRefundableStorageFee(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv4_non_refundable_storage_fee([ + uniffiTypeChangeEpochV4ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * The protocol version in effect in the new epoch. + */protocolVersion(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv4_protocol_version([ + uniffiTypeChangeEpochV4ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * Vector of scores relative to the past epoch performance of each + * validator, ordered by the past epoch's validator index. + */scores(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv4_scores([ + uniffiTypeChangeEpochV4ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterUInt64)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * The total amount of gas charged for storage during the epoch. + */storageCharge(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv4_storage_charge([ + uniffiTypeChangeEpochV4ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * The amount of storage rebate refunded to the txn senders. + */storageRebate(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv4_storage_rebate([ + uniffiTypeChangeEpochV4ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * System packages (specifically framework and move stdlib) that are + * written before the new epoch starts. + */systemPackages(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_changeepochv4_system_packages([ + uniffiTypeChangeEpochV4ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeSystemPackage)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeChangeEpochV4ObjectFactory.pointer(this); + uniffiTypeChangeEpochV4ObjectFactory.freePointer(pointer); + uniffiTypeChangeEpochV4ObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is ChangeEpochV4 { + return uniffiTypeChangeEpochV4ObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeChangeEpochV4ObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeChangeEpochV4ObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): ChangeEpochV4 { + const instance = Object.create(ChangeEpochV4.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'ChangeEpochV4'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: ChangeEpochV4): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: ChangeEpochV4): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_changeepochv4([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_changeepochv4([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is ChangeEpochV4 { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'ChangeEpochV4' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeChangeEpochV4 = new FfiConverterObject( + uniffiTypeChangeEpochV4ObjectFactory +); + + +export type CheckpointCommitmentInterface = { + asEcmhLiveObjectSetDigest(): Digest; + isEcmhLiveObjectSet(): boolean; + +}; + + +/** + * A commitment made by a checkpoint. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * ; CheckpointCommitment is an enum and each variant is prefixed with its index + * checkpoint-commitment = ecmh-live-object-set + * ecmh-live-object-set = %x00 digest + * ``` + */ +export class CheckpointCommitment extends UniffiAbstractObject implements CheckpointCommitmentInterface { + readonly [uniffiTypeNameSymbol] = 'CheckpointCommitment'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + // Methods: + + asEcmhLiveObjectSetDigest(): Digest { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_checkpointcommitment_as_ecmh_live_object_set_digest([ + uniffiTypeCheckpointCommitmentObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeDigest.lift(returnValue); + } + + isEcmhLiveObjectSet(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_checkpointcommitment_is_ecmh_live_object_set([ + uniffiTypeCheckpointCommitmentObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + + // UniffiTrait implementations: + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeCheckpointCommitmentObjectFactory.pointer(this); + uniffiTypeCheckpointCommitmentObjectFactory.freePointer(pointer); + uniffiTypeCheckpointCommitmentObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is CheckpointCommitment { + return uniffiTypeCheckpointCommitmentObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeCheckpointCommitmentObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeCheckpointCommitmentObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): CheckpointCommitment { + const instance = Object.create(CheckpointCommitment.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'CheckpointCommitment'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: CheckpointCommitment): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: CheckpointCommitment): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_checkpointcommitment([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_checkpointcommitment([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is CheckpointCommitment { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'CheckpointCommitment' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeCheckpointCommitment = new FfiConverterObject( + uniffiTypeCheckpointCommitmentObjectFactory +); + + +export type CheckpointContentsInterface = { + digest(): Digest; + transactionInfo(): Array; + +}; + + +/** + * The committed to contents of a checkpoint. + * + * `CheckpointContents` contains a list of digests of Transactions, their + * effects, and the user signatures that authorized their execution included in + * a checkpoint. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * checkpoint-contents = %x00 checkpoint-contents-v1 ; variant 0 + * + * checkpoint-contents-v1 = (vector (digest digest)) ; vector of transaction and effect digests + * (vector (vector bcs-user-signature)) ; set of user signatures for each + * ; transaction. MUST be the same + * ; length as the vector of digests + * ``` + */ +export class CheckpointContents extends UniffiAbstractObject implements CheckpointContentsInterface { + readonly [uniffiTypeNameSymbol] = 'CheckpointContents'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(transactionInfo: Array) { + super(); + + let transactionInfoArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeCheckpointTransactionInfo)).lower(transactionInfo)).toStruct(); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_checkpointcontents_new([ + transactionInfoArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeCheckpointContentsObjectFactory.bless(pointer); + }// Methods: + + digest(): Digest { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_checkpointcontents_digest([ + uniffiTypeCheckpointContentsObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeDigest.lift(returnValue); + } + + transactionInfo(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_checkpointcontents_transaction_info([ + uniffiTypeCheckpointContentsObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeCheckpointTransactionInfo)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeCheckpointContentsObjectFactory.pointer(this); + uniffiTypeCheckpointContentsObjectFactory.freePointer(pointer); + uniffiTypeCheckpointContentsObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is CheckpointContents { + return uniffiTypeCheckpointContentsObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeCheckpointContentsObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeCheckpointContentsObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): CheckpointContents { + const instance = Object.create(CheckpointContents.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'CheckpointContents'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: CheckpointContents): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: CheckpointContents): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_checkpointcontents([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_checkpointcontents([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is CheckpointContents { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'CheckpointContents' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeCheckpointContents = new FfiConverterObject( + uniffiTypeCheckpointContentsObjectFactory +); + + +export type CheckpointSummaryInterface = { + +/** + * Commitments to checkpoint-specific state. + */checkpointCommitments(): Array; + +/** + * The hash of the `CheckpointContents` for this checkpoint. + */contentDigest(): Digest; + digest(): Digest; + +/** + * Extra data only present in the final checkpoint of an epoch. + */endOfEpochData(): EndOfEpochData | undefined; + +/** + * Epoch that this checkpoint belongs to. + */epoch(): /*u64*/bigint; + +/** + * The running total gas costs of all transactions included in the current + * epoch so far until this checkpoint. + */epochRollingGasCostSummary(): GasCostSummary; + +/** + * Total number of transactions committed since genesis, including those in + * this checkpoint. + */networkTotalTransactions(): /*u64*/bigint; + +/** + * The hash of the previous `CheckpointSummary`. + * + * This will be only be `None` for the first, or genesis checkpoint. + */previousDigest(): Digest | undefined; + +/** + * The height of this checkpoint. + */sequenceNumber(): /*u64*/bigint; + signingMessage(): ArrayBuffer; + signingMessageHex(): string; + +/** + * Timestamp of the checkpoint - number of milliseconds from the Unix epoch + * Checkpoint timestamps are monotonic, but not strongly monotonic - + * subsequent checkpoints can have same timestamp if they originate + * from the same underlining consensus commit + */timestampMs(): /*u64*/bigint; + +/** + * CheckpointSummary is not an evolvable structure - it must be readable by + * any version of the code. Therefore, in order to allow extensions to + * be added to CheckpointSummary, we allow opaque data to be added to + * checkpoints which can be deserialized based on the current + * protocol version. + */versionSpecificData(): ArrayBuffer; + +}; + + +/** + * A header for a Checkpoint on the IOTA blockchain. + * + * On the IOTA network, checkpoints define the history of the blockchain. They + * are quite similar to the concept of blocks used by other blockchains like + * Bitcoin or Ethereum. The IOTA blockchain, however, forms checkpoints after + * transaction execution has already happened to provide a certified history of + * the chain, instead of being formed before execution. + * + * Checkpoints commit to a variety of state including but not limited to: + * - The hash of the previous checkpoint. + * - The set of transaction digests, their corresponding effects digests, as + * well as the set of user signatures which authorized its execution. + * - The object's produced by a transaction. + * - The set of live objects that make up the current state of the chain. + * - On epoch transitions, the next validator committee. + * + * `CheckpointSummary`s themselves don't directly include all of the above + * information but they are the top-level type by which all the above are + * committed to transitively via cryptographic hashes included in the summary. + * `CheckpointSummary`s are signed and certified by a quorum of the validator + * committee in a given epoch in order to allow verification of the chain's + * state. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * checkpoint-summary = u64 ; epoch + * u64 ; sequence_number + * u64 ; network_total_transactions + * digest ; content_digest + * (option digest) ; previous_digest + * gas-cost-summary ; epoch_rolling_gas_cost_summary + * u64 ; timestamp_ms + * (vector checkpoint-commitment) ; checkpoint_commitments + * (option end-of-epoch-data) ; end_of_epoch_data + * bytes ; version_specific_data + * ``` + */ +export class CheckpointSummary extends UniffiAbstractObject implements CheckpointSummaryInterface { + readonly [uniffiTypeNameSymbol] = 'CheckpointSummary'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(epoch: /*u64*/bigint, sequenceNumber: /*u64*/bigint, networkTotalTransactions: /*u64*/bigint, contentDigest: Digest, previousDigest: Digest | undefined, epochRollingGasCostSummary: GasCostSummary, timestampMs: /*u64*/bigint, checkpointCommitments: Array, endOfEpochData: EndOfEpochData | undefined, versionSpecificData: ArrayBuffer) { + super(); + + let epochArg = FfiConverterUInt64.lower(epoch); + let sequenceNumberArg = FfiConverterUInt64.lower(sequenceNumber); + let networkTotalTransactionsArg = FfiConverterUInt64.lower(networkTotalTransactions); + let contentDigestArg = FfiConverterTypeDigest.lower(contentDigest); + let previousDigestArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypeDigest).lower(previousDigest)).toStruct(); + let epochRollingGasCostSummaryArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeGasCostSummary.lower(epochRollingGasCostSummary)).toStruct(); + let timestampMsArg = FfiConverterUInt64.lower(timestampMs); + let checkpointCommitmentsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeCheckpointCommitment)).lower(checkpointCommitments)).toStruct(); + let endOfEpochDataArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypeEndOfEpochData).lower(endOfEpochData)).toStruct(); + let versionSpecificDataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(versionSpecificData)).toStruct(); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_checkpointsummary_new([ + epochArg, sequenceNumberArg, networkTotalTransactionsArg, contentDigestArg, previousDigestArg, epochRollingGasCostSummaryArg, timestampMsArg, checkpointCommitmentsArg, endOfEpochDataArg, versionSpecificDataArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeCheckpointSummaryObjectFactory.bless(pointer); + }// Methods: + + +/** + * Commitments to checkpoint-specific state. + */checkpointCommitments(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_checkpointsummary_checkpoint_commitments([ + uniffiTypeCheckpointSummaryObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeCheckpointCommitment)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * The hash of the `CheckpointContents` for this checkpoint. + */contentDigest(): Digest { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_checkpointsummary_content_digest([ + uniffiTypeCheckpointSummaryObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeDigest.lift(returnValue); + } + + digest(): Digest { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_checkpointsummary_digest([ + uniffiTypeCheckpointSummaryObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeDigest.lift(returnValue); + } + + +/** + * Extra data only present in the final checkpoint of an epoch. + */endOfEpochData(): EndOfEpochData | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_checkpointsummary_end_of_epoch_data([ + uniffiTypeCheckpointSummaryObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeEndOfEpochData).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Epoch that this checkpoint belongs to. + */epoch(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_checkpointsummary_epoch([ + uniffiTypeCheckpointSummaryObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * The running total gas costs of all transactions included in the current + * epoch so far until this checkpoint. + */epochRollingGasCostSummary(): GasCostSummary { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_checkpointsummary_epoch_rolling_gas_cost_summary([ + uniffiTypeCheckpointSummaryObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeGasCostSummary.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Total number of transactions committed since genesis, including those in + * this checkpoint. + */networkTotalTransactions(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_checkpointsummary_network_total_transactions([ + uniffiTypeCheckpointSummaryObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * The hash of the previous `CheckpointSummary`. + * + * This will be only be `None` for the first, or genesis checkpoint. + */previousDigest(): Digest | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_checkpointsummary_previous_digest([ + uniffiTypeCheckpointSummaryObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeDigest).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * The height of this checkpoint. + */sequenceNumber(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_checkpointsummary_sequence_number([ + uniffiTypeCheckpointSummaryObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + signingMessage(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_checkpointsummary_signing_message([ + uniffiTypeCheckpointSummaryObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + signingMessageHex(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_checkpointsummary_signing_message_hex([ + uniffiTypeCheckpointSummaryObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Timestamp of the checkpoint - number of milliseconds from the Unix epoch + * Checkpoint timestamps are monotonic, but not strongly monotonic - + * subsequent checkpoints can have same timestamp if they originate + * from the same underlining consensus commit + */timestampMs(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_checkpointsummary_timestamp_ms([ + uniffiTypeCheckpointSummaryObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * CheckpointSummary is not an evolvable structure - it must be readable by + * any version of the code. Therefore, in order to allow extensions to + * be added to CheckpointSummary, we allow opaque data to be added to + * checkpoints which can be deserialized based on the current + * protocol version. + */versionSpecificData(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_checkpointsummary_version_specific_data([ + uniffiTypeCheckpointSummaryObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeCheckpointSummaryObjectFactory.pointer(this); + uniffiTypeCheckpointSummaryObjectFactory.freePointer(pointer); + uniffiTypeCheckpointSummaryObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is CheckpointSummary { + return uniffiTypeCheckpointSummaryObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeCheckpointSummaryObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeCheckpointSummaryObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): CheckpointSummary { + const instance = Object.create(CheckpointSummary.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'CheckpointSummary'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: CheckpointSummary): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: CheckpointSummary): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_checkpointsummary([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_checkpointsummary([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is CheckpointSummary { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'CheckpointSummary' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeCheckpointSummary = new FfiConverterObject( + uniffiTypeCheckpointSummaryObjectFactory +); + + +export type CheckpointTransactionInfoInterface = { + effects(): Digest; + signatures(): Array; + transaction(): Digest; + +}; + + +/** + * Transaction information committed to in a checkpoint + */ +export class CheckpointTransactionInfo extends UniffiAbstractObject implements CheckpointTransactionInfoInterface { + readonly [uniffiTypeNameSymbol] = 'CheckpointTransactionInfo'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(transaction: Digest, effects: Digest, signatures: Array) { + super(); + + let transactionArg = FfiConverterTypeDigest.lower(transaction); + let effectsArg = FfiConverterTypeDigest.lower(effects); + let signaturesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeUserSignature)).lower(signatures)).toStruct(); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_checkpointtransactioninfo_new([ + transactionArg, effectsArg, signaturesArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeCheckpointTransactionInfoObjectFactory.bless(pointer); + }// Methods: + + effects(): Digest { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_checkpointtransactioninfo_effects([ + uniffiTypeCheckpointTransactionInfoObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeDigest.lift(returnValue); + } + + signatures(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_checkpointtransactioninfo_signatures([ + uniffiTypeCheckpointTransactionInfoObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeUserSignature)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + transaction(): Digest { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_checkpointtransactioninfo_transaction([ + uniffiTypeCheckpointTransactionInfoObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeDigest.lift(returnValue); + } + + + // UniffiTrait implementations: + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeCheckpointTransactionInfoObjectFactory.pointer(this); + uniffiTypeCheckpointTransactionInfoObjectFactory.freePointer(pointer); + uniffiTypeCheckpointTransactionInfoObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is CheckpointTransactionInfo { + return uniffiTypeCheckpointTransactionInfoObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeCheckpointTransactionInfoObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeCheckpointTransactionInfoObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): CheckpointTransactionInfo { + const instance = Object.create(CheckpointTransactionInfo.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'CheckpointTransactionInfo'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: CheckpointTransactionInfo): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: CheckpointTransactionInfo): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_checkpointtransactioninfo([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_checkpointtransactioninfo([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is CheckpointTransactionInfo { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'CheckpointTransactionInfo' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeCheckpointTransactionInfo = new FfiConverterObject( + uniffiTypeCheckpointTransactionInfoObjectFactory +); + + +export type CircomG1Interface = { + +}; + + +/** + * A G1 point + * + * This represents the canonical decimal representation of the projective + * coordinates in Fq. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * circom-g1 = %x03 3(bn254-field-element) + * ``` + */ +export class CircomG1 extends UniffiAbstractObject implements CircomG1Interface { + readonly [uniffiTypeNameSymbol] = 'CircomG1'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(el0: Bn254FieldElement, el1: Bn254FieldElement, el2: Bn254FieldElement) { + super(); + + let el0Arg = FfiConverterTypeBn254FieldElement.lower(el0); + let el1Arg = FfiConverterTypeBn254FieldElement.lower(el1); + let el2Arg = FfiConverterTypeBn254FieldElement.lower(el2); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_circomg1_new([ + el0Arg, el1Arg, el2Arg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeCircomG1ObjectFactory.bless(pointer); + }// Methods: + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeCircomG1ObjectFactory.pointer(this); + uniffiTypeCircomG1ObjectFactory.freePointer(pointer); + uniffiTypeCircomG1ObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is CircomG1 { + return uniffiTypeCircomG1ObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeCircomG1ObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeCircomG1ObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): CircomG1 { + const instance = Object.create(CircomG1.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'CircomG1'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: CircomG1): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: CircomG1): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_circomg1([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_circomg1([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is CircomG1 { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'CircomG1' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeCircomG1 = new FfiConverterObject( + uniffiTypeCircomG1ObjectFactory +); + + +export type CircomG2Interface = { + +}; + + +/** + * A G2 point + * + * This represents the canonical decimal representation of the coefficients of + * the projective coordinates in Fq2. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * circom-g2 = %x03 3(%x02 2(bn254-field-element)) + * ``` + */ +export class CircomG2 extends UniffiAbstractObject implements CircomG2Interface { + readonly [uniffiTypeNameSymbol] = 'CircomG2'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(el00: Bn254FieldElement, el01: Bn254FieldElement, el10: Bn254FieldElement, el11: Bn254FieldElement, el20: Bn254FieldElement, el21: Bn254FieldElement) { + super(); + + let el00Arg = FfiConverterTypeBn254FieldElement.lower(el00); + let el01Arg = FfiConverterTypeBn254FieldElement.lower(el01); + let el10Arg = FfiConverterTypeBn254FieldElement.lower(el10); + let el11Arg = FfiConverterTypeBn254FieldElement.lower(el11); + let el20Arg = FfiConverterTypeBn254FieldElement.lower(el20); + let el21Arg = FfiConverterTypeBn254FieldElement.lower(el21); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_circomg2_new([ + el00Arg, el01Arg, el10Arg, el11Arg, el20Arg, el21Arg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeCircomG2ObjectFactory.bless(pointer); + }// Methods: + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeCircomG2ObjectFactory.pointer(this); + uniffiTypeCircomG2ObjectFactory.freePointer(pointer); + uniffiTypeCircomG2ObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is CircomG2 { + return uniffiTypeCircomG2ObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeCircomG2ObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeCircomG2ObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): CircomG2 { + const instance = Object.create(CircomG2.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'CircomG2'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: CircomG2): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: CircomG2): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_circomg2([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_circomg2([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is CircomG2 { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'CircomG2' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeCircomG2 = new FfiConverterObject( + uniffiTypeCircomG2ObjectFactory +); + + +export type ClientTransactionBuilderInterface = { + +/** + * Dry run the transaction. + *//* async */ dryRun(skipChecks: boolean, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Execute the transaction and optionally wait for finalization. + *//* async */ execute(signer: TransactionSigner, waitFor: WaitForTx | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Execute the transaction and optionally wait for finalization. + *//* async */ executeWithSponsor(signer: TransactionSigner, sponsorSigner: TransactionSigner, waitFor: WaitForTx | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Set the expiration of the transaction to be a specific epoch. + */expiration(epoch: /*u64*/bigint): ClientTransactionBuilder; + +/** + * Convert this builder into a transaction. + *//* async */ finish(asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Add gas coins that will be consumed. Optional. + */gas(objectIds: Array): ClientTransactionBuilder; + +/** + * Set the gas budget for the transaction. + */gasBudget(budget: /*u64*/bigint): ClientTransactionBuilder; + +/** + * Set the gas price for the transaction. + */gasPrice(price: /*u64*/bigint): ClientTransactionBuilder; + +/** + * Set the gas station sponsor. + */gasStationSponsor(url: string, duration: number /* in milliseconds */ | undefined, headers: Map> | undefined): ClientTransactionBuilder; + +/** + * Make a move vector from a list of elements. The elements must all be of + * the type indicated by `type_tag`. + */makeMoveVec(elements: Array, typeTag: TypeTag, name: string): ClientTransactionBuilder; + +/** + * Merge multiple coins into one. + * + * This method combines the balances of multiple coins of the same coin + * type into a single coin. The `primary_coin` will receive the balances + * from all `consumed_coins`. After merging, the `consumed_coins` will + * be consumed and no longer exist. + */mergeCoins(primaryCoin: PtbArgument, consumedCoins: Array): ClientTransactionBuilder; + +/** + * Call a Move function with the given arguments. + */moveCall(package_: Address, module: Identifier, function_: Identifier, arguments_: Array, typeArgs: Array, names: Array): ClientTransactionBuilder; + +/** + * Publish a list of modules with the given dependencies. The result + * assigned to `upgrade_cap_name` is the `0x2::package::UpgradeCap` + * Move type. Note that the upgrade capability needs to be handled + * after this call: + * - transfer it to the transaction sender or another address + * - burn it + * - wrap it for access control + * - discard the it to make a package immutable + * + * The arguments required for this command are: + * - `modules`: is the modules' bytecode to be published + * - `dependencies`: is the list of IDs of the transitive dependencies of + * the package + */publish(packageData: MovePackageData, upgradeCapName: string): ClientTransactionBuilder; + +/** + * Transfer some coins to a recipient address. If multiple coins are + * provided then they will be merged. + * + * The `amount` parameter specifies the quantity in NANOS, where 1 IOTA + * equals 1_000_000_000 NANOS. + * If `amount` is provided, that amount is split from the provided coins + * and sent. + * If `amount` is `None`, the entire coins are transferred. + * + * All provided coins must have the same coin type. Mixing coins of + * different types will result in an error. + * + * If you intend to transfer all provided coins to another address in a + * single transaction, consider using + * `TransactionBuilder::transfer_objects()` instead. + */sendCoins(coins: Array, recipient: Address, amount: PtbArgument | undefined): ClientTransactionBuilder; + +/** + * Send IOTA to a recipient address. + * + * The `amount` parameter specifies the quantity in NANOS, where 1 IOTA + * equals 1_000_000_000 NANOS. That amount is split from the gas coin and + * sent. + */sendIota(recipient: Address, amount: PtbArgument): ClientTransactionBuilder; + +/** + * Set the sender address. + */setSender(sender: Address): void; + +/** + * Split a coin into many. + */splitCoins(coin: PtbArgument, amounts: Array, names: Array): ClientTransactionBuilder; + +/** + * Set the sponsor of the transaction. + */sponsor(sponsor: Address): ClientTransactionBuilder; + +/** + * Add stake to a validator's staking pool. + * + * This is a high-level function which will split the provided stake amount + * from the gas coin and then stake using the resulting coin. + */stake(stake: PtbArgument, validatorAddress: Address): ClientTransactionBuilder; + +/** + * Transfer a list of objects to the given address, without producing any + * result. + */transferObjects(recipient: Address, objects: Array): ClientTransactionBuilder; + +/** + * Withdraw stake from a validator's staking pool. + */unstake(stakedIota: PtbArgument): ClientTransactionBuilder; + +/** + * Upgrade a Move package. + * + * - `modules`: is the modules' bytecode for the modules to be published + * - `dependencies`: is the list of IDs of the transitive dependencies of + * the package to be upgraded + * - `package`: is the ID of the current package being upgraded + * - `ticket`: is the upgrade ticket + * + * To get the ticket, you have to call the + * `0x2::package::authorize_upgrade` function, and pass the package + * ID, the upgrade policy, and package digest. + */upgrade(packageId: ObjectId, packageData: MovePackageData, upgradeTicket: PtbArgument, name: string | undefined): ClientTransactionBuilder; + +}; + + +/** + * A builder for creating transactions which uses a GraphQL client to + * automatically resolve inputs. Use `finish` to finalize the transaction data. + */ +export class ClientTransactionBuilder extends UniffiAbstractObject implements ClientTransactionBuilderInterface { + readonly [uniffiTypeNameSymbol] = 'ClientTransactionBuilder'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + // Methods: + + +/** + * Dry run the transaction. + */async dryRun(skipChecks: boolean, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let skipChecksArg = FfiConverterBool.lower(skipChecks); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_dry_run([ + uniffiTypeClientTransactionBuilderObjectFactory.clonePointer(this), skipChecksArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeDryRunResult.lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Execute the transaction and optionally wait for finalization. + */async execute(signer: TransactionSigner, waitFor: WaitForTx | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let signerArg = FfiConverterTypeTransactionSigner.lower(signer); + let waitForArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypeWaitForTx).lower(waitFor)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_execute([ + uniffiTypeClientTransactionBuilderObjectFactory.clonePointer(this), signerArg, waitForArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_pointer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_pointer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_pointer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_pointer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeTransactionEffects.lift(value), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Execute the transaction and optionally wait for finalization. + */async executeWithSponsor(signer: TransactionSigner, sponsorSigner: TransactionSigner, waitFor: WaitForTx | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let signerArg = FfiConverterTypeTransactionSigner.lower(signer); + let sponsorSignerArg = FfiConverterTypeTransactionSigner.lower(sponsorSigner); + let waitForArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypeWaitForTx).lower(waitFor)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_execute_with_sponsor([ + uniffiTypeClientTransactionBuilderObjectFactory.clonePointer(this), signerArg, sponsorSignerArg, waitForArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_pointer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_pointer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_pointer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_pointer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeTransactionEffects.lift(value), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Set the expiration of the transaction to be a specific epoch. + */expiration(epoch: /*u64*/bigint): ClientTransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let epochArg = FfiConverterUInt64.lower(epoch); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_expiration([ + uniffiTypeClientTransactionBuilderObjectFactory.clonePointer(this), epochArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeClientTransactionBuilder.lift(returnValue); + } + + +/** + * Convert this builder into a transaction. + */async finish(asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_finish([ + uniffiTypeClientTransactionBuilderObjectFactory.clonePointer(this) + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_pointer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_pointer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_pointer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_pointer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeTransaction.lift(value), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Add gas coins that will be consumed. Optional. + */gas(objectIds: Array): ClientTransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let objectIdsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeObjectId)).lower(objectIds)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_gas([ + uniffiTypeClientTransactionBuilderObjectFactory.clonePointer(this), objectIdsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeClientTransactionBuilder.lift(returnValue); + } + + +/** + * Set the gas budget for the transaction. + */gasBudget(budget: /*u64*/bigint): ClientTransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let budgetArg = FfiConverterUInt64.lower(budget); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_gas_budget([ + uniffiTypeClientTransactionBuilderObjectFactory.clonePointer(this), budgetArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeClientTransactionBuilder.lift(returnValue); + } + + +/** + * Set the gas price for the transaction. + */gasPrice(price: /*u64*/bigint): ClientTransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let priceArg = FfiConverterUInt64.lower(price); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_gas_price([ + uniffiTypeClientTransactionBuilderObjectFactory.clonePointer(this), priceArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeClientTransactionBuilder.lift(returnValue); + } + + +/** + * Set the gas station sponsor. + */gasStationSponsor(url: string, duration: number /* in milliseconds */ | undefined, headers: Map> | undefined): ClientTransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let urlArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(url)).toStruct(); + let durationArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterDuration).lower(duration)).toStruct(); + let headersArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional((new FfiConverterMap(FfiConverterString, (new FfiConverterArray(FfiConverterString))))).lower(headers)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_gas_station_sponsor([ + uniffiTypeClientTransactionBuilderObjectFactory.clonePointer(this), urlArg, durationArg, headersArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeClientTransactionBuilder.lift(returnValue); + } + + +/** + * Make a move vector from a list of elements. The elements must all be of + * the type indicated by `type_tag`. + */makeMoveVec(elements: Array, typeTag: TypeTag, name: string): ClientTransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let elementsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeMoveArg)).lower(elements)).toStruct(); + let typeTagArg = FfiConverterTypeTypeTag.lower(typeTag); + let nameArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(name)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_make_move_vec([ + uniffiTypeClientTransactionBuilderObjectFactory.clonePointer(this), elementsArg, typeTagArg, nameArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeClientTransactionBuilder.lift(returnValue); + } + + +/** + * Merge multiple coins into one. + * + * This method combines the balances of multiple coins of the same coin + * type into a single coin. The `primary_coin` will receive the balances + * from all `consumed_coins`. After merging, the `consumed_coins` will + * be consumed and no longer exist. + */mergeCoins(primaryCoin: PtbArgument, consumedCoins: Array): ClientTransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let primaryCoinArg = FfiConverterTypePtbArgument.lower(primaryCoin); + let consumedCoinsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypePtbArgument)).lower(consumedCoins)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_merge_coins([ + uniffiTypeClientTransactionBuilderObjectFactory.clonePointer(this), primaryCoinArg, consumedCoinsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeClientTransactionBuilder.lift(returnValue); + } + + +/** + * Call a Move function with the given arguments. + */moveCall(package_: Address, module: Identifier, function_: Identifier, arguments_: Array, typeArgs: Array, names: Array): ClientTransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let package_Arg = FfiConverterTypeAddress.lower(package_); + let moduleArg = FfiConverterTypeIdentifier.lower(module); + let function_Arg = FfiConverterTypeIdentifier.lower(function_); + let arguments_Arg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypePtbArgument)).lower(arguments_)).toStruct(); + let typeArgsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeTypeTag)).lower(typeArgs)).toStruct(); + let namesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterString)).lower(names)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_move_call([ + uniffiTypeClientTransactionBuilderObjectFactory.clonePointer(this), package_Arg, moduleArg, function_Arg, arguments_Arg, typeArgsArg, namesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeClientTransactionBuilder.lift(returnValue); + } + + +/** + * Publish a list of modules with the given dependencies. The result + * assigned to `upgrade_cap_name` is the `0x2::package::UpgradeCap` + * Move type. Note that the upgrade capability needs to be handled + * after this call: + * - transfer it to the transaction sender or another address + * - burn it + * - wrap it for access control + * - discard the it to make a package immutable + * + * The arguments required for this command are: + * - `modules`: is the modules' bytecode to be published + * - `dependencies`: is the list of IDs of the transitive dependencies of + * the package + */publish(packageData: MovePackageData, upgradeCapName: string): ClientTransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let packageDataArg = FfiConverterTypeMovePackageData.lower(packageData); + let upgradeCapNameArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(upgradeCapName)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_publish([ + uniffiTypeClientTransactionBuilderObjectFactory.clonePointer(this), packageDataArg, upgradeCapNameArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeClientTransactionBuilder.lift(returnValue); + } + + +/** + * Transfer some coins to a recipient address. If multiple coins are + * provided then they will be merged. + * + * The `amount` parameter specifies the quantity in NANOS, where 1 IOTA + * equals 1_000_000_000 NANOS. + * If `amount` is provided, that amount is split from the provided coins + * and sent. + * If `amount` is `None`, the entire coins are transferred. + * + * All provided coins must have the same coin type. Mixing coins of + * different types will result in an error. + * + * If you intend to transfer all provided coins to another address in a + * single transaction, consider using + * `TransactionBuilder::transfer_objects()` instead. + */sendCoins(coins: Array, recipient: Address, amount: PtbArgument | undefined): ClientTransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let coinsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypePtbArgument)).lower(coins)).toStruct(); + let recipientArg = FfiConverterTypeAddress.lower(recipient); + let amountArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypePtbArgument).lower(amount)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_send_coins([ + uniffiTypeClientTransactionBuilderObjectFactory.clonePointer(this), coinsArg, recipientArg, amountArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeClientTransactionBuilder.lift(returnValue); + } + + +/** + * Send IOTA to a recipient address. + * + * The `amount` parameter specifies the quantity in NANOS, where 1 IOTA + * equals 1_000_000_000 NANOS. That amount is split from the gas coin and + * sent. + */sendIota(recipient: Address, amount: PtbArgument): ClientTransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let recipientArg = FfiConverterTypeAddress.lower(recipient); + let amountArg = FfiConverterTypePtbArgument.lower(amount); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_send_iota([ + uniffiTypeClientTransactionBuilderObjectFactory.clonePointer(this), recipientArg, amountArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeClientTransactionBuilder.lift(returnValue); + } + + +/** + * Set the sender address. + */setSender(sender: Address): void { + /* Regular function call: */ + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let senderArg = FfiConverterTypeAddress.lower(sender); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_set_sender([ + uniffiTypeClientTransactionBuilderObjectFactory.clonePointer(this), senderArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + +/** + * Split a coin into many. + */splitCoins(coin: PtbArgument, amounts: Array, names: Array): ClientTransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let coinArg = FfiConverterTypePtbArgument.lower(coin); + let amountsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypePtbArgument)).lower(amounts)).toStruct(); + let namesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterString)).lower(names)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_split_coins([ + uniffiTypeClientTransactionBuilderObjectFactory.clonePointer(this), coinArg, amountsArg, namesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeClientTransactionBuilder.lift(returnValue); + } + + +/** + * Set the sponsor of the transaction. + */sponsor(sponsor: Address): ClientTransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let sponsorArg = FfiConverterTypeAddress.lower(sponsor); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_sponsor([ + uniffiTypeClientTransactionBuilderObjectFactory.clonePointer(this), sponsorArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeClientTransactionBuilder.lift(returnValue); + } + + +/** + * Add stake to a validator's staking pool. + * + * This is a high-level function which will split the provided stake amount + * from the gas coin and then stake using the resulting coin. + */stake(stake: PtbArgument, validatorAddress: Address): ClientTransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let stakeArg = FfiConverterTypePtbArgument.lower(stake); + let validatorAddressArg = FfiConverterTypeAddress.lower(validatorAddress); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_stake([ + uniffiTypeClientTransactionBuilderObjectFactory.clonePointer(this), stakeArg, validatorAddressArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeClientTransactionBuilder.lift(returnValue); + } + + +/** + * Transfer a list of objects to the given address, without producing any + * result. + */transferObjects(recipient: Address, objects: Array): ClientTransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let recipientArg = FfiConverterTypeAddress.lower(recipient); + let objectsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypePtbArgument)).lower(objects)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_transfer_objects([ + uniffiTypeClientTransactionBuilderObjectFactory.clonePointer(this), recipientArg, objectsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeClientTransactionBuilder.lift(returnValue); + } + + +/** + * Withdraw stake from a validator's staking pool. + */unstake(stakedIota: PtbArgument): ClientTransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let stakedIotaArg = FfiConverterTypePtbArgument.lower(stakedIota); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_unstake([ + uniffiTypeClientTransactionBuilderObjectFactory.clonePointer(this), stakedIotaArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeClientTransactionBuilder.lift(returnValue); + } + + +/** + * Upgrade a Move package. + * + * - `modules`: is the modules' bytecode for the modules to be published + * - `dependencies`: is the list of IDs of the transitive dependencies of + * the package to be upgraded + * - `package`: is the ID of the current package being upgraded + * - `ticket`: is the upgrade ticket + * + * To get the ticket, you have to call the + * `0x2::package::authorize_upgrade` function, and pass the package + * ID, the upgrade policy, and package digest. + */upgrade(packageId: ObjectId, packageData: MovePackageData, upgradeTicket: PtbArgument, name: string | undefined): ClientTransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let packageIdArg = FfiConverterTypeObjectId.lower(packageId); + let packageDataArg = FfiConverterTypeMovePackageData.lower(packageData); + let upgradeTicketArg = FfiConverterTypePtbArgument.lower(upgradeTicket); + let nameArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterString).lower(name)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_upgrade([ + uniffiTypeClientTransactionBuilderObjectFactory.clonePointer(this), packageIdArg, packageDataArg, upgradeTicketArg, nameArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeClientTransactionBuilder.lift(returnValue); + } + + + // UniffiTrait implementations: + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeClientTransactionBuilderObjectFactory.pointer(this); + uniffiTypeClientTransactionBuilderObjectFactory.freePointer(pointer); + uniffiTypeClientTransactionBuilderObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is ClientTransactionBuilder { + return uniffiTypeClientTransactionBuilderObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeClientTransactionBuilderObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeClientTransactionBuilderObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): ClientTransactionBuilder { + const instance = Object.create(ClientTransactionBuilder.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'ClientTransactionBuilder'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: ClientTransactionBuilder): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: ClientTransactionBuilder): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_clienttransactionbuilder([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_clienttransactionbuilder([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is ClientTransactionBuilder { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'ClientTransactionBuilder' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeClientTransactionBuilder = new FfiConverterObject( + uniffiTypeClientTransactionBuilderObjectFactory +); + + +export type CoinInterface = { + balance(): /*u64*/bigint; + coinType(): TypeTag; + id(): ObjectId; + +}; + + +export class Coin extends UniffiAbstractObject implements CoinInterface { + readonly [uniffiTypeNameSymbol] = 'Coin'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static tryFromObject(object: Object_): Coin { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let objectArg = FfiConverterTypeObject.lower(object); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_coin_try_from_object([ + objectArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCoin.lift(returnValue); + }// Methods: + + balance(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_coin_balance([ + uniffiTypeCoinObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + coinType(): TypeTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_coin_coin_type([ + uniffiTypeCoinObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTypeTag.lift(returnValue); + } + + id(): ObjectId { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_coin_id([ + uniffiTypeCoinObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectId.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeCoinObjectFactory.pointer(this); + uniffiTypeCoinObjectFactory.freePointer(pointer); + uniffiTypeCoinObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Coin { + return uniffiTypeCoinObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeCoinObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeCoinObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Coin { + const instance = Object.create(Coin.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Coin'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Coin): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Coin): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_coin([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_coin([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Coin { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Coin' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeCoin = new FfiConverterObject( + uniffiTypeCoinObjectFactory +); + + +export type CommandInterface = { + +}; + + +/** + * A single command in a programmable transaction. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * command = command-move-call + * =/ command-transfer-objects + * =/ command-split-coins + * =/ command-merge-coins + * =/ command-publish + * =/ command-make-move-vector + * =/ command-upgrade + * + * command-move-call = %x00 move-call + * command-transfer-objects = %x01 transfer-objects + * command-split-coins = %x02 split-coins + * command-merge-coins = %x03 merge-coins + * command-publish = %x04 publish + * command-make-move-vector = %x05 make-move-vector + * command-upgrade = %x06 upgrade + * ``` + */ +export class Command extends UniffiAbstractObject implements CommandInterface { + readonly [uniffiTypeNameSymbol] = 'Command'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + +/** + * Given n-values of the same type, it constructs a vector. For non objects + * or an empty vector, the type tag must be specified. + */ + + static newMakeMoveVector(makeMoveVector: MakeMoveVector): Command { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let makeMoveVectorArg = FfiConverterTypeMakeMoveVector.lower(makeMoveVector); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_command_new_make_move_vector([ + makeMoveVectorArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCommand.lift(returnValue); + } +/** + * It merges n-coins into the first coin + */ + + static newMergeCoins(mergeCoins: MergeCoins): Command { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let mergeCoinsArg = FfiConverterTypeMergeCoins.lower(mergeCoins); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_command_new_merge_coins([ + mergeCoinsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCommand.lift(returnValue); + } +/** + * A call to either an entry or a public Move function + */ + + static newMoveCall(moveCall: MoveCall): Command { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let moveCallArg = FfiConverterTypeMoveCall.lower(moveCall); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_command_new_move_call([ + moveCallArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCommand.lift(returnValue); + } +/** + * Publishes a Move package. It takes the package bytes and a list of the + * package's transitive dependencies to link against on-chain. + */ + + static newPublish(publish: Publish): Command { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let publishArg = FfiConverterTypePublish.lower(publish); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_command_new_publish([ + publishArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCommand.lift(returnValue); + } +/** + * It splits off some amounts into a new coins with those amounts + */ + + static newSplitCoins(splitCoins: SplitCoins): Command { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let splitCoinsArg = FfiConverterTypeSplitCoins.lower(splitCoins); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_command_new_split_coins([ + splitCoinsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCommand.lift(returnValue); + } +/** + * It sends n-objects to the specified address. These objects must have + * store (public transfer) and either the previous owner must be an + * address or the object must be newly created. + */ + + static newTransferObjects(transferObjects: TransferObjects): Command { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let transferObjectsArg = FfiConverterTypeTransferObjects.lower(transferObjects); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_command_new_transfer_objects([ + transferObjectsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCommand.lift(returnValue); + } +/** + * Upgrades a Move package + * Takes (in order): + * 1. A vector of serialized modules for the package. + * 2. A vector of object ids for the transitive dependencies of the new + * package. + * 3. The object ID of the package being upgraded. + * 4. An argument holding the `UpgradeTicket` that must have been produced + * from an earlier command in the same programmable transaction. + */ + + static newUpgrade(upgrade: Upgrade): Command { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let upgradeArg = FfiConverterTypeUpgrade.lower(upgrade); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_command_new_upgrade([ + upgradeArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCommand.lift(returnValue); + }// Methods: + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeCommandObjectFactory.pointer(this); + uniffiTypeCommandObjectFactory.freePointer(pointer); + uniffiTypeCommandObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Command { + return uniffiTypeCommandObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeCommandObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeCommandObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Command { + const instance = Object.create(Command.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Command'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Command): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Command): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_command([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_command([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Command { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Command' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeCommand = new FfiConverterObject( + uniffiTypeCommandObjectFactory +); + + +export type ConsensusCommitPrologueV1Interface = { + +/** + * Unix timestamp from consensus + */commitTimestampMs(): /*u64*/bigint; + +/** + * Digest of consensus output + */consensusCommitDigest(): Digest; + +/** + * Stores consensus handler determined shared object version assignments. + */consensusDeterminedVersionAssignments(): ConsensusDeterminedVersionAssignments; + +/** + * Epoch of the commit prologue transaction + */epoch(): /*u64*/bigint; + +/** + * Consensus round of the commit + */round(): /*u64*/bigint; + +/** + * The sub DAG index of the consensus commit. This field will be populated + * if there are multiple consensus commits per round. + */subDagIndex(): /*u64*/bigint | undefined; + +}; + + +/** + * V1 of the consensus commit prologue system transaction + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * consensus-commit-prologue-v1 = u64 u64 (option u64) u64 digest + * consensus-determined-version-assignments + * ``` + */ +export class ConsensusCommitPrologueV1 extends UniffiAbstractObject implements ConsensusCommitPrologueV1Interface { + readonly [uniffiTypeNameSymbol] = 'ConsensusCommitPrologueV1'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(epoch: /*u64*/bigint, round: /*u64*/bigint, subDagIndex: /*u64*/bigint | undefined, commitTimestampMs: /*u64*/bigint, consensusCommitDigest: Digest, consensusDeterminedVersionAssignments: ConsensusDeterminedVersionAssignments) { + super(); + + let epochArg = FfiConverterUInt64.lower(epoch); + let roundArg = FfiConverterUInt64.lower(round); + let subDagIndexArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterUInt64).lower(subDagIndex)).toStruct(); + let commitTimestampMsArg = FfiConverterUInt64.lower(commitTimestampMs); + let consensusCommitDigestArg = FfiConverterTypeDigest.lower(consensusCommitDigest); + let consensusDeterminedVersionAssignmentsArg = FfiConverterTypeConsensusDeterminedVersionAssignments.lower(consensusDeterminedVersionAssignments); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_consensuscommitprologuev1_new([ + epochArg, roundArg, subDagIndexArg, commitTimestampMsArg, consensusCommitDigestArg, consensusDeterminedVersionAssignmentsArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeConsensusCommitPrologueV1ObjectFactory.bless(pointer); + }// Methods: + + +/** + * Unix timestamp from consensus + */commitTimestampMs(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_commit_timestamp_ms([ + uniffiTypeConsensusCommitPrologueV1ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * Digest of consensus output + */consensusCommitDigest(): Digest { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_consensus_commit_digest([ + uniffiTypeConsensusCommitPrologueV1ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeDigest.lift(returnValue); + } + + +/** + * Stores consensus handler determined shared object version assignments. + */consensusDeterminedVersionAssignments(): ConsensusDeterminedVersionAssignments { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_consensus_determined_version_assignments([ + uniffiTypeConsensusCommitPrologueV1ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeConsensusDeterminedVersionAssignments.lift(returnValue); + } + + +/** + * Epoch of the commit prologue transaction + */epoch(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_epoch([ + uniffiTypeConsensusCommitPrologueV1ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * Consensus round of the commit + */round(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_round([ + uniffiTypeConsensusCommitPrologueV1ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * The sub DAG index of the consensus commit. This field will be populated + * if there are multiple consensus commits per round. + */subDagIndex(): /*u64*/bigint | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_sub_dag_index([ + uniffiTypeConsensusCommitPrologueV1ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterUInt64).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeConsensusCommitPrologueV1ObjectFactory.pointer(this); + uniffiTypeConsensusCommitPrologueV1ObjectFactory.freePointer(pointer); + uniffiTypeConsensusCommitPrologueV1ObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is ConsensusCommitPrologueV1 { + return uniffiTypeConsensusCommitPrologueV1ObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeConsensusCommitPrologueV1ObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeConsensusCommitPrologueV1ObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): ConsensusCommitPrologueV1 { + const instance = Object.create(ConsensusCommitPrologueV1.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'ConsensusCommitPrologueV1'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: ConsensusCommitPrologueV1): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: ConsensusCommitPrologueV1): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_consensuscommitprologuev1([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_consensuscommitprologuev1([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is ConsensusCommitPrologueV1 { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'ConsensusCommitPrologueV1' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeConsensusCommitPrologueV1 = new FfiConverterObject( + uniffiTypeConsensusCommitPrologueV1ObjectFactory +); + + +export type ConsensusDeterminedVersionAssignmentsInterface = { + asCancelledTransactions(): Array; + isCancelledTransactions(): boolean; + +}; + + +export class ConsensusDeterminedVersionAssignments extends UniffiAbstractObject implements ConsensusDeterminedVersionAssignmentsInterface { + readonly [uniffiTypeNameSymbol] = 'ConsensusDeterminedVersionAssignments'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static newCancelledTransactions(cancelledTransactions: Array): ConsensusDeterminedVersionAssignments { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let cancelledTransactionsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeCancelledTransaction)).lower(cancelledTransactions)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_consensusdeterminedversionassignments_new_cancelled_transactions([ + cancelledTransactionsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeConsensusDeterminedVersionAssignments.lift(returnValue); + }// Methods: + + asCancelledTransactions(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_consensusdeterminedversionassignments_as_cancelled_transactions([ + uniffiTypeConsensusDeterminedVersionAssignmentsObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeCancelledTransaction)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + isCancelledTransactions(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_consensusdeterminedversionassignments_is_cancelled_transactions([ + uniffiTypeConsensusDeterminedVersionAssignmentsObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeConsensusDeterminedVersionAssignmentsObjectFactory.pointer(this); + uniffiTypeConsensusDeterminedVersionAssignmentsObjectFactory.freePointer(pointer); + uniffiTypeConsensusDeterminedVersionAssignmentsObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is ConsensusDeterminedVersionAssignments { + return uniffiTypeConsensusDeterminedVersionAssignmentsObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeConsensusDeterminedVersionAssignmentsObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeConsensusDeterminedVersionAssignmentsObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): ConsensusDeterminedVersionAssignments { + const instance = Object.create(ConsensusDeterminedVersionAssignments.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'ConsensusDeterminedVersionAssignments'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: ConsensusDeterminedVersionAssignments): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: ConsensusDeterminedVersionAssignments): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_consensusdeterminedversionassignments([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_consensusdeterminedversionassignments([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is ConsensusDeterminedVersionAssignments { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'ConsensusDeterminedVersionAssignments' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeConsensusDeterminedVersionAssignments = new FfiConverterObject( + uniffiTypeConsensusDeterminedVersionAssignmentsObjectFactory +); + + +export type DigestInterface = { + +/** + * Returns the next digest in byte-increasing order. + */nextLexicographical(): Digest; + toBase58(): string; + toBytes(): ArrayBuffer; + +}; + + +/** + * A 32-byte Blake2b256 hash output. + * + * # BCS + * + * A `Digest`'s BCS serialized form is defined by the following: + * + * ```text + * digest = %x20 32OCTET + * ``` + * + * Due to historical reasons, even though a `Digest` has a fixed-length of 32, + * IOTA's binary representation of a `Digest` is prefixed with its length + * meaning its serialized binary form (in bcs) is 33 bytes long vs a more + * compact 32 bytes. + */ +export class Digest extends UniffiAbstractObject implements DigestInterface { + readonly [uniffiTypeNameSymbol] = 'Digest'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static fromBase58(base58: string): Digest { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let base58Arg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(base58)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_digest_from_base58([ + base58Arg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeDigest.lift(returnValue); + } + + static fromBytes(bytes: ArrayBuffer): Digest { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_digest_from_bytes([ + bytesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeDigest.lift(returnValue); + } + + static generate(): Digest { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_digest_generate([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeDigest.lift(returnValue); + }// Methods: + + +/** + * Returns the next digest in byte-increasing order. + */nextLexicographical(): Digest { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_digest_next_lexicographical([ + uniffiTypeDigestObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeDigest.lift(returnValue); + } + + toBase58(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_digest_to_base58([ + uniffiTypeDigestObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + toBytes(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_digest_to_bytes([ + uniffiTypeDigestObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + toString(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_digest_uniffi_trait_display([ + uniffiTypeDigestObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeDigestObjectFactory.pointer(this); + uniffiTypeDigestObjectFactory.freePointer(pointer); + uniffiTypeDigestObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Digest { + return uniffiTypeDigestObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeDigestObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeDigestObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Digest { + const instance = Object.create(Digest.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Digest'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Digest): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Digest): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_digest([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_digest([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Digest { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Digest' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeDigest = new FfiConverterObject( + uniffiTypeDigestObjectFactory +); + + +export type Ed25519PrivateKeyInterface = { + publicKey(): Ed25519PublicKey; + scheme(): SignatureScheme; + +/** + * Sign a personal message and return a UserSignature. + */signPersonalMessage(message: PersonalMessage): UserSignature; + +/** + * Sign a transaction and return a UserSignature. + */signTransaction(transaction: Transaction): UserSignature; + +/** + * Encode this private key as `flag || privkey` in Bech32 starting with + * "iotaprivkey" to a string. + */toBech32(): string; + +/** + * Serialize this private key to bytes. + */toBytes(): ArrayBuffer; + +/** + * Serialize this private key as DER-encoded PKCS#8 + */toDer(): ArrayBuffer; + +/** + * Serialize this private key as PEM-encoded PKCS#8 + */toPem(): string; + trySign(message: ArrayBuffer): Ed25519Signature; + trySignSimple(message: ArrayBuffer): SimpleSignature; + trySignUser(message: ArrayBuffer): UserSignature; + verifyingKey(): Ed25519VerifyingKey; + +}; + + +export class Ed25519PrivateKey extends UniffiAbstractObject implements Ed25519PrivateKeyInterface { + readonly [uniffiTypeNameSymbol] = 'Ed25519PrivateKey'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + +/** + * Decode a private key from `flag || privkey` in Bech32 starting with + * "iotaprivkey". + */ + + static fromBech32(value: string): Ed25519PrivateKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let valueArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(value)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ed25519privatekey_from_bech32([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEd25519PrivateKey.lift(returnValue); + } +/** + * Deserialize PKCS#8 private key from ASN.1 DER-encoded data (binary + * format). + */ + + static fromDer(bytes: ArrayBuffer): Ed25519PrivateKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ed25519privatekey_from_der([ + bytesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEd25519PrivateKey.lift(returnValue); + } +/** + * Construct the private key from a mnemonic phrase + */ + + static fromMnemonic(phrase: string, accountIndex: /*u64*/bigint, password: string): Ed25519PrivateKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let phraseArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(phrase)).toStruct(); + let accountIndexArg = FfiConverterUInt64.lower(accountIndex); + let passwordArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(password)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ed25519privatekey_from_mnemonic([ + phraseArg, accountIndexArg, passwordArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEd25519PrivateKey.lift(returnValue); + } +/** + * Create an instance from a mnemonic phrase and a derivation path like + * `"m/44'/4218'/0'/0'/0'"` + */ + + static fromMnemonicWithPath(phrase: string, path: string, password: string): Ed25519PrivateKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let phraseArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(phrase)).toStruct(); + let pathArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(path)).toStruct(); + let passwordArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(password)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ed25519privatekey_from_mnemonic_with_path([ + phraseArg, pathArg, passwordArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEd25519PrivateKey.lift(returnValue); + } +/** + * Deserialize PKCS#8-encoded private key from PEM. + */ + + static fromPem(s: string): Ed25519PrivateKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let sArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(s)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ed25519privatekey_from_pem([ + sArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEd25519PrivateKey.lift(returnValue); + } + + static generate(): Ed25519PrivateKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ed25519privatekey_generate([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEd25519PrivateKey.lift(returnValue); + } + constructor(bytes: ArrayBuffer) { + super(); + + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + const pointer =uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ed25519privatekey_new([ + bytesArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeEd25519PrivateKeyObjectFactory.bless(pointer); + }// Methods: + + publicKey(): Ed25519PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_public_key([ + uniffiTypeEd25519PrivateKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEd25519PublicKey.lift(returnValue); + } + + scheme(): SignatureScheme { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_scheme([ + uniffiTypeEd25519PrivateKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSignatureScheme.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Sign a personal message and return a UserSignature. + */signPersonalMessage(message: PersonalMessage): UserSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = FfiConverterTypePersonalMessage.lower(message); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_sign_personal_message([ + uniffiTypeEd25519PrivateKeyObjectFactory.clonePointer(this), messageArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUserSignature.lift(returnValue); + } + + +/** + * Sign a transaction and return a UserSignature. + */signTransaction(transaction: Transaction): UserSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let transactionArg = FfiConverterTypeTransaction.lower(transaction); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_sign_transaction([ + uniffiTypeEd25519PrivateKeyObjectFactory.clonePointer(this), transactionArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUserSignature.lift(returnValue); + } + + +/** + * Encode this private key as `flag || privkey` in Bech32 starting with + * "iotaprivkey" to a string. + */toBech32(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_to_bech32([ + uniffiTypeEd25519PrivateKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Serialize this private key to bytes. + */toBytes(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_to_bytes([ + uniffiTypeEd25519PrivateKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Serialize this private key as DER-encoded PKCS#8 + */toDer(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_to_der([ + uniffiTypeEd25519PrivateKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Serialize this private key as PEM-encoded PKCS#8 + */toPem(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_to_pem([ + uniffiTypeEd25519PrivateKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + trySign(message: ArrayBuffer): Ed25519Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_try_sign([ + uniffiTypeEd25519PrivateKeyObjectFactory.clonePointer(this), messageArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEd25519Signature.lift(returnValue); + } + + trySignSimple(message: ArrayBuffer): SimpleSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_try_sign_simple([ + uniffiTypeEd25519PrivateKeyObjectFactory.clonePointer(this), messageArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSimpleSignature.lift(returnValue); + } + + trySignUser(message: ArrayBuffer): UserSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_try_sign_user([ + uniffiTypeEd25519PrivateKeyObjectFactory.clonePointer(this), messageArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUserSignature.lift(returnValue); + } + + verifyingKey(): Ed25519VerifyingKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_verifying_key([ + uniffiTypeEd25519PrivateKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEd25519VerifyingKey.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeEd25519PrivateKeyObjectFactory.pointer(this); + uniffiTypeEd25519PrivateKeyObjectFactory.freePointer(pointer); + uniffiTypeEd25519PrivateKeyObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Ed25519PrivateKey { + return uniffiTypeEd25519PrivateKeyObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeEd25519PrivateKeyObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeEd25519PrivateKeyObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Ed25519PrivateKey { + const instance = Object.create(Ed25519PrivateKey.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Ed25519PrivateKey'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Ed25519PrivateKey): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Ed25519PrivateKey): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_ed25519privatekey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_ed25519privatekey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Ed25519PrivateKey { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Ed25519PrivateKey' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeEd25519PrivateKey = new FfiConverterObject( + uniffiTypeEd25519PrivateKeyObjectFactory +); + + +export type Ed25519PublicKeyInterface = { + +/** + * Derive an `Address` from this Public Key + * + * An `Address` can be derived from an `Ed25519PublicKey` by hashing the + * bytes of the public key with no prefix flag. + * + * `hash(32-byte ed25519 public key)` + */deriveAddress(): Address; + +/** + * Returns the signature scheme for this public key. + */scheme(): SignatureScheme; + toBytes(): ArrayBuffer; + +/** + * Returns the bytes with signature scheme flag prepended. + */toFlaggedBytes(): ArrayBuffer; + +}; + + +/** + * An ed25519 public key. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * ed25519-public-key = 32OCTET + * ``` + */ +export class Ed25519PublicKey extends UniffiAbstractObject implements Ed25519PublicKeyInterface { + readonly [uniffiTypeNameSymbol] = 'Ed25519PublicKey'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static fromBytes(bytes: ArrayBuffer): Ed25519PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ed25519publickey_from_bytes([ + bytesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEd25519PublicKey.lift(returnValue); + } + + static fromStr(s: string): Ed25519PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let sArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(s)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ed25519publickey_from_str([ + sArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEd25519PublicKey.lift(returnValue); + } + + static generate(): Ed25519PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ed25519publickey_generate([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEd25519PublicKey.lift(returnValue); + }// Methods: + + +/** + * Derive an `Address` from this Public Key + * + * An `Address` can be derived from an `Ed25519PublicKey` by hashing the + * bytes of the public key with no prefix flag. + * + * `hash(32-byte ed25519 public key)` + */deriveAddress(): Address { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_ed25519publickey_derive_address([ + uniffiTypeEd25519PublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeAddress.lift(returnValue); + } + + +/** + * Returns the signature scheme for this public key. + */scheme(): SignatureScheme { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_ed25519publickey_scheme([ + uniffiTypeEd25519PublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSignatureScheme.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + toBytes(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_ed25519publickey_to_bytes([ + uniffiTypeEd25519PublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Returns the bytes with signature scheme flag prepended. + */toFlaggedBytes(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_ed25519publickey_to_flagged_bytes([ + uniffiTypeEd25519PublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeEd25519PublicKeyObjectFactory.pointer(this); + uniffiTypeEd25519PublicKeyObjectFactory.freePointer(pointer); + uniffiTypeEd25519PublicKeyObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Ed25519PublicKey { + return uniffiTypeEd25519PublicKeyObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeEd25519PublicKeyObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeEd25519PublicKeyObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Ed25519PublicKey { + const instance = Object.create(Ed25519PublicKey.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Ed25519PublicKey'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Ed25519PublicKey): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Ed25519PublicKey): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_ed25519publickey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_ed25519publickey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Ed25519PublicKey { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Ed25519PublicKey' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeEd25519PublicKey = new FfiConverterObject( + uniffiTypeEd25519PublicKeyObjectFactory +); + + +export type Ed25519SignatureInterface = { + toBytes(): ArrayBuffer; + +}; + + +/** + * An ed25519 signature. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * ed25519-signature = 64OCTET + * ``` + */ +export class Ed25519Signature extends UniffiAbstractObject implements Ed25519SignatureInterface { + readonly [uniffiTypeNameSymbol] = 'Ed25519Signature'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static fromBytes(bytes: ArrayBuffer): Ed25519Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ed25519signature_from_bytes([ + bytesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEd25519Signature.lift(returnValue); + } + + static fromStr(s: string): Ed25519Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let sArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(s)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ed25519signature_from_str([ + sArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEd25519Signature.lift(returnValue); + } + + static generate(): Ed25519Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ed25519signature_generate([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEd25519Signature.lift(returnValue); + }// Methods: + + toBytes(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_ed25519signature_to_bytes([ + uniffiTypeEd25519SignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeEd25519SignatureObjectFactory.pointer(this); + uniffiTypeEd25519SignatureObjectFactory.freePointer(pointer); + uniffiTypeEd25519SignatureObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Ed25519Signature { + return uniffiTypeEd25519SignatureObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeEd25519SignatureObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeEd25519SignatureObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Ed25519Signature { + const instance = Object.create(Ed25519Signature.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Ed25519Signature'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Ed25519Signature): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Ed25519Signature): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_ed25519signature([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_ed25519signature([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Ed25519Signature { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Ed25519Signature' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeEd25519Signature = new FfiConverterObject( + uniffiTypeEd25519SignatureObjectFactory +); + + +export type Ed25519VerifierInterface = { + verifySimple(message: ArrayBuffer, signature: SimpleSignature): void; + verifyUser(message: ArrayBuffer, signature: UserSignature): void; + +}; + + +export class Ed25519Verifier extends UniffiAbstractObject implements Ed25519VerifierInterface { + readonly [uniffiTypeNameSymbol] = 'Ed25519Verifier'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor() { + super(); + + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ed25519verifier_new([ + callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeEd25519VerifierObjectFactory.bless(pointer); + }// Methods: + + verifySimple(message: ArrayBuffer, signature: SimpleSignature): void { + /* Regular function call: */ + uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + let signatureArg = FfiConverterTypeSimpleSignature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_ed25519verifier_verify_simple([ + uniffiTypeEd25519VerifierObjectFactory.clonePointer(this), messageArg, signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + verifyUser(message: ArrayBuffer, signature: UserSignature): void { + /* Regular function call: */ + uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + let signatureArg = FfiConverterTypeUserSignature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_ed25519verifier_verify_user([ + uniffiTypeEd25519VerifierObjectFactory.clonePointer(this), messageArg, signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + + // UniffiTrait implementations: + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeEd25519VerifierObjectFactory.pointer(this); + uniffiTypeEd25519VerifierObjectFactory.freePointer(pointer); + uniffiTypeEd25519VerifierObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Ed25519Verifier { + return uniffiTypeEd25519VerifierObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeEd25519VerifierObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeEd25519VerifierObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Ed25519Verifier { + const instance = Object.create(Ed25519Verifier.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Ed25519Verifier'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Ed25519Verifier): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Ed25519Verifier): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_ed25519verifier([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_ed25519verifier([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Ed25519Verifier { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Ed25519Verifier' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeEd25519Verifier = new FfiConverterObject( + uniffiTypeEd25519VerifierObjectFactory +); + + +export type Ed25519VerifyingKeyInterface = { + publicKey(): Ed25519PublicKey; + +/** + * Serialize this public key as DER-encoded data + */toDer(): ArrayBuffer; + +/** + * Serialize this public key into PEM format + */toPem(): string; + verify(message: ArrayBuffer, signature: Ed25519Signature): void; + verifySimple(message: ArrayBuffer, signature: SimpleSignature): void; + verifyUser(message: ArrayBuffer, signature: UserSignature): void; + +}; + + +export class Ed25519VerifyingKey extends UniffiAbstractObject implements Ed25519VerifyingKeyInterface { + readonly [uniffiTypeNameSymbol] = 'Ed25519VerifyingKey'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + +/** + * Deserialize public key from ASN.1 DER-encoded data (binary format). + */ + + static fromDer(bytes: ArrayBuffer): Ed25519VerifyingKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ed25519verifyingkey_from_der([ + bytesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEd25519VerifyingKey.lift(returnValue); + } +/** + * Deserialize public key from PEM. + */ + + static fromPem(s: string): Ed25519VerifyingKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let sArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(s)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ed25519verifyingkey_from_pem([ + sArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEd25519VerifyingKey.lift(returnValue); + } + constructor(publicKey: Ed25519PublicKey) { + super(); + + let publicKeyArg = FfiConverterTypeEd25519PublicKey.lower(publicKey); + const pointer =uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ed25519verifyingkey_new([ + publicKeyArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeEd25519VerifyingKeyObjectFactory.bless(pointer); + }// Methods: + + publicKey(): Ed25519PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_ed25519verifyingkey_public_key([ + uniffiTypeEd25519VerifyingKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEd25519PublicKey.lift(returnValue); + } + + +/** + * Serialize this public key as DER-encoded data + */toDer(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_ed25519verifyingkey_to_der([ + uniffiTypeEd25519VerifyingKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Serialize this public key into PEM format + */toPem(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_ed25519verifyingkey_to_pem([ + uniffiTypeEd25519VerifyingKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + verify(message: ArrayBuffer, signature: Ed25519Signature): void { + /* Regular function call: */ + uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + let signatureArg = FfiConverterTypeEd25519Signature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_ed25519verifyingkey_verify([ + uniffiTypeEd25519VerifyingKeyObjectFactory.clonePointer(this), messageArg, signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + verifySimple(message: ArrayBuffer, signature: SimpleSignature): void { + /* Regular function call: */ + uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + let signatureArg = FfiConverterTypeSimpleSignature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_ed25519verifyingkey_verify_simple([ + uniffiTypeEd25519VerifyingKeyObjectFactory.clonePointer(this), messageArg, signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + verifyUser(message: ArrayBuffer, signature: UserSignature): void { + /* Regular function call: */ + uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + let signatureArg = FfiConverterTypeUserSignature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_ed25519verifyingkey_verify_user([ + uniffiTypeEd25519VerifyingKeyObjectFactory.clonePointer(this), messageArg, signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeEd25519VerifyingKeyObjectFactory.pointer(this); + uniffiTypeEd25519VerifyingKeyObjectFactory.freePointer(pointer); + uniffiTypeEd25519VerifyingKeyObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Ed25519VerifyingKey { + return uniffiTypeEd25519VerifyingKeyObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeEd25519VerifyingKeyObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeEd25519VerifyingKeyObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Ed25519VerifyingKey { + const instance = Object.create(Ed25519VerifyingKey.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Ed25519VerifyingKey'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Ed25519VerifyingKey): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Ed25519VerifyingKey): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_ed25519verifyingkey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_ed25519verifyingkey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Ed25519VerifyingKey { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Ed25519VerifyingKey' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeEd25519VerifyingKey = new FfiConverterObject( + uniffiTypeEd25519VerifyingKeyObjectFactory +); + + +export type EndOfEpochTransactionKindInterface = { + +}; + + +/** + * Operation run at the end of an epoch + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * end-of-epoch-transaction-kind = eoe-change-epoch + * =/ eoe-authenticator-state-create + * =/ eoe-authenticator-state-expire + * =/ eoe-randomness-state-create + * =/ eoe-deny-list-state-create + * =/ eoe-bridge-state-create + * =/ eoe-bridge-committee-init + * =/ eoe-store-execution-time-observations + * + * eoe-change-epoch = %x00 change-epoch + * eoe-authenticator-state-create = %x01 + * eoe-authenticator-state-expire = %x02 authenticator-state-expire + * eoe-randomness-state-create = %x03 + * eoe-deny-list-state-create = %x04 + * eoe-bridge-state-create = %x05 digest + * eoe-bridge-committee-init = %x06 u64 + * eoe-store-execution-time-observations = %x07 stored-execution-time-observations + * ``` + */ +export class EndOfEpochTransactionKind extends UniffiAbstractObject implements EndOfEpochTransactionKindInterface { + readonly [uniffiTypeNameSymbol] = 'EndOfEpochTransactionKind'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static newAuthenticatorStateCreate(): EndOfEpochTransactionKind { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_endofepochtransactionkind_new_authenticator_state_create([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEndOfEpochTransactionKind.lift(returnValue); + } + + static newAuthenticatorStateExpire(tx: AuthenticatorStateExpire): EndOfEpochTransactionKind { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let txArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeAuthenticatorStateExpire.lower(tx)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_endofepochtransactionkind_new_authenticator_state_expire([ + txArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEndOfEpochTransactionKind.lift(returnValue); + } + + static newChangeEpoch(tx: ChangeEpoch): EndOfEpochTransactionKind { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let txArg = FfiConverterTypeChangeEpoch.lower(tx); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_endofepochtransactionkind_new_change_epoch([ + txArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEndOfEpochTransactionKind.lift(returnValue); + } + + static newChangeEpochV2(tx: ChangeEpochV2): EndOfEpochTransactionKind { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let txArg = FfiConverterTypeChangeEpochV2.lower(tx); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_endofepochtransactionkind_new_change_epoch_v2([ + txArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEndOfEpochTransactionKind.lift(returnValue); + } + + static newChangeEpochV3(tx: ChangeEpochV3): EndOfEpochTransactionKind { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let txArg = FfiConverterTypeChangeEpochV3.lower(tx); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_endofepochtransactionkind_new_change_epoch_v3([ + txArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEndOfEpochTransactionKind.lift(returnValue); + } + + static newChangeEpochV4(tx: ChangeEpochV4): EndOfEpochTransactionKind { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let txArg = FfiConverterTypeChangeEpochV4.lower(tx); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_endofepochtransactionkind_new_change_epoch_v4([ + txArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEndOfEpochTransactionKind.lift(returnValue); + }// Methods: + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeEndOfEpochTransactionKindObjectFactory.pointer(this); + uniffiTypeEndOfEpochTransactionKindObjectFactory.freePointer(pointer); + uniffiTypeEndOfEpochTransactionKindObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is EndOfEpochTransactionKind { + return uniffiTypeEndOfEpochTransactionKindObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeEndOfEpochTransactionKindObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeEndOfEpochTransactionKindObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): EndOfEpochTransactionKind { + const instance = Object.create(EndOfEpochTransactionKind.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'EndOfEpochTransactionKind'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: EndOfEpochTransactionKind): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: EndOfEpochTransactionKind): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_endofepochtransactionkind([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_endofepochtransactionkind([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is EndOfEpochTransactionKind { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'EndOfEpochTransactionKind' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeEndOfEpochTransactionKind = new FfiConverterObject( + uniffiTypeEndOfEpochTransactionKindObjectFactory +); + + +export type ExecutionTimeObservationInterface = { + key(): ExecutionTimeObservationKey; + observations(): Array; + +}; + + +export class ExecutionTimeObservation extends UniffiAbstractObject implements ExecutionTimeObservationInterface { + readonly [uniffiTypeNameSymbol] = 'ExecutionTimeObservation'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(key: ExecutionTimeObservationKey, observations: Array) { + super(); + + let keyArg = FfiConverterTypeExecutionTimeObservationKey.lower(key); + let observationsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeValidatorExecutionTimeObservation)).lower(observations)).toStruct(); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservation_new([ + keyArg, observationsArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeExecutionTimeObservationObjectFactory.bless(pointer); + }// Methods: + + key(): ExecutionTimeObservationKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_executiontimeobservation_key([ + uniffiTypeExecutionTimeObservationObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeExecutionTimeObservationKey.lift(returnValue); + } + + observations(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_executiontimeobservation_observations([ + uniffiTypeExecutionTimeObservationObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeValidatorExecutionTimeObservation)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeExecutionTimeObservationObjectFactory.pointer(this); + uniffiTypeExecutionTimeObservationObjectFactory.freePointer(pointer); + uniffiTypeExecutionTimeObservationObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is ExecutionTimeObservation { + return uniffiTypeExecutionTimeObservationObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeExecutionTimeObservationObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeExecutionTimeObservationObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): ExecutionTimeObservation { + const instance = Object.create(ExecutionTimeObservation.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'ExecutionTimeObservation'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: ExecutionTimeObservation): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: ExecutionTimeObservation): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_executiontimeobservation([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_executiontimeobservation([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is ExecutionTimeObservation { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'ExecutionTimeObservation' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeExecutionTimeObservation = new FfiConverterObject( + uniffiTypeExecutionTimeObservationObjectFactory +); + + +export type ExecutionTimeObservationKeyInterface = { + +}; + + +/** + * Key for an execution time observation + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * execution-time-observation-key = %x00 move-entry-point + * =/ %x01 ; transfer-objects + * =/ %x02 ; split-coins + * =/ %x03 ; merge-coins + * =/ %x04 ; publish + * =/ %x05 ; make-move-vec + * =/ %x06 ; upgrade + * + * move-entry-point = object-id string string (vec type-tag) + * ``` + */ +export class ExecutionTimeObservationKey extends UniffiAbstractObject implements ExecutionTimeObservationKeyInterface { + readonly [uniffiTypeNameSymbol] = 'ExecutionTimeObservationKey'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static newMakeMoveVec(): ExecutionTimeObservationKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_make_move_vec([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeExecutionTimeObservationKey.lift(returnValue); + } + + static newMergeCoins(): ExecutionTimeObservationKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_merge_coins([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeExecutionTimeObservationKey.lift(returnValue); + } + + static newMoveEntryPoint(package_: ObjectId, module: string, function_: string, typeArguments: Array): ExecutionTimeObservationKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let package_Arg = FfiConverterTypeObjectId.lower(package_); + let moduleArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(module)).toStruct(); + let function_Arg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(function_)).toStruct(); + let typeArgumentsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeTypeTag)).lower(typeArguments)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_move_entry_point([ + package_Arg, moduleArg, function_Arg, typeArgumentsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeExecutionTimeObservationKey.lift(returnValue); + } + + static newPublish(): ExecutionTimeObservationKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_publish([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeExecutionTimeObservationKey.lift(returnValue); + } + + static newSplitCoins(): ExecutionTimeObservationKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_split_coins([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeExecutionTimeObservationKey.lift(returnValue); + } + + static newTransferObjects(): ExecutionTimeObservationKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_transfer_objects([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeExecutionTimeObservationKey.lift(returnValue); + } + + static newUpgrade(): ExecutionTimeObservationKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_upgrade([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeExecutionTimeObservationKey.lift(returnValue); + }// Methods: + + + // UniffiTrait implementations: + + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeExecutionTimeObservationKeyObjectFactory.pointer(this); + uniffiTypeExecutionTimeObservationKeyObjectFactory.freePointer(pointer); + uniffiTypeExecutionTimeObservationKeyObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is ExecutionTimeObservationKey { + return uniffiTypeExecutionTimeObservationKeyObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeExecutionTimeObservationKeyObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeExecutionTimeObservationKeyObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): ExecutionTimeObservationKey { + const instance = Object.create(ExecutionTimeObservationKey.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'ExecutionTimeObservationKey'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: ExecutionTimeObservationKey): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: ExecutionTimeObservationKey): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_executiontimeobservationkey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_executiontimeobservationkey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is ExecutionTimeObservationKey { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'ExecutionTimeObservationKey' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeExecutionTimeObservationKey = new FfiConverterObject( + uniffiTypeExecutionTimeObservationKeyObjectFactory +); + + +export type ExecutionTimeObservationsInterface = { + +}; + + +/** + * Set of Execution Time Observations from the committee. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * stored-execution-time-observations = %x00 v1-stored-execution-time-observations + * + * v1-stored-execution-time-observations = (vec + * execution-time-observation-key + * (vec execution-time-observation) + * ) + * ``` + */ +export class ExecutionTimeObservations extends UniffiAbstractObject implements ExecutionTimeObservationsInterface { + readonly [uniffiTypeNameSymbol] = 'ExecutionTimeObservations'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static newV1(executionTimeObservations: Array): ExecutionTimeObservations { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let executionTimeObservationsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeExecutionTimeObservation)).lower(executionTimeObservations)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservations_new_v1([ + executionTimeObservationsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeExecutionTimeObservations.lift(returnValue); + }// Methods: + + + // UniffiTrait implementations: + + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeExecutionTimeObservationsObjectFactory.pointer(this); + uniffiTypeExecutionTimeObservationsObjectFactory.freePointer(pointer); + uniffiTypeExecutionTimeObservationsObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is ExecutionTimeObservations { + return uniffiTypeExecutionTimeObservationsObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeExecutionTimeObservationsObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeExecutionTimeObservationsObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): ExecutionTimeObservations { + const instance = Object.create(ExecutionTimeObservations.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'ExecutionTimeObservations'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: ExecutionTimeObservations): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: ExecutionTimeObservations): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_executiontimeobservations([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_executiontimeobservations([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is ExecutionTimeObservations { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'ExecutionTimeObservations' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeExecutionTimeObservations = new FfiConverterObject( + uniffiTypeExecutionTimeObservationsObjectFactory +); + + +export type FaucetClientInterface = { + +/** + * Request gas from the faucet. Note that this will return the UUID of the + * request and not wait until the token is received. Use + * `request_and_wait` to wait for the token. + *//* async */ request(address: Address, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Request gas from the faucet and wait until the request is completed and + * token is transferred. Returns `FaucetReceipt` if the request is + * successful, which contains the list of tokens transferred, and the + * transaction digest. + * + * Note that the faucet is heavily rate-limited, so calling repeatedly the + * faucet would likely result in a 429 code or 502 code. + * + * If you intend to use the transferred tokens with the graphql client, + * consider using `request_and_wait_for_finalized` instead to ensure + * the tokens are available in the indexer. + *//* async */ requestAndWait(address: Address, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Request gas from the faucet and wait until the request is completed and + * token is transferred and finalized on the ledger. Returns + * `FaucetReceipt` if the request is successful, which contains the + * list of tokens transferred, and the transaction digest. + * + * This is a convenience method that combines `request_and_wait` and + * waiting for the funding transactions to be finalized using the provided + * GraphQL `Client`. + *//* async */ requestAndWaitForFinalized(address: Address, client: GraphQlClient, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Check the faucet request status. + * + * Possible statuses are defined in: `BatchSendStatusType` + *//* async */ requestStatus(id: string, asyncOpts_?: { signal: AbortSignal }): Promise; + +}; + + +export class FaucetClient extends UniffiAbstractObject implements FaucetClientInterface { + readonly [uniffiTypeNameSymbol] = 'FaucetClient'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + +/** + * Construct a new `FaucetClient` with the given faucet service URL. This + * `FaucetClient` expects that the service provides two endpoints: + * /v1/gas and /v1/status. As such, do not provide the request + * endpoint, just the top level service endpoint. + * + * - /v1/gas is used to request gas + * - /v1/status/task-uuid is used to check the status of the request + */ + constructor(faucetUrl: string) { + super(); + + let faucetUrlArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(faucetUrl)).toStruct(); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_faucetclient_new([ + faucetUrlArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeFaucetClientObjectFactory.bless(pointer); + } +/** + * Create a new Faucet client connected to the `devnet` faucet. + */ + + static newDevnet(): FaucetClient { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_faucetclient_new_devnet([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeFaucetClient.lift(returnValue); + } +/** + * Create a new Faucet client connected to a `localnet` faucet. + */ + + static newLocalnet(): FaucetClient { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_faucetclient_new_localnet([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeFaucetClient.lift(returnValue); + } +/** + * Create a new Faucet client connected to the `testnet` faucet. + */ + + static newTestnet(): FaucetClient { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_faucetclient_new_testnet([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeFaucetClient.lift(returnValue); + }// Methods: + + +/** + * Request gas from the faucet. Note that this will return the UUID of the + * request and not wait until the token is received. Use + * `request_and_wait` to wait for the token. + */async request(address: Address, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let addressArg = FfiConverterTypeAddress.lower(address); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_faucetclient_request([ + uniffiTypeFaucetClientObjectFactory.clonePointer(this), addressArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterString).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Request gas from the faucet and wait until the request is completed and + * token is transferred. Returns `FaucetReceipt` if the request is + * successful, which contains the list of tokens transferred, and the + * transaction digest. + * + * Note that the faucet is heavily rate-limited, so calling repeatedly the + * faucet would likely result in a 429 code or 502 code. + * + * If you intend to use the transferred tokens with the graphql client, + * consider using `request_and_wait_for_finalized` instead to ensure + * the tokens are available in the indexer. + */async requestAndWait(address: Address, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let addressArg = FfiConverterTypeAddress.lower(address); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_faucetclient_request_and_wait([ + uniffiTypeFaucetClientObjectFactory.clonePointer(this), addressArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterTypeFaucetReceipt).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Request gas from the faucet and wait until the request is completed and + * token is transferred and finalized on the ledger. Returns + * `FaucetReceipt` if the request is successful, which contains the + * list of tokens transferred, and the transaction digest. + * + * This is a convenience method that combines `request_and_wait` and + * waiting for the funding transactions to be finalized using the provided + * GraphQL `Client`. + */async requestAndWaitForFinalized(address: Address, client: GraphQlClient, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let addressArg = FfiConverterTypeAddress.lower(address); + let clientArg = FfiConverterTypeGraphQlClient.lower(client); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_faucetclient_request_and_wait_for_finalized([ + uniffiTypeFaucetClientObjectFactory.clonePointer(this), addressArg, clientArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterTypeFaucetReceipt).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Check the faucet request status. + * + * Possible statuses are defined in: `BatchSendStatusType` + */async requestStatus(id: string, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let idArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(id)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_faucetclient_request_status([ + uniffiTypeFaucetClientObjectFactory.clonePointer(this), idArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterTypeBatchSendStatus).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + + // UniffiTrait implementations: + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeFaucetClientObjectFactory.pointer(this); + uniffiTypeFaucetClientObjectFactory.freePointer(pointer); + uniffiTypeFaucetClientObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is FaucetClient { + return uniffiTypeFaucetClientObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeFaucetClientObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeFaucetClientObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): FaucetClient { + const instance = Object.create(FaucetClient.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'FaucetClient'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: FaucetClient): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: FaucetClient): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_faucetclient([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_faucetclient([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is FaucetClient { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'FaucetClient' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeFaucetClient = new FfiConverterObject( + uniffiTypeFaucetClientObjectFactory +); + + +export type GenesisObjectInterface = { + data(): ObjectData; + objectId(): ObjectId; + objectType(): ObjectType; + owner(): Owner; + version(): /*u64*/bigint; + +}; + + +/** + * An object part of the initial chain state + * + * `GenesisObject`'s are included as a part of genesis, the initial + * checkpoint/transaction, that initializes the state of the blockchain. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * genesis-object = object-data owner + * ``` + */ +export class GenesisObject extends UniffiAbstractObject implements GenesisObjectInterface { + readonly [uniffiTypeNameSymbol] = 'GenesisObject'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(data: ObjectData, owner: Owner) { + super(); + + let dataArg = FfiConverterTypeObjectData.lower(data); + let ownerArg = FfiConverterTypeOwner.lower(owner); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_genesisobject_new([ + dataArg, ownerArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeGenesisObjectObjectFactory.bless(pointer); + }// Methods: + + data(): ObjectData { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_genesisobject_data([ + uniffiTypeGenesisObjectObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectData.lift(returnValue); + } + + objectId(): ObjectId { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_genesisobject_object_id([ + uniffiTypeGenesisObjectObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectId.lift(returnValue); + } + + objectType(): ObjectType { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_genesisobject_object_type([ + uniffiTypeGenesisObjectObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectType.lift(returnValue); + } + + owner(): Owner { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_genesisobject_owner([ + uniffiTypeGenesisObjectObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeOwner.lift(returnValue); + } + + version(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_genesisobject_version([ + uniffiTypeGenesisObjectObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeGenesisObjectObjectFactory.pointer(this); + uniffiTypeGenesisObjectObjectFactory.freePointer(pointer); + uniffiTypeGenesisObjectObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is GenesisObject { + return uniffiTypeGenesisObjectObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeGenesisObjectObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeGenesisObjectObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): GenesisObject { + const instance = Object.create(GenesisObject.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'GenesisObject'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: GenesisObject): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: GenesisObject): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_genesisobject([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_genesisobject([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is GenesisObject { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'GenesisObject' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeGenesisObject = new FfiConverterObject( + uniffiTypeGenesisObjectObjectFactory +); + + +export type GenesisTransactionInterface = { + events(): Array; + objects(): Array; + +}; + + +/** + * The genesis transaction + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * genesis-transaction = (vector genesis-object) + * ``` + */ +export class GenesisTransaction extends UniffiAbstractObject implements GenesisTransactionInterface { + readonly [uniffiTypeNameSymbol] = 'GenesisTransaction'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(objects: Array, events: Array) { + super(); + + let objectsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeGenesisObject)).lower(objects)).toStruct(); + let eventsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeEvent)).lower(events)).toStruct(); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_genesistransaction_new([ + objectsArg, eventsArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeGenesisTransactionObjectFactory.bless(pointer); + }// Methods: + + events(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_genesistransaction_events([ + uniffiTypeGenesisTransactionObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeEvent)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + objects(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_genesistransaction_objects([ + uniffiTypeGenesisTransactionObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeGenesisObject)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeGenesisTransactionObjectFactory.pointer(this); + uniffiTypeGenesisTransactionObjectFactory.freePointer(pointer); + uniffiTypeGenesisTransactionObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is GenesisTransaction { + return uniffiTypeGenesisTransactionObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeGenesisTransactionObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeGenesisTransactionObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): GenesisTransaction { + const instance = Object.create(GenesisTransaction.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'GenesisTransaction'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: GenesisTransaction): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: GenesisTransaction): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_genesistransaction([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_genesistransaction([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is GenesisTransaction { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'GenesisTransaction' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeGenesisTransaction = new FfiConverterObject( + uniffiTypeGenesisTransactionObjectFactory +); + + +export type GraphQlClientInterface = { + +/** + * Get the list of active validators for the provided epoch, including + * related metadata. If no epoch is provided, it will return the active + * validators for the current epoch. + *//* async */ activeValidators(epoch: /*u64*/bigint | undefined, paginationFilter: PaginationFilter | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Get the balance of all the coins owned by address for the provided coin + * type. Coin type will default to `0x2::coin::Coin<0x2::iota::IOTA>` + * if not provided. + *//* async */ balance(address: Address, coinType: string | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Get the chain identifier. + *//* async */ chainId(asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Get the `CheckpointSummary` for a given checkpoint digest or + * checkpoint id. If none is provided, it will use the last known + * checkpoint id. + *//* async */ checkpoint(digest: Digest | undefined, seqNum: /*u64*/bigint | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Get a page of `CheckpointSummary` for the provided parameters. + *//* async */ checkpoints(paginationFilter: PaginationFilter | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Get the coin metadata for the coin type. + *//* async */ coinMetadata(coinType: string, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Get the list of coins for the specified address. + * + * If `coin_type` is not provided, all coins will be returned. For IOTA + * coins, pass in the coin type: `0x2::iota::IOTA`. + *//* async */ coins(owner: Address, paginationFilter: PaginationFilter | undefined, coinType: StructTag | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Dry run a `Transaction` and return the transaction effects and dry run + * error (if any). + * + * `skipChecks` optional flag disables the usual verification checks that + * prevent access to objects that are owned by addresses other than the + * sender, and calling non-public, non-entry functions, and some other + * checks. Defaults to false. + *//* async */ dryRunTx(tx: Transaction, skipChecks: boolean, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Dry run a `TransactionKind` and return the transaction effects and dry + * run error (if any). + * + * `skipChecks` optional flag disables the usual verification checks that + * prevent access to objects that are owned by addresses other than the + * sender, and calling non-public, non-entry functions, and some other + * checks. Defaults to false. + * + * `tx_meta` is the transaction metadata. + *//* async */ dryRunTxKind(txKind: TransactionKind, txMeta: TransactionMetadata, skipChecks: boolean, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Access a dynamic field on an object using its name. Names are arbitrary + * Move values whose type have copy, drop, and store, and are specified + * using their type, and their BCS contents, Base64 encoded. + * + * The `name` argument is a json serialized type. + * + * This returns `DynamicFieldOutput` which contains the name, the value + * as json, and object. + *//* async */ dynamicField(address: Address, typeTag: TypeTag, name: string, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Get a page of dynamic fields for the provided address. Note that this + * will also fetch dynamic fields on wrapped objects. + * + * This returns a page of `DynamicFieldOutput`s. + *//* async */ dynamicFields(address: Address, paginationFilter: PaginationFilter | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Access a dynamic object field on an object using its name. Names are + * arbitrary Move values whose type have copy, drop, and store, and are + * specified using their type, and their BCS contents, Base64 encoded. + * + * The `name` argument is a json serialized type. + * + * This returns `DynamicFieldOutput` which contains the name, the value + * as json, and object. + *//* async */ dynamicObjectField(address: Address, typeTag: TypeTag, name: string, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Return the epoch information for the provided epoch. If no epoch is + * provided, it will return the last known epoch. + *//* async */ epoch(epoch: /*u64*/bigint | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Return the number of checkpoints in this epoch. This will return + * `Ok(None)` if the epoch requested is not available in the GraphQL + * service (e.g., due to pruning). + *//* async */ epochTotalCheckpoints(epoch: /*u64*/bigint | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Return the number of transaction blocks in this epoch. This will return + * `Ok(None)` if the epoch requested is not available in the GraphQL + * service (e.g., due to pruning). + *//* async */ epochTotalTransactionBlocks(epoch: /*u64*/bigint | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Return a page of tuple (event, transaction digest) based on the + * (optional) event filter. + *//* async */ events(filter: EventFilter | undefined, paginationFilter: PaginationFilter | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Execute a transaction. + *//* async */ executeTx(signatures: Array, tx: Transaction, waitFor: WaitForTx | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Get the list of gas coins for the specified address. + *//* async */ gasCoins(owner: Address, paginationFilter: PaginationFilter | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Get the default name pointing to this address, if one exists. + *//* async */ iotaNamesDefaultName(address: Address, format: NameFormat | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Return the resolved address for the given name. + *//* async */ iotaNamesLookup(name: string, asyncOpts_?: { signal: AbortSignal }): Promise
; + +/** + * Find all registration NFTs for the given address. + *//* async */ iotaNamesRegistrations(address: Address, paginationFilter: PaginationFilter, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Returns whether the transaction for the given digest has been included + * in a checkpoint (finalized). + *//* async */ isTxFinalized(digest: Digest, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Returns whether the transaction for the given digest has been indexed + * on the node. This means that it can be queried by its digest and its + * effects will be usable for subsequent transactions. To check for + * full finalization, use `is_tx_finalized`. + *//* async */ isTxIndexedOnNode(digest: Digest, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Return the sequence number of the latest checkpoint that has been + * executed. + *//* async */ latestCheckpointSequenceNumber(asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Lazily fetch the max page size + *//* async */ maxPageSize(asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Return the contents' JSON of an object that is a Move object. + * + * If the object does not exist (e.g., due to pruning), this will return + * `Ok(None)`. Similarly, if this is not an object but an address, it + * will return `Ok(None)`. + *//* async */ moveObjectContents(objectId: ObjectId, version: /*u64*/bigint | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Return the BCS of an object that is a Move object. + * + * If the object does not exist (e.g., due to pruning), this will return + * `Ok(None)`. Similarly, if this is not an object but an address, it + * will return `Ok(None)`. + *//* async */ moveObjectContentsBcs(objectId: ObjectId, version: /*u64*/bigint | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Execute a Move View Function. + * + * A View Function is a function in a Move module with a return type that + * does not alter the state of the ledger. When using this interface, + * no transactions are submitted to the network for inclusion into the + * ledger. + * + * This method allows calling nearly any Move function with a return type + * and any arguments. The function's result values are provided and + * decoded using the appropriate Move type, then formatted in JSON. + * + * The use of this interface does not require signature checks (even for + * functions that take Owned Objects as input) or gas coins, as it does + * not alter ledger state. Spam attacks are dealt with at the RPC level + * rather than execution level. + * + * # Arguments + * * `function_name` - The Move function fully qualified name as + * `::::`, e.g., + * `0x2::hash::blake2b256` + * * `type_arguments` - The type arguments of the Move function + * * `arguments` - The typed arguments to be passed into the Move function + * + * # Returns + * A `MoveViewResult` containing either execution results (return values) + * or an error. + *//* async */ moveViewCall(functionName: string, typeArguments: Array | undefined, arguments_: Array | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Execute a Move View Function with raw JSON arguments. + * + * This is an alternative to [`GraphQLClient::move_view_call`] that accepts + * raw JSON values instead of typed arguments. + * + * A View Function is a function in a Move module with a return type that + * does not alter the state of the ledger. When using this interface, + * no transactions are submitted to the network for inclusion into the + * ledger. + * + * # Arguments + * * `function_name` - The Move function fully qualified name as + * `::::`, e.g., + * `0x2::hash::blake2b256` + * * `type_arguments` - The type arguments of the Move function + * * `arguments` - The arguments to be passed into the Move function, in + * JSON format + * + * # Returns + * A `MoveViewResult` containing either execution results (return values) + * or an error. + *//* async */ moveViewCallJson(functionName: string, typeArguments: Array | undefined, arguments_: Array | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Return the normalized Move function data for the provided package, + * module, and function. + *//* async */ normalizedMoveFunction(package_: Address, module: string, function_: string, version: /*u64*/bigint | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Return the normalized Move module data for the provided module. + *//* async */ normalizedMoveModule(package_: Address, module: string, version: /*u64*/bigint | undefined, paginationFilterEnums: PaginationFilter | undefined, paginationFilterFriends: PaginationFilter | undefined, paginationFilterFunctions: PaginationFilter | undefined, paginationFilterStructs: PaginationFilter | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Return an object based on the provided `Address`. + * + * If the object does not exist (e.g., due to pruning), this will return + * `Ok(None)`. Similarly, if this is not an object but an address, it + * will return `Ok(None)`. + *//* async */ object(objectId: ObjectId, version: /*u64*/bigint | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Return the object's bcs content `Vec` based on the provided + * `Address`. + *//* async */ objectBcs(objectId: ObjectId, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Return a page of objects based on the provided parameters. + * + * Use this function together with the `ObjectFilter::owner` to get the + * objects owned by an address. + *//* async */ objects(filter: ObjectFilter | undefined, paginationFilter: PaginationFilter | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * The package corresponding to the given address (at the optionally given + * version). When no version is given, the package is loaded directly + * from the address given. Otherwise, the address is translated before + * loading to point to the package whose original ID matches + * the package at address, but whose version is version. For non-system + * packages, this might result in a different address than address + * because different versions of a package, introduced by upgrades, + * exist at distinct addresses. + * + * Note that this interpretation of version is different from a historical + * object read (the interpretation of version for the object query). + *//* async */ package_(address: Address, version: /*u64*/bigint | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Fetch the latest version of the package at address. + * This corresponds to the package with the highest version that shares its + * original ID with the package at address. + *//* async */ packageLatest(address: Address, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Fetch all versions of package at address (packages that share this + * package's original ID), optionally bounding the versions exclusively + * from below with afterVersion, or from above with beforeVersion. + *//* async */ packageVersions(address: Address, afterVersion: /*u64*/bigint | undefined, beforeVersion: /*u64*/bigint | undefined, paginationFilter: PaginationFilter | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * The Move packages that exist in the network, optionally filtered to be + * strictly before beforeCheckpoint and/or strictly after + * afterCheckpoint. + * + * This query returns all versions of a given user package that appear + * between the specified checkpoints, but only records the latest + * versions of system packages. + *//* async */ packages(afterCheckpoint: /*u64*/bigint | undefined, beforeCheckpoint: /*u64*/bigint | undefined, paginationFilter: PaginationFilter | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Get the protocol configuration. + *//* async */ protocolConfig(version: /*u64*/bigint | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Get the reference gas price for the provided epoch or the last known one + * if no epoch is provided. + * + * This will return `Ok(None)` if the epoch requested is not available in + * the GraphQL service (e.g., due to pruning). + *//* async */ referenceGasPrice(epoch: /*u64*/bigint | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Run a query. + *//* async */ runQuery(query: Query, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Get the GraphQL service configuration, including complexity limits, read + * and mutation limits, supported versions, and others. + *//* async */ serviceConfig(asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Set the server address for the GraphQL client. It should be a + * valid URL with a host and optionally a port number. + *//* async */ setRpcServer(server: string, asyncOpts_?: { signal: AbortSignal }): void; + +/** + * Get total supply for the coin type. + *//* async */ totalSupply(coinType: string, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * The total number of transaction blocks in the network by the end of the + * last known checkpoint. + *//* async */ totalTransactionBlocks(asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * The total number of transaction blocks in the network by the end of the + * provided checkpoint digest. + *//* async */ totalTransactionBlocksByDigest(digest: Digest, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * The total number of transaction blocks in the network by the end of the + * provided checkpoint sequence number. + *//* async */ totalTransactionBlocksBySeqNum(seqNum: /*u64*/bigint, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Get a transaction by its digest. + *//* async */ transaction(digest: Digest, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Get a transaction's data and effects by its digest. + *//* async */ transactionDataEffects(digest: Digest, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Get a transaction's effects by its digest. + *//* async */ transactionEffects(digest: Digest, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Get a page of transactions based on the provided filters. + *//* async */ transactions(filter: TransactionsFilter | undefined, paginationFilter: PaginationFilter | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Get a page of transactions' data and effects based on the provided + * filters. + *//* async */ transactionsDataEffects(filter: TransactionsFilter | undefined, paginationFilter: PaginationFilter | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Get a page of transactions' effects based on the provided filters. + *//* async */ transactionsEffects(filter: TransactionsFilter | undefined, paginationFilter: PaginationFilter | undefined, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Wait for the indexing (on the node, not the indexer) or finalization of + * a transaction by its digest. An optional timeout can be provided, + * which, if exceeded, will return an error (default 60s). + *//* async */ waitForTx(digest: Digest, waitFor: WaitForTx, timeout: number /* in milliseconds */ | undefined, asyncOpts_?: { signal: AbortSignal }): void; + +}; + + +/** + * The GraphQL client for interacting with the IOTA blockchain. + */ +export class GraphQlClient extends UniffiAbstractObject implements GraphQlClientInterface { + readonly [uniffiTypeNameSymbol] = 'GraphQLClient'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + +/** + * Create a new GraphQL client with the provided server address. + */ + constructor(server: string) { + super(); + + let serverArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(server)).toStruct(); + const pointer =uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_graphqlclient_new([ + serverArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeGraphQlClientObjectFactory.bless(pointer); + } +/** + * Create a new GraphQL client connected to the `devnet` GraphQL server: + * {DEVNET_HOST}. + */ + + static newDevnet(): GraphQlClient { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_graphqlclient_new_devnet([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeGraphQlClient.lift(returnValue); + } +/** + * Create a new GraphQL client connected to the `localhost` GraphQL server: + * {DEFAULT_LOCAL_HOST}. + */ + + static newLocalnet(): GraphQlClient { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_graphqlclient_new_localnet([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeGraphQlClient.lift(returnValue); + } +/** + * Create a new GraphQL client connected to the `mainnet` GraphQL server: + * {MAINNET_HOST}. + */ + + static newMainnet(): GraphQlClient { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_graphqlclient_new_mainnet([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeGraphQlClient.lift(returnValue); + } +/** + * Create a new GraphQL client connected to the `testnet` GraphQL server: + * {TESTNET_HOST}. + */ + + static newTestnet(): GraphQlClient { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_graphqlclient_new_testnet([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeGraphQlClient.lift(returnValue); + }// Methods: + + +/** + * Get the list of active validators for the provided epoch, including + * related metadata. If no epoch is provided, it will return the active + * validators for the current epoch. + */async activeValidators(epoch: /*u64*/bigint | undefined, paginationFilter: PaginationFilter | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let epochArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterUInt64).lower(epoch)).toStruct(); + let paginationFilterArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypePaginationFilter).lower(paginationFilter)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_active_validators([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), epochArg, paginationFilterArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeValidatorPage.lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Get the balance of all the coins owned by address for the provided coin + * type. Coin type will default to `0x2::coin::Coin<0x2::iota::IOTA>` + * if not provided. + */async balance(address: Address, coinType: string | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let addressArg = FfiConverterTypeAddress.lower(address); + let coinTypeArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterString).lower(coinType)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_balance([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), addressArg, coinTypeArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterUInt64).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Get the chain identifier. + */async chainId(asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_chain_id([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this) + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterString.lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Get the `CheckpointSummary` for a given checkpoint digest or + * checkpoint id. If none is provided, it will use the last known + * checkpoint id. + */async checkpoint(digest: Digest | undefined, seqNum: /*u64*/bigint | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let digestArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypeDigest).lower(digest)).toStruct(); + let seqNumArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterUInt64).lower(seqNum)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_checkpoint([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), digestArg, seqNumArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterTypeCheckpointSummary).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Get a page of `CheckpointSummary` for the provided parameters. + */async checkpoints(paginationFilter: PaginationFilter | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let paginationFilterArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypePaginationFilter).lower(paginationFilter)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_checkpoints([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), paginationFilterArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeCheckpointSummaryPage.lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Get the coin metadata for the coin type. + */async coinMetadata(coinType: string, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let coinTypeArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(coinType)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_coin_metadata([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), coinTypeArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterTypeCoinMetadata).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Get the list of coins for the specified address. + * + * If `coin_type` is not provided, all coins will be returned. For IOTA + * coins, pass in the coin type: `0x2::iota::IOTA`. + */async coins(owner: Address, paginationFilter: PaginationFilter | undefined, coinType: StructTag | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let ownerArg = FfiConverterTypeAddress.lower(owner); + let paginationFilterArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypePaginationFilter).lower(paginationFilter)).toStruct(); + let coinTypeArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypeStructTag).lower(coinType)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_coins([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), ownerArg, paginationFilterArg, coinTypeArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeCoinPage.lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Dry run a `Transaction` and return the transaction effects and dry run + * error (if any). + * + * `skipChecks` optional flag disables the usual verification checks that + * prevent access to objects that are owned by addresses other than the + * sender, and calling non-public, non-entry functions, and some other + * checks. Defaults to false. + */async dryRunTx(tx: Transaction, skipChecks: boolean, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let txArg = FfiConverterTypeTransaction.lower(tx); + let skipChecksArg = FfiConverterBool.lower(skipChecks); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_dry_run_tx([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), txArg, skipChecksArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeDryRunResult.lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Dry run a `TransactionKind` and return the transaction effects and dry + * run error (if any). + * + * `skipChecks` optional flag disables the usual verification checks that + * prevent access to objects that are owned by addresses other than the + * sender, and calling non-public, non-entry functions, and some other + * checks. Defaults to false. + * + * `tx_meta` is the transaction metadata. + */async dryRunTxKind(txKind: TransactionKind, txMeta: TransactionMetadata, skipChecks: boolean, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let txKindArg = FfiConverterTypeTransactionKind.lower(txKind); + let txMetaArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeTransactionMetadata.lower(txMeta)).toStruct(); + let skipChecksArg = FfiConverterBool.lower(skipChecks); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_dry_run_tx_kind([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), txKindArg, txMetaArg, skipChecksArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeDryRunResult.lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Access a dynamic field on an object using its name. Names are arbitrary + * Move values whose type have copy, drop, and store, and are specified + * using their type, and their BCS contents, Base64 encoded. + * + * The `name` argument is a json serialized type. + * + * This returns `DynamicFieldOutput` which contains the name, the value + * as json, and object. + */async dynamicField(address: Address, typeTag: TypeTag, name: string, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let addressArg = FfiConverterTypeAddress.lower(address); + let typeTagArg = FfiConverterTypeTypeTag.lower(typeTag); + let nameArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(name)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_dynamic_field([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), addressArg, typeTagArg, nameArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterTypeDynamicFieldOutput).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Get a page of dynamic fields for the provided address. Note that this + * will also fetch dynamic fields on wrapped objects. + * + * This returns a page of `DynamicFieldOutput`s. + */async dynamicFields(address: Address, paginationFilter: PaginationFilter | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let addressArg = FfiConverterTypeAddress.lower(address); + let paginationFilterArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypePaginationFilter).lower(paginationFilter)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_dynamic_fields([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), addressArg, paginationFilterArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeDynamicFieldOutputPage.lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Access a dynamic object field on an object using its name. Names are + * arbitrary Move values whose type have copy, drop, and store, and are + * specified using their type, and their BCS contents, Base64 encoded. + * + * The `name` argument is a json serialized type. + * + * This returns `DynamicFieldOutput` which contains the name, the value + * as json, and object. + */async dynamicObjectField(address: Address, typeTag: TypeTag, name: string, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let addressArg = FfiConverterTypeAddress.lower(address); + let typeTagArg = FfiConverterTypeTypeTag.lower(typeTag); + let nameArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(name)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_dynamic_object_field([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), addressArg, typeTagArg, nameArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterTypeDynamicFieldOutput).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Return the epoch information for the provided epoch. If no epoch is + * provided, it will return the last known epoch. + */async epoch(epoch: /*u64*/bigint | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let epochArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterUInt64).lower(epoch)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_epoch([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), epochArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterTypeEpoch).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Return the number of checkpoints in this epoch. This will return + * `Ok(None)` if the epoch requested is not available in the GraphQL + * service (e.g., due to pruning). + */async epochTotalCheckpoints(epoch: /*u64*/bigint | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let epochArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterUInt64).lower(epoch)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_epoch_total_checkpoints([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), epochArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterUInt64).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Return the number of transaction blocks in this epoch. This will return + * `Ok(None)` if the epoch requested is not available in the GraphQL + * service (e.g., due to pruning). + */async epochTotalTransactionBlocks(epoch: /*u64*/bigint | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let epochArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterUInt64).lower(epoch)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_epoch_total_transaction_blocks([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), epochArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterUInt64).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Return a page of tuple (event, transaction digest) based on the + * (optional) event filter. + */async events(filter: EventFilter | undefined, paginationFilter: PaginationFilter | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let filterArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypeEventFilter).lower(filter)).toStruct(); + let paginationFilterArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypePaginationFilter).lower(paginationFilter)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_events([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), filterArg, paginationFilterArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeEventPage.lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Execute a transaction. + */async executeTx(signatures: Array, tx: Transaction, waitFor: WaitForTx | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let signaturesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeUserSignature)).lower(signatures)).toStruct(); + let txArg = FfiConverterTypeTransaction.lower(tx); + let waitForArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypeWaitForTx).lower(waitFor)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_execute_tx([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), signaturesArg, txArg, waitForArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_pointer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_pointer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_pointer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_pointer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeTransactionEffects.lift(value), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Get the list of gas coins for the specified address. + */async gasCoins(owner: Address, paginationFilter: PaginationFilter | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let ownerArg = FfiConverterTypeAddress.lower(owner); + let paginationFilterArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypePaginationFilter).lower(paginationFilter)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_gas_coins([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), ownerArg, paginationFilterArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeCoinPage.lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Get the default name pointing to this address, if one exists. + */async iotaNamesDefaultName(address: Address, format: NameFormat | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let addressArg = FfiConverterTypeAddress.lower(address); + let formatArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypeNameFormat).lower(format)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_iota_names_default_name([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), addressArg, formatArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterTypeName).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Return the resolved address for the given name. + */async iotaNamesLookup(name: string, asyncOpts_?: { signal: AbortSignal }): Promise
{ + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let nameArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(name)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_iota_names_lookup([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), nameArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterTypeAddress).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Find all registration NFTs for the given address. + */async iotaNamesRegistrations(address: Address, paginationFilter: PaginationFilter, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let addressArg = FfiConverterTypeAddress.lower(address); + let paginationFilterArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypePaginationFilter.lower(paginationFilter)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_iota_names_registrations([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), addressArg, paginationFilterArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeNameRegistrationPage.lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Returns whether the transaction for the given digest has been included + * in a checkpoint (finalized). + */async isTxFinalized(digest: Digest, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let digestArg = FfiConverterTypeDigest.lower(digest); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_is_tx_finalized([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), digestArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_i8([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_i8([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_i8([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_i8([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterBool.lift(value), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Returns whether the transaction for the given digest has been indexed + * on the node. This means that it can be queried by its digest and its + * effects will be usable for subsequent transactions. To check for + * full finalization, use `is_tx_finalized`. + */async isTxIndexedOnNode(digest: Digest, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let digestArg = FfiConverterTypeDigest.lower(digest); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_is_tx_indexed_on_node([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), digestArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_i8([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_i8([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_i8([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_i8([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterBool.lift(value), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Return the sequence number of the latest checkpoint that has been + * executed. + */async latestCheckpointSequenceNumber(asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_latest_checkpoint_sequence_number([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this) + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterUInt64).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Lazily fetch the max page size + */async maxPageSize(asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_max_page_size([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this) + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_i32([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_i32([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_i32([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_i32([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterInt32.lift(value), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Return the contents' JSON of an object that is a Move object. + * + * If the object does not exist (e.g., due to pruning), this will return + * `Ok(None)`. Similarly, if this is not an object but an address, it + * will return `Ok(None)`. + */async moveObjectContents(objectId: ObjectId, version: /*u64*/bigint | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let objectIdArg = FfiConverterTypeObjectId.lower(objectId); + let versionArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterUInt64).lower(version)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_move_object_contents([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), objectIdArg, versionArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterString).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Return the BCS of an object that is a Move object. + * + * If the object does not exist (e.g., due to pruning), this will return + * `Ok(None)`. Similarly, if this is not an object but an address, it + * will return `Ok(None)`. + */async moveObjectContentsBcs(objectId: ObjectId, version: /*u64*/bigint | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let objectIdArg = FfiConverterTypeObjectId.lower(objectId); + let versionArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterUInt64).lower(version)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_move_object_contents_bcs([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), objectIdArg, versionArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterArrayBuffer).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Execute a Move View Function. + * + * A View Function is a function in a Move module with a return type that + * does not alter the state of the ledger. When using this interface, + * no transactions are submitted to the network for inclusion into the + * ledger. + * + * This method allows calling nearly any Move function with a return type + * and any arguments. The function's result values are provided and + * decoded using the appropriate Move type, then formatted in JSON. + * + * The use of this interface does not require signature checks (even for + * functions that take Owned Objects as input) or gas coins, as it does + * not alter ledger state. Spam attacks are dealt with at the RPC level + * rather than execution level. + * + * # Arguments + * * `function_name` - The Move function fully qualified name as + * `::::`, e.g., + * `0x2::hash::blake2b256` + * * `type_arguments` - The type arguments of the Move function + * * `arguments` - The typed arguments to be passed into the Move function + * + * # Returns + * A `MoveViewResult` containing either execution results (return values) + * or an error. + */async moveViewCall(functionName: string, typeArguments: Array | undefined, arguments_: Array | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let functionNameArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(functionName)).toStruct(); + let typeArgumentsArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeTypeTag))).lower(typeArguments)).toStruct(); + let arguments_Arg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeMoveViewArg))).lower(arguments_)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_move_view_call([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), functionNameArg, typeArgumentsArg, arguments_Arg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeMoveViewResult.lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Execute a Move View Function with raw JSON arguments. + * + * This is an alternative to [`GraphQLClient::move_view_call`] that accepts + * raw JSON values instead of typed arguments. + * + * A View Function is a function in a Move module with a return type that + * does not alter the state of the ledger. When using this interface, + * no transactions are submitted to the network for inclusion into the + * ledger. + * + * # Arguments + * * `function_name` - The Move function fully qualified name as + * `::::`, e.g., + * `0x2::hash::blake2b256` + * * `type_arguments` - The type arguments of the Move function + * * `arguments` - The arguments to be passed into the Move function, in + * JSON format + * + * # Returns + * A `MoveViewResult` containing either execution results (return values) + * or an error. + */async moveViewCallJson(functionName: string, typeArguments: Array | undefined, arguments_: Array | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let functionNameArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(functionName)).toStruct(); + let typeArgumentsArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional((new FfiConverterArray(FfiConverterString))).lower(typeArguments)).toStruct(); + let arguments_Arg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional((new FfiConverterArray(FfiConverterString))).lower(arguments_)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_move_view_call_json([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), functionNameArg, typeArgumentsArg, arguments_Arg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeMoveViewResult.lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Return the normalized Move function data for the provided package, + * module, and function. + */async normalizedMoveFunction(package_: Address, module: string, function_: string, version: /*u64*/bigint | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let package_Arg = FfiConverterTypeAddress.lower(package_); + let moduleArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(module)).toStruct(); + let function_Arg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(function_)).toStruct(); + let versionArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterUInt64).lower(version)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_normalized_move_function([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), package_Arg, moduleArg, function_Arg, versionArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterTypeMoveFunction).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Return the normalized Move module data for the provided module. + */async normalizedMoveModule(package_: Address, module: string, version: /*u64*/bigint | undefined, paginationFilterEnums: PaginationFilter | undefined, paginationFilterFriends: PaginationFilter | undefined, paginationFilterFunctions: PaginationFilter | undefined, paginationFilterStructs: PaginationFilter | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let package_Arg = FfiConverterTypeAddress.lower(package_); + let moduleArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(module)).toStruct(); + let versionArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterUInt64).lower(version)).toStruct(); + let paginationFilterEnumsArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypePaginationFilter).lower(paginationFilterEnums)).toStruct(); + let paginationFilterFriendsArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypePaginationFilter).lower(paginationFilterFriends)).toStruct(); + let paginationFilterFunctionsArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypePaginationFilter).lower(paginationFilterFunctions)).toStruct(); + let paginationFilterStructsArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypePaginationFilter).lower(paginationFilterStructs)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_normalized_move_module([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), package_Arg, moduleArg, versionArg, paginationFilterEnumsArg, paginationFilterFriendsArg, paginationFilterFunctionsArg, paginationFilterStructsArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterTypeMoveModule).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Return an object based on the provided `Address`. + * + * If the object does not exist (e.g., due to pruning), this will return + * `Ok(None)`. Similarly, if this is not an object but an address, it + * will return `Ok(None)`. + */async object(objectId: ObjectId, version: /*u64*/bigint | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let objectIdArg = FfiConverterTypeObjectId.lower(objectId); + let versionArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterUInt64).lower(version)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_object([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), objectIdArg, versionArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterTypeObject).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Return the object's bcs content `Vec` based on the provided + * `Address`. + */async objectBcs(objectId: ObjectId, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let objectIdArg = FfiConverterTypeObjectId.lower(objectId); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_object_bcs([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), objectIdArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterArrayBuffer).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Return a page of objects based on the provided parameters. + * + * Use this function together with the `ObjectFilter::owner` to get the + * objects owned by an address. + */async objects(filter: ObjectFilter | undefined, paginationFilter: PaginationFilter | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let filterArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypeObjectFilter).lower(filter)).toStruct(); + let paginationFilterArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypePaginationFilter).lower(paginationFilter)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_objects([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), filterArg, paginationFilterArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeObjectPage.lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * The package corresponding to the given address (at the optionally given + * version). When no version is given, the package is loaded directly + * from the address given. Otherwise, the address is translated before + * loading to point to the package whose original ID matches + * the package at address, but whose version is version. For non-system + * packages, this might result in a different address than address + * because different versions of a package, introduced by upgrades, + * exist at distinct addresses. + * + * Note that this interpretation of version is different from a historical + * object read (the interpretation of version for the object query). + */async package_(address: Address, version: /*u64*/bigint | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let addressArg = FfiConverterTypeAddress.lower(address); + let versionArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterUInt64).lower(version)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_package([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), addressArg, versionArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterTypeMovePackage).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Fetch the latest version of the package at address. + * This corresponds to the package with the highest version that shares its + * original ID with the package at address. + */async packageLatest(address: Address, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let addressArg = FfiConverterTypeAddress.lower(address); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_package_latest([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), addressArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterTypeMovePackage).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Fetch all versions of package at address (packages that share this + * package's original ID), optionally bounding the versions exclusively + * from below with afterVersion, or from above with beforeVersion. + */async packageVersions(address: Address, afterVersion: /*u64*/bigint | undefined, beforeVersion: /*u64*/bigint | undefined, paginationFilter: PaginationFilter | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let addressArg = FfiConverterTypeAddress.lower(address); + let afterVersionArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterUInt64).lower(afterVersion)).toStruct(); + let beforeVersionArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterUInt64).lower(beforeVersion)).toStruct(); + let paginationFilterArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypePaginationFilter).lower(paginationFilter)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_package_versions([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), addressArg, afterVersionArg, beforeVersionArg, paginationFilterArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeMovePackagePage.lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * The Move packages that exist in the network, optionally filtered to be + * strictly before beforeCheckpoint and/or strictly after + * afterCheckpoint. + * + * This query returns all versions of a given user package that appear + * between the specified checkpoints, but only records the latest + * versions of system packages. + */async packages(afterCheckpoint: /*u64*/bigint | undefined, beforeCheckpoint: /*u64*/bigint | undefined, paginationFilter: PaginationFilter | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let afterCheckpointArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterUInt64).lower(afterCheckpoint)).toStruct(); + let beforeCheckpointArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterUInt64).lower(beforeCheckpoint)).toStruct(); + let paginationFilterArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypePaginationFilter).lower(paginationFilter)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_packages([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), afterCheckpointArg, beforeCheckpointArg, paginationFilterArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeMovePackagePage.lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Get the protocol configuration. + */async protocolConfig(version: /*u64*/bigint | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let versionArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterUInt64).lower(version)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_protocol_config([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), versionArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeProtocolConfigs.lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Get the reference gas price for the provided epoch or the last known one + * if no epoch is provided. + * + * This will return `Ok(None)` if the epoch requested is not available in + * the GraphQL service (e.g., due to pruning). + */async referenceGasPrice(epoch: /*u64*/bigint | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let epochArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterUInt64).lower(epoch)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_reference_gas_price([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), epochArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterUInt64).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Run a query. + */async runQuery(query: Query, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let queryArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeQuery.lower(query)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_run_query([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), queryArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterString.lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Get the GraphQL service configuration, including complexity limits, read + * and mutation limits, supported versions, and others. + */async serviceConfig(asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_service_config([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this) + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeServiceConfig.lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Set the server address for the GraphQL client. It should be a + * valid URL with a host and optionally a port number. + */async setRpcServer(server: string, asyncOpts_?: { signal: AbortSignal }): void { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let serverArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(server)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_set_rpc_server([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), serverArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_void([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_void([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_void([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_void([handle]) + }, + + /*liftFunc:*/ (_v) => { /* void return value */ }, + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Get total supply for the coin type. + */async totalSupply(coinType: string, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let coinTypeArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(coinType)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_total_supply([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), coinTypeArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterUInt64).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * The total number of transaction blocks in the network by the end of the + * last known checkpoint. + */async totalTransactionBlocks(asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_total_transaction_blocks([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this) + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterUInt64).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * The total number of transaction blocks in the network by the end of the + * provided checkpoint digest. + */async totalTransactionBlocksByDigest(digest: Digest, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let digestArg = FfiConverterTypeDigest.lower(digest); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_total_transaction_blocks_by_digest([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), digestArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterUInt64).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * The total number of transaction blocks in the network by the end of the + * provided checkpoint sequence number. + */async totalTransactionBlocksBySeqNum(seqNum: /*u64*/bigint, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let seqNumArg = FfiConverterUInt64.lower(seqNum); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_total_transaction_blocks_by_seq_num([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), seqNumArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterUInt64).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Get a transaction by its digest. + */async transaction(digest: Digest, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let digestArg = FfiConverterTypeDigest.lower(digest); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_transaction([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), digestArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterTypeSignedTransaction).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Get a transaction's data and effects by its digest. + */async transactionDataEffects(digest: Digest, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let digestArg = FfiConverterTypeDigest.lower(digest); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_transaction_data_effects([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), digestArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterTypeTransactionDataEffects).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Get a transaction's effects by its digest. + */async transactionEffects(digest: Digest, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let digestArg = FfiConverterTypeDigest.lower(digest); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_transaction_effects([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), digestArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => new FfiConverterOptional(FfiConverterTypeTransactionEffects).lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Get a page of transactions based on the provided filters. + */async transactions(filter: TransactionsFilter | undefined, paginationFilter: PaginationFilter | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let filterArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypeTransactionsFilter).lower(filter)).toStruct(); + let paginationFilterArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypePaginationFilter).lower(paginationFilter)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_transactions([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), filterArg, paginationFilterArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeSignedTransactionPage.lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Get a page of transactions' data and effects based on the provided + * filters. + */async transactionsDataEffects(filter: TransactionsFilter | undefined, paginationFilter: PaginationFilter | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let filterArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypeTransactionsFilter).lower(filter)).toStruct(); + let paginationFilterArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypePaginationFilter).lower(paginationFilter)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_transactions_data_effects([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), filterArg, paginationFilterArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeTransactionDataEffectsPage.lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Get a page of transactions' effects based on the provided filters. + */async transactionsEffects(filter: TransactionsFilter | undefined, paginationFilter: PaginationFilter | undefined, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let filterArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypeTransactionsFilter).lower(filter)).toStruct(); + let paginationFilterArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypePaginationFilter).lower(paginationFilter)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_transactions_effects([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), filterArg, paginationFilterArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeTransactionEffectsPage.lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Wait for the indexing (on the node, not the indexer) or finalization of + * a transaction by its digest. An optional timeout can be provided, + * which, if exceeded, will return an error (default 60s). + */async waitForTx(digest: Digest, waitFor: WaitForTx, timeout: number /* in milliseconds */ | undefined, asyncOpts_?: { signal: AbortSignal }): void { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let digestArg = FfiConverterTypeDigest.lower(digest); + let waitForArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeWaitForTx.lower(waitFor)).toStruct(); + let timeoutArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterDuration).lower(timeout)).toStruct(); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_graphqlclient_wait_for_tx([ + uniffiTypeGraphQlClientObjectFactory.clonePointer(this), digestArg, waitForArg, timeoutArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_void([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_void([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_void([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_void([handle]) + }, + + /*liftFunc:*/ (_v) => { /* void return value */ }, + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + + // UniffiTrait implementations: + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeGraphQlClientObjectFactory.pointer(this); + uniffiTypeGraphQlClientObjectFactory.freePointer(pointer); + uniffiTypeGraphQlClientObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is GraphQlClient { + return uniffiTypeGraphQlClientObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeGraphQlClientObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeGraphQlClientObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): GraphQlClient { + const instance = Object.create(GraphQlClient.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'GraphQLClient'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: GraphQlClient): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: GraphQlClient): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_graphqlclient([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_graphqlclient([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is GraphQlClient { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'GraphQLClient' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeGraphQlClient = new FfiConverterObject( + uniffiTypeGraphQlClientObjectFactory +); + + +export type IdentifierInterface = { + asStr(): string; + +}; + + +/** + * A move identifier + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * identifier = %x01-80 ; length of the identifier + * (ALPHA *127(ALPHA / DIGIT / UNDERSCORE)) / + * (UNDERSCORE 1*127(ALPHA / DIGIT / UNDERSCORE)) + * + * UNDERSCORE = %x95 + * ``` + */ +export class Identifier extends UniffiAbstractObject implements IdentifierInterface { + readonly [uniffiTypeNameSymbol] = 'Identifier'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(identifier: string) { + super(); + + let identifierArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(identifier)).toStruct(); + const pointer =uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_identifier_new([ + identifierArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeIdentifierObjectFactory.bless(pointer); + }// Methods: + + asStr(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_identifier_as_str([ + uniffiTypeIdentifierObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + toString(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_identifier_uniffi_trait_display([ + uniffiTypeIdentifierObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeIdentifierObjectFactory.pointer(this); + uniffiTypeIdentifierObjectFactory.freePointer(pointer); + uniffiTypeIdentifierObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Identifier { + return uniffiTypeIdentifierObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeIdentifierObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeIdentifierObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Identifier { + const instance = Object.create(Identifier.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Identifier'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Identifier): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Identifier): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_identifier([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_identifier([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Identifier { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Identifier' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeIdentifier = new FfiConverterObject( + uniffiTypeIdentifierObjectFactory +); + + +export type InputInterface = { + +}; + + +/** + * An input to a user transaction + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * input = input-pure / input-immutable-or-owned / input-shared / input-receiving + * + * input-pure = %x00 bytes + * input-immutable-or-owned = %x01 object-ref + * input-shared = %x02 object-id u64 bool + * input-receiving = %x04 object-ref + * ``` + */ +export class Input extends UniffiAbstractObject implements InputInterface { + readonly [uniffiTypeNameSymbol] = 'Input'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + +/** + * A move object that is either immutable or address owned + */ + + static newImmutableOrOwned(objectRef: ObjectReference): Input { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let objectRefArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeObjectReference.lower(objectRef)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_input_new_immutable_or_owned([ + objectRefArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeInput.lift(returnValue); + } +/** + * For normal operations this is required to be a move primitive type and + * not contain structs or objects. + */ + + static newPure(value: ArrayBuffer): Input { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valueArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(value)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_input_new_pure([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeInput.lift(returnValue); + } + + static newReceiving(objectRef: ObjectReference): Input { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let objectRefArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeObjectReference.lower(objectRef)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_input_new_receiving([ + objectRefArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeInput.lift(returnValue); + } +/** + * A move object whose owner is "Shared" + */ + + static newShared(objectId: ObjectId, initialSharedVersion: /*u64*/bigint, mutable: boolean): Input { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let objectIdArg = FfiConverterTypeObjectId.lower(objectId); + let initialSharedVersionArg = FfiConverterUInt64.lower(initialSharedVersion); + let mutableArg = FfiConverterBool.lower(mutable); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_input_new_shared([ + objectIdArg, initialSharedVersionArg, mutableArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeInput.lift(returnValue); + }// Methods: + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeInputObjectFactory.pointer(this); + uniffiTypeInputObjectFactory.freePointer(pointer); + uniffiTypeInputObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Input { + return uniffiTypeInputObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeInputObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeInputObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Input { + const instance = Object.create(Input.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Input'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Input): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Input): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_input([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_input([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Input { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Input' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeInput = new FfiConverterObject( + uniffiTypeInputObjectFactory +); + + +export type IntentInterface = { + +/** + * Get the app id of the signing intent. + */appId(): IntentAppId; + +/** + * Get the scope of the signing intent. + */scope(): IntentScope; + +/** + * Convert the signing intent to bytes. + */toBytes(): ArrayBuffer; + +/** + * Get the version of the signing intent. + */version(): IntentVersion; + +}; + + +/** + * A Signing Intent + * + * An intent is a compact struct that serves as the domain separator for a + * message that a signature commits to. It consists of three parts: + * 1. IntentScope (what the type of the message is) + * 2. IntentVersion + * 3. IntentAppId (what application the signature refers to). + * + * The serialization of an Intent is a 3-byte array where each field is + * represented by a byte and it is prepended onto a message before it is signed + * in IOTA. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * intent = intent-scope intent-version intent-app-id + * ``` + */ +export class Intent extends UniffiAbstractObject implements IntentInterface { + readonly [uniffiTypeNameSymbol] = 'Intent'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + +/** + * Create a signing intent from bytes. + */ + + static fromBytes(bytes: ArrayBuffer): Intent { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["IntentError", FfiConverterTypeIntentError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_intent_from_bytes([ + bytesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeIntent.lift(returnValue); + } +/** + * Create a signing intent from a hex string. + */ + + static fromHex(hex: string): Intent { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["IntentError", FfiConverterTypeIntentError.lift(buffer)], + /*caller:*/ (callStatus) => { + let hexArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(hex)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_intent_from_hex([ + hexArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeIntent.lift(returnValue); + } +/** + * Create a new signing intent. + */ + constructor(scope: IntentScope, version: IntentVersion, appId: IntentAppId) { + super(); + + let scopeArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeIntentScope.lower(scope)).toStruct(); + let versionArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeIntentVersion.lower(version)).toStruct(); + let appIdArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeIntentAppId.lower(appId)).toStruct(); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_intent_new([ + scopeArg, versionArg, appIdArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeIntentObjectFactory.bless(pointer); + } +/** + * Create a new Consensus app signing intent. + */ + + static newConsensusApp(scope: IntentScope): Intent { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let scopeArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeIntentScope.lower(scope)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_intent_new_consensus_app([ + scopeArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeIntent.lift(returnValue); + } +/** + * Create a new IOTA app signing intent. + */ + + static newIotaApp(scope: IntentScope): Intent { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let scopeArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeIntentScope.lower(scope)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_intent_new_iota_app([ + scopeArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeIntent.lift(returnValue); + } +/** + * Create a new IOTA transaction signing intent. + */ + + static newIotaTransaction(): Intent { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_intent_new_iota_transaction([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeIntent.lift(returnValue); + } +/** + * Create a new IOTA personal message signing intent. + */ + + static newPersonalMessage(): Intent { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_intent_new_personal_message([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeIntent.lift(returnValue); + }// Methods: + + +/** + * Get the app id of the signing intent. + */appId(): IntentAppId { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_intent_app_id([ + uniffiTypeIntentObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeIntentAppId.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Get the scope of the signing intent. + */scope(): IntentScope { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_intent_scope([ + uniffiTypeIntentObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeIntentScope.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Convert the signing intent to bytes. + */toBytes(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_intent_to_bytes([ + uniffiTypeIntentObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Get the version of the signing intent. + */version(): IntentVersion { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_intent_version([ + uniffiTypeIntentObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeIntentVersion.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeIntentObjectFactory.pointer(this); + uniffiTypeIntentObjectFactory.freePointer(pointer); + uniffiTypeIntentObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Intent { + return uniffiTypeIntentObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeIntentObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeIntentObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Intent { + const instance = Object.create(Intent.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Intent'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Intent): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Intent): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_intent([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_intent([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Intent { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Intent' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeIntent = new FfiConverterObject( + uniffiTypeIntentObjectFactory +); + + +export type MakeMoveVectorInterface = { + +/** + * The set individual elements to build the vector with + */elements(): Array; + +/** + * Type of the individual elements + * + * This is required to be set when the type can't be inferred, for example + * when the set of provided arguments are all pure input values. + */typeTag(): TypeTag | undefined; + +}; + + +/** + * Command to build a move vector out of a set of individual elements + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * make-move-vector = (option type-tag) (vector argument) + * ``` + */ +export class MakeMoveVector extends UniffiAbstractObject implements MakeMoveVectorInterface { + readonly [uniffiTypeNameSymbol] = 'MakeMoveVector'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(typeTag: TypeTag | undefined, elements: Array) { + super(); + + let typeTagArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypeTypeTag).lower(typeTag)).toStruct(); + let elementsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeArgument)).lower(elements)).toStruct(); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_makemovevector_new([ + typeTagArg, elementsArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeMakeMoveVectorObjectFactory.bless(pointer); + }// Methods: + + +/** + * The set individual elements to build the vector with + */elements(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_makemovevector_elements([ + uniffiTypeMakeMoveVectorObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeArgument)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Type of the individual elements + * + * This is required to be set when the type can't be inferred, for example + * when the set of provided arguments are all pure input values. + */typeTag(): TypeTag | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_makemovevector_type_tag([ + uniffiTypeMakeMoveVectorObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeTypeTag).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeMakeMoveVectorObjectFactory.pointer(this); + uniffiTypeMakeMoveVectorObjectFactory.freePointer(pointer); + uniffiTypeMakeMoveVectorObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is MakeMoveVector { + return uniffiTypeMakeMoveVectorObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeMakeMoveVectorObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeMakeMoveVectorObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): MakeMoveVector { + const instance = Object.create(MakeMoveVector.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'MakeMoveVector'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: MakeMoveVector): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: MakeMoveVector): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_makemovevector([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_makemovevector([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is MakeMoveVector { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'MakeMoveVector' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeMakeMoveVector = new FfiConverterObject( + uniffiTypeMakeMoveVectorObjectFactory +); + + +export type MergeCoinsInterface = { + +/** + * Coin to merge coins into + */coin(): Argument; + +/** + * Set of coins to merge into `coin` + * + * All listed coins must be of the same type and be the same type as `coin` + */coinsToMerge(): Array; + +}; + + +/** + * Command to merge multiple coins of the same type into a single coin + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * merge-coins = argument (vector argument) + * ``` + */ +export class MergeCoins extends UniffiAbstractObject implements MergeCoinsInterface { + readonly [uniffiTypeNameSymbol] = 'MergeCoins'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(coin: Argument, coinsToMerge: Array) { + super(); + + let coinArg = FfiConverterTypeArgument.lower(coin); + let coinsToMergeArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeArgument)).lower(coinsToMerge)).toStruct(); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_mergecoins_new([ + coinArg, coinsToMergeArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeMergeCoinsObjectFactory.bless(pointer); + }// Methods: + + +/** + * Coin to merge coins into + */coin(): Argument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_mergecoins_coin([ + uniffiTypeMergeCoinsObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeArgument.lift(returnValue); + } + + +/** + * Set of coins to merge into `coin` + * + * All listed coins must be of the same type and be the same type as `coin` + */coinsToMerge(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_mergecoins_coins_to_merge([ + uniffiTypeMergeCoinsObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeArgument)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeMergeCoinsObjectFactory.pointer(this); + uniffiTypeMergeCoinsObjectFactory.freePointer(pointer); + uniffiTypeMergeCoinsObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is MergeCoins { + return uniffiTypeMergeCoinsObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeMergeCoinsObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeMergeCoinsObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): MergeCoins { + const instance = Object.create(MergeCoins.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'MergeCoins'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: MergeCoins): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: MergeCoins): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_mergecoins([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_mergecoins([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is MergeCoins { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'MergeCoins' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeMergeCoins = new FfiConverterObject( + uniffiTypeMergeCoinsObjectFactory +); + + +export type MoveArgInterface = { + +}; + + +export class MoveArg extends UniffiAbstractObject implements MoveArgInterface { + readonly [uniffiTypeNameSymbol] = 'MoveArg'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static address(address: Address): MoveArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let addressArg = FfiConverterTypeAddress.lower(address); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movearg_address([ + addressArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveArg.lift(returnValue); + } + + static addressFromHex(hex: string): MoveArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let hexArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(hex)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movearg_address_from_hex([ + hexArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveArg.lift(returnValue); + } + + static addressVec(addresses: Array
): MoveArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let addressesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeAddress)).lower(addresses)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movearg_address_vec([ + addressesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveArg.lift(returnValue); + } + + static addressVecFromHex(addresses: Array): MoveArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let addressesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterString)).lower(addresses)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movearg_address_vec_from_hex([ + addressesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveArg.lift(returnValue); + } + + static bool(value: boolean): MoveArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valueArg = FfiConverterBool.lower(value); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movearg_bool([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveArg.lift(returnValue); + } + + static boolVec(values: Array): MoveArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valuesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterBool)).lower(values)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movearg_bool_vec([ + valuesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveArg.lift(returnValue); + } + + static digest(digest: Digest): MoveArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let digestArg = FfiConverterTypeDigest.lower(digest); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movearg_digest([ + digestArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveArg.lift(returnValue); + } + + static digestFromBase58(base58: string): MoveArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let base58Arg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(base58)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movearg_digest_from_base58([ + base58Arg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveArg.lift(returnValue); + } + + static digestVec(digests: Array): MoveArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let digestsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeDigest)).lower(digests)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movearg_digest_vec([ + digestsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveArg.lift(returnValue); + } + + static digestVecFromBase58(digests: Array): MoveArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let digestsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterString)).lower(digests)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movearg_digest_vec_from_base58([ + digestsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveArg.lift(returnValue); + } + + static option(value: MoveArg | undefined): MoveArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valueArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypeMoveArg).lower(value)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movearg_option([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveArg.lift(returnValue); + } + + static string(string: string): MoveArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let stringArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(string)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movearg_string([ + stringArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveArg.lift(returnValue); + } + + static stringVec(addresses: Array): MoveArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let addressesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterString)).lower(addresses)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movearg_string_vec([ + addressesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveArg.lift(returnValue); + } + + static u128(value: string): MoveArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let valueArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(value)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movearg_u128([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveArg.lift(returnValue); + } + + static u128Vec(values: Array): MoveArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let valuesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterString)).lower(values)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movearg_u128_vec([ + valuesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveArg.lift(returnValue); + } + + static u16(value: /*u16*/number): MoveArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valueArg = FfiConverterUInt16.lower(value); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movearg_u16([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveArg.lift(returnValue); + } + + static u16Vec(values: Array): MoveArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valuesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterUInt16)).lower(values)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movearg_u16_vec([ + valuesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveArg.lift(returnValue); + } + + static u256(value: string): MoveArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let valueArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(value)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movearg_u256([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveArg.lift(returnValue); + } + + static u256Vec(values: Array): MoveArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let valuesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterString)).lower(values)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movearg_u256_vec([ + valuesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveArg.lift(returnValue); + } + + static u32(value: /*u32*/number): MoveArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valueArg = FfiConverterUInt32.lower(value); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movearg_u32([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveArg.lift(returnValue); + } + + static u32Vec(values: Array): MoveArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valuesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterUInt32)).lower(values)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movearg_u32_vec([ + valuesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveArg.lift(returnValue); + } + + static u64(value: /*u64*/bigint): MoveArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valueArg = FfiConverterUInt64.lower(value); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movearg_u64([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveArg.lift(returnValue); + } + + static u64Vec(values: Array): MoveArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valuesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterUInt64)).lower(values)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movearg_u64_vec([ + valuesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveArg.lift(returnValue); + } + + static u8(value: /*u8*/number): MoveArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valueArg = FfiConverterUInt8.lower(value); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movearg_u8([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveArg.lift(returnValue); + } + + static u8Vec(values: ArrayBuffer): MoveArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valuesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(values)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movearg_u8_vec([ + valuesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveArg.lift(returnValue); + }// Methods: + + + // UniffiTrait implementations: + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeMoveArgObjectFactory.pointer(this); + uniffiTypeMoveArgObjectFactory.freePointer(pointer); + uniffiTypeMoveArgObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is MoveArg { + return uniffiTypeMoveArgObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeMoveArgObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeMoveArgObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): MoveArg { + const instance = Object.create(MoveArg.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'MoveArg'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: MoveArg): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: MoveArg): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_movearg([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_movearg([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is MoveArg { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'MoveArg' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeMoveArg = new FfiConverterObject( + uniffiTypeMoveArgObjectFactory +); + + +export type MoveAuthenticatorInterface = { + address(): Address; + callArgs(): Array; + objectToAuthenticate(): Input; + typeArgs(): Array; + +}; + + +/** + * MoveAuthenticator is a signature variant that enables a method of + * authentication through Move code. This type represents the data received + * by the Move authenticate function during the Account Abstraction + * authentication flow. + */ +export class MoveAuthenticator extends UniffiAbstractObject implements MoveAuthenticatorInterface { + readonly [uniffiTypeNameSymbol] = 'MoveAuthenticator'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + +/** + * Create a new move authenticator from an immutable object. + */ + + static newImmutable(callArgs: Array, typeArgs: Array, objectToAuthenticate: ObjectReference): MoveAuthenticator { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let callArgsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeInput)).lower(callArgs)).toStruct(); + let typeArgsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeTypeTag)).lower(typeArgs)).toStruct(); + let objectToAuthenticateArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeObjectReference.lower(objectToAuthenticate)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_moveauthenticator_new_immutable([ + callArgsArg, typeArgsArg, objectToAuthenticateArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveAuthenticator.lift(returnValue); + } +/** + * Create a new move authenticator from a shared object. + */ + + static newShared(callArgs: Array, typeArgs: Array, objectToAuthenticate: ObjectId, initialSharedVersion: /*u64*/bigint): MoveAuthenticator { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let callArgsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeInput)).lower(callArgs)).toStruct(); + let typeArgsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeTypeTag)).lower(typeArgs)).toStruct(); + let objectToAuthenticateArg = FfiConverterTypeObjectId.lower(objectToAuthenticate); + let initialSharedVersionArg = FfiConverterUInt64.lower(initialSharedVersion); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_moveauthenticator_new_shared([ + callArgsArg, typeArgsArg, objectToAuthenticateArg, initialSharedVersionArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveAuthenticator.lift(returnValue); + }// Methods: + + address(): Address { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_moveauthenticator_address([ + uniffiTypeMoveAuthenticatorObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeAddress.lift(returnValue); + } + + callArgs(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_moveauthenticator_call_args([ + uniffiTypeMoveAuthenticatorObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeInput)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + objectToAuthenticate(): Input { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_moveauthenticator_object_to_authenticate([ + uniffiTypeMoveAuthenticatorObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeInput.lift(returnValue); + } + + typeArgs(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_moveauthenticator_type_args([ + uniffiTypeMoveAuthenticatorObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeTypeTag)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeMoveAuthenticatorObjectFactory.pointer(this); + uniffiTypeMoveAuthenticatorObjectFactory.freePointer(pointer); + uniffiTypeMoveAuthenticatorObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is MoveAuthenticator { + return uniffiTypeMoveAuthenticatorObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeMoveAuthenticatorObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeMoveAuthenticatorObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): MoveAuthenticator { + const instance = Object.create(MoveAuthenticator.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'MoveAuthenticator'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: MoveAuthenticator): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: MoveAuthenticator): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_moveauthenticator([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_moveauthenticator([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is MoveAuthenticator { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'MoveAuthenticator' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeMoveAuthenticator = new FfiConverterObject( + uniffiTypeMoveAuthenticatorObjectFactory +); + + +export type MoveAuthenticatorBuilderInterface = { + +/** + * Resolve this move authenticator builder into a `MoveAuthenticator` which + * can be used to execute a transaction. + *//* async */ finish(client: GraphQlClient, asyncOpts_?: { signal: AbortSignal }): Promise; + +}; + + +export class MoveAuthenticatorBuilder extends UniffiAbstractObject implements MoveAuthenticatorBuilderInterface { + readonly [uniffiTypeNameSymbol] = 'MoveAuthenticatorBuilder'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + +/** + * Create a new move authenticator call with the account ID, function + * inputs, and generic types. + */ + constructor(accountId: ObjectId, callArgs: Array, typeArgs: Array) { + super(); + + let accountIdArg = FfiConverterTypeObjectId.lower(accountId); + let callArgsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypePtbArgument)).lower(callArgs)).toStruct(); + let typeArgsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeTypeTag)).lower(typeArgs)).toStruct(); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_moveauthenticatorbuilder_new([ + accountIdArg, callArgsArg, typeArgsArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeMoveAuthenticatorBuilderObjectFactory.bless(pointer); + }// Methods: + + +/** + * Resolve this move authenticator builder into a `MoveAuthenticator` which + * can be used to execute a transaction. + */async finish(client: GraphQlClient, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let clientArg = FfiConverterTypeGraphQlClient.lower(client); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_moveauthenticatorbuilder_finish([ + uniffiTypeMoveAuthenticatorBuilderObjectFactory.clonePointer(this), clientArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_pointer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_pointer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_pointer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_pointer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeMoveAuthenticator.lift(value), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + + // UniffiTrait implementations: + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeMoveAuthenticatorBuilderObjectFactory.pointer(this); + uniffiTypeMoveAuthenticatorBuilderObjectFactory.freePointer(pointer); + uniffiTypeMoveAuthenticatorBuilderObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is MoveAuthenticatorBuilder { + return uniffiTypeMoveAuthenticatorBuilderObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeMoveAuthenticatorBuilderObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeMoveAuthenticatorBuilderObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): MoveAuthenticatorBuilder { + const instance = Object.create(MoveAuthenticatorBuilder.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'MoveAuthenticatorBuilder'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: MoveAuthenticatorBuilder): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: MoveAuthenticatorBuilder): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_moveauthenticatorbuilder([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_moveauthenticatorbuilder([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is MoveAuthenticatorBuilder { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'MoveAuthenticatorBuilder' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeMoveAuthenticatorBuilder = new FfiConverterObject( + uniffiTypeMoveAuthenticatorBuilderObjectFactory +); + + +export type MoveCallInterface = { + +/** + * The arguments to the function. + */arguments_(): Array; + +/** + * The function to be called. + */function_(): Identifier; + +/** + * The specific module in the package containing the function. + */module(): Identifier; + +/** + * The package containing the module and function. + */package_(): ObjectId; + +/** + * The type arguments to the function. + */typeArguments(): Array; + +}; + + +/** + * Command to call a move function + * + * Functions that can be called by a `MoveCall` command are those that have a + * function signature that is either `entry` or `public` (which don't have a + * reference return type). + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * move-call = object-id ; package id + * identifier ; module name + * identifier ; function name + * (vector type-tag) ; type arguments, if any + * (vector argument) ; input arguments + * ``` + */ +export class MoveCall extends UniffiAbstractObject implements MoveCallInterface { + readonly [uniffiTypeNameSymbol] = 'MoveCall'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(package_: ObjectId, module: Identifier, function_: Identifier, typeArguments: Array, arguments_: Array) { + super(); + + let package_Arg = FfiConverterTypeObjectId.lower(package_); + let moduleArg = FfiConverterTypeIdentifier.lower(module); + let function_Arg = FfiConverterTypeIdentifier.lower(function_); + let typeArgumentsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeTypeTag)).lower(typeArguments)).toStruct(); + let arguments_Arg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeArgument)).lower(arguments_)).toStruct(); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movecall_new([ + package_Arg, moduleArg, function_Arg, typeArgumentsArg, arguments_Arg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeMoveCallObjectFactory.bless(pointer); + }// Methods: + + +/** + * The arguments to the function. + */arguments_(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_movecall_arguments([ + uniffiTypeMoveCallObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeArgument)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * The function to be called. + */function_(): Identifier { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_movecall_function([ + uniffiTypeMoveCallObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeIdentifier.lift(returnValue); + } + + +/** + * The specific module in the package containing the function. + */module(): Identifier { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_movecall_module([ + uniffiTypeMoveCallObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeIdentifier.lift(returnValue); + } + + +/** + * The package containing the module and function. + */package_(): ObjectId { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_movecall_package([ + uniffiTypeMoveCallObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectId.lift(returnValue); + } + + +/** + * The type arguments to the function. + */typeArguments(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_movecall_type_arguments([ + uniffiTypeMoveCallObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeTypeTag)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeMoveCallObjectFactory.pointer(this); + uniffiTypeMoveCallObjectFactory.freePointer(pointer); + uniffiTypeMoveCallObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is MoveCall { + return uniffiTypeMoveCallObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeMoveCallObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeMoveCallObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): MoveCall { + const instance = Object.create(MoveCall.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'MoveCall'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: MoveCall): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: MoveCall): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_movecall([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_movecall([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is MoveCall { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'MoveCall' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeMoveCall = new FfiConverterObject( + uniffiTypeMoveCallObjectFactory +); + + +export type MoveFunctionInterface = { + isEntry(): boolean; + name(): string; + parameters(): Array | undefined; + returnType(): Array | undefined; + typeParameters(): Array | undefined; + visibility(): MoveVisibility | undefined; + +}; + + +export class MoveFunction extends UniffiAbstractObject implements MoveFunctionInterface { + readonly [uniffiTypeNameSymbol] = 'MoveFunction'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + // Methods: + + isEntry(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_movefunction_is_entry([ + uniffiTypeMoveFunctionObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + name(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_movefunction_name([ + uniffiTypeMoveFunctionObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + parameters(): Array | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_movefunction_parameters([ + uniffiTypeMoveFunctionObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeOpenMoveType))).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + returnType(): Array | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_movefunction_return_type([ + uniffiTypeMoveFunctionObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeOpenMoveType))).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + typeParameters(): Array | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_movefunction_type_parameters([ + uniffiTypeMoveFunctionObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional((new FfiConverterArray(FfiConverterTypeMoveFunctionTypeParameter))).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + visibility(): MoveVisibility | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_movefunction_visibility([ + uniffiTypeMoveFunctionObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeMoveVisibility).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + toString(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_movefunction_uniffi_trait_display([ + uniffiTypeMoveFunctionObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeMoveFunctionObjectFactory.pointer(this); + uniffiTypeMoveFunctionObjectFactory.freePointer(pointer); + uniffiTypeMoveFunctionObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is MoveFunction { + return uniffiTypeMoveFunctionObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeMoveFunctionObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeMoveFunctionObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): MoveFunction { + const instance = Object.create(MoveFunction.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'MoveFunction'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: MoveFunction): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: MoveFunction): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_movefunction([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_movefunction([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is MoveFunction { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'MoveFunction' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeMoveFunction = new FfiConverterObject( + uniffiTypeMoveFunctionObjectFactory +); + + +export type MovePackageInterface = { + id(): ObjectId; + linkageTable(): Map; + modules(): Map; + typeOriginTable(): Array; + version(): /*u64*/bigint; + +}; + + +/** + * A move package + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * object-move-package = object-id u64 move-modules type-origin-table linkage-table + * + * move-modules = map (identifier bytes) + * type-origin-table = vector type-origin + * linkage-table = map (object-id upgrade-info) + * ``` + */ +export class MovePackage extends UniffiAbstractObject implements MovePackageInterface { + readonly [uniffiTypeNameSymbol] = 'MovePackage'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(id: ObjectId, version: /*u64*/bigint, modules: Map, typeOriginTable: Array, linkageTable: Map) { + super(); + + let idArg = FfiConverterTypeObjectId.lower(id); + let versionArg = FfiConverterUInt64.lower(version); + let modulesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterMap(FfiConverterTypeIdentifier, FfiConverterArrayBuffer)).lower(modules)).toStruct(); + let typeOriginTableArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeTypeOrigin)).lower(typeOriginTable)).toStruct(); + let linkageTableArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterMap(FfiConverterTypeObjectId, FfiConverterTypeUpgradeInfo)).lower(linkageTable)).toStruct(); + const pointer =uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movepackage_new([ + idArg, versionArg, modulesArg, typeOriginTableArg, linkageTableArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeMovePackageObjectFactory.bless(pointer); + }// Methods: + + id(): ObjectId { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_movepackage_id([ + uniffiTypeMovePackageObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectId.lift(returnValue); + } + + linkageTable(): Map { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_movepackage_linkage_table([ + uniffiTypeMovePackageObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterMap(FfiConverterTypeObjectId, FfiConverterTypeUpgradeInfo)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + modules(): Map { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_movepackage_modules([ + uniffiTypeMovePackageObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterMap(FfiConverterTypeIdentifier, FfiConverterArrayBuffer)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + typeOriginTable(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_movepackage_type_origin_table([ + uniffiTypeMovePackageObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeTypeOrigin)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + version(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_movepackage_version([ + uniffiTypeMovePackageObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeMovePackageObjectFactory.pointer(this); + uniffiTypeMovePackageObjectFactory.freePointer(pointer); + uniffiTypeMovePackageObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is MovePackage { + return uniffiTypeMovePackageObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeMovePackageObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeMovePackageObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): MovePackage { + const instance = Object.create(MovePackage.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'MovePackage'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: MovePackage): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: MovePackage): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_movepackage([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_movepackage([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is MovePackage { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'MovePackage' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeMovePackage = new FfiConverterObject( + uniffiTypeMovePackageObjectFactory +); + + +export type MovePackageDataInterface = { + +/** + * Returns the package dependencies. + */dependencies(): Array; + +/** + * Returns the package digest. + */digest(): Digest; + +/** + * Returns the package modules. + */modules(): Array; + toBase64(): string; + toJson(): string; + +}; + + +/** + * Type corresponding to the output of `iota move build + * --dump-bytecode-as-base64` + */ +export class MovePackageData extends UniffiAbstractObject implements MovePackageDataInterface { + readonly [uniffiTypeNameSymbol] = 'MovePackageData'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static fromBase64(base64: string): MovePackageData { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let base64Arg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(base64)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movepackagedata_from_base64([ + base64Arg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMovePackageData.lift(returnValue); + } + + static fromJson(json: string): MovePackageData { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movepackagedata_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMovePackageData.lift(returnValue); + } + constructor(modules: Array, dependencies: Array) { + super(); + + let modulesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterArrayBuffer)).lower(modules)).toStruct(); + let dependenciesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeObjectId)).lower(dependencies)).toStruct(); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_movepackagedata_new([ + modulesArg, dependenciesArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeMovePackageDataObjectFactory.bless(pointer); + }// Methods: + + +/** + * Returns the package dependencies. + */dependencies(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_movepackagedata_dependencies([ + uniffiTypeMovePackageDataObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeObjectId)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Returns the package digest. + */digest(): Digest { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_movepackagedata_digest([ + uniffiTypeMovePackageDataObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeDigest.lift(returnValue); + } + + +/** + * Returns the package modules. + */modules(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_movepackagedata_modules([ + uniffiTypeMovePackageDataObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterArrayBuffer)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + toBase64(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_movepackagedata_to_base64([ + uniffiTypeMovePackageDataObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + toJson(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_movepackagedata_to_json([ + uniffiTypeMovePackageDataObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeMovePackageDataObjectFactory.pointer(this); + uniffiTypeMovePackageDataObjectFactory.freePointer(pointer); + uniffiTypeMovePackageDataObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is MovePackageData { + return uniffiTypeMovePackageDataObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeMovePackageDataObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeMovePackageDataObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): MovePackageData { + const instance = Object.create(MovePackageData.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'MovePackageData'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: MovePackageData): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: MovePackageData): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_movepackagedata([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_movepackagedata([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is MovePackageData { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'MovePackageData' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeMovePackageData = new FfiConverterObject( + uniffiTypeMovePackageDataObjectFactory +); + + +export type MoveViewArgInterface = { + +}; + + +/** + * An argument for a Move View Function call. + * + * This enum represents the different types of values that can be passed + * as arguments to a Move View Function. + */ +export class MoveViewArg extends UniffiAbstractObject implements MoveViewArgInterface { + readonly [uniffiTypeNameSymbol] = 'MoveViewArg'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static address(value: Address): MoveViewArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valueArg = FfiConverterTypeAddress.lower(value); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_address([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveViewArg.lift(returnValue); + } + + static bool(value: boolean): MoveViewArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valueArg = FfiConverterBool.lower(value); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_bool([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveViewArg.lift(returnValue); + } + + static json(value: string): MoveViewArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valueArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(value)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_json([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveViewArg.lift(returnValue); + } + + static null_(): MoveViewArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_null([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveViewArg.lift(returnValue); + } + + static objectId(value: ObjectId): MoveViewArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valueArg = FfiConverterTypeObjectId.lower(value); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_object_id([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveViewArg.lift(returnValue); + } + + static option(value: MoveViewArg | undefined): MoveViewArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valueArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypeMoveViewArg).lower(value)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_option([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveViewArg.lift(returnValue); + } + + static string(value: string): MoveViewArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valueArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(value)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_string([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveViewArg.lift(returnValue); + } + + static stringVec(values: Array): MoveViewArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valuesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterString)).lower(values)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_string_vec([ + valuesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveViewArg.lift(returnValue); + } + + static u128(value: string): MoveViewArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valueArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(value)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_u128([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveViewArg.lift(returnValue); + } + + static u16(value: /*u16*/number): MoveViewArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valueArg = FfiConverterUInt16.lower(value); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_u16([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveViewArg.lift(returnValue); + } + + static u32(value: /*u32*/number): MoveViewArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valueArg = FfiConverterUInt32.lower(value); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_u32([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveViewArg.lift(returnValue); + } + + static u64(value: /*u64*/bigint): MoveViewArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valueArg = FfiConverterUInt64.lower(value); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_u64([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveViewArg.lift(returnValue); + } + + static u8(value: /*u8*/number): MoveViewArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valueArg = FfiConverterUInt8.lower(value); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_u8([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveViewArg.lift(returnValue); + } + + static u8Vec(values: ArrayBuffer): MoveViewArg { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valuesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(values)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_u8_vec([ + valuesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveViewArg.lift(returnValue); + }// Methods: + + + // UniffiTrait implementations: + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeMoveViewArgObjectFactory.pointer(this); + uniffiTypeMoveViewArgObjectFactory.freePointer(pointer); + uniffiTypeMoveViewArgObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is MoveViewArg { + return uniffiTypeMoveViewArgObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeMoveViewArgObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeMoveViewArgObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): MoveViewArg { + const instance = Object.create(MoveViewArg.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'MoveViewArg'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: MoveViewArg): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: MoveViewArg): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_moveviewarg([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_moveviewarg([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is MoveViewArg { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'MoveViewArg' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeMoveViewArg = new FfiConverterObject( + uniffiTypeMoveViewArgObjectFactory +); + + +export type MultisigAggregatedSignatureInterface = { + +/** + * The bitmap that indicates which committee members provided their + * signature. + */bitmap(): /*u16*/number; + committee(): MultisigCommittee; + +/** + * The list of signatures from committee members + */signatures(): Array; + +}; + + +/** + * Aggregated signature from members of a multisig committee. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * multisig-aggregated-signature = (vector multisig-member-signature) + * u16 ; bitmap + * multisig-committee + * ``` + * + * There is also a legacy encoding for this type defined as: + * + * ```text + * legacy-multisig-aggregated-signature = (vector multisig-member-signature) + * roaring-bitmap ; bitmap + * legacy-multisig-committee + * roaring-bitmap = bytes ; where the contents of the bytes are valid + * ; according to the serialized spec for + * ; roaring bitmaps + * ``` + * + * See for the specification for the + * serialized format of RoaringBitmaps. + */ +export class MultisigAggregatedSignature extends UniffiAbstractObject implements MultisigAggregatedSignatureInterface { + readonly [uniffiTypeNameSymbol] = 'MultisigAggregatedSignature'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + +/** + * Construct a new aggregated multisig signature. + * + * Since the list of signatures doesn't contain sufficient information to + * identify which committee member provided the signature, it is up to + * the caller to ensure that the provided signature list is in the same + * order as it's corresponding member in the provided committee + * and that it's position in the provided bitmap is set. + */ + constructor(committee: MultisigCommittee, signatures: Array, bitmap: /*u16*/number) { + super(); + + let committeeArg = FfiConverterTypeMultisigCommittee.lower(committee); + let signaturesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeMultisigMemberSignature)).lower(signatures)).toStruct(); + let bitmapArg = FfiConverterUInt16.lower(bitmap); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_multisigaggregatedsignature_new([ + committeeArg, signaturesArg, bitmapArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeMultisigAggregatedSignatureObjectFactory.bless(pointer); + }// Methods: + + +/** + * The bitmap that indicates which committee members provided their + * signature. + */bitmap(): /*u16*/number { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigaggregatedsignature_bitmap([ + uniffiTypeMultisigAggregatedSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt16.lift(returnValue); + } + + committee(): MultisigCommittee { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigaggregatedsignature_committee([ + uniffiTypeMultisigAggregatedSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMultisigCommittee.lift(returnValue); + } + + +/** + * The list of signatures from committee members + */signatures(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigaggregatedsignature_signatures([ + uniffiTypeMultisigAggregatedSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeMultisigMemberSignature)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeMultisigAggregatedSignatureObjectFactory.pointer(this); + uniffiTypeMultisigAggregatedSignatureObjectFactory.freePointer(pointer); + uniffiTypeMultisigAggregatedSignatureObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is MultisigAggregatedSignature { + return uniffiTypeMultisigAggregatedSignatureObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeMultisigAggregatedSignatureObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeMultisigAggregatedSignatureObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): MultisigAggregatedSignature { + const instance = Object.create(MultisigAggregatedSignature.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'MultisigAggregatedSignature'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: MultisigAggregatedSignature): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: MultisigAggregatedSignature): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_multisigaggregatedsignature([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_multisigaggregatedsignature([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is MultisigAggregatedSignature { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'MultisigAggregatedSignature' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeMultisigAggregatedSignature = new FfiConverterObject( + uniffiTypeMultisigAggregatedSignatureObjectFactory +); + + +export type MultisigAggregatorInterface = { + finish(): MultisigAggregatedSignature; + verifier(): MultisigVerifier; + withSignature(signature: UserSignature): MultisigAggregator; + withVerifier(verifier: MultisigVerifier): MultisigAggregator; + +}; + + +export class MultisigAggregator extends UniffiAbstractObject implements MultisigAggregatorInterface { + readonly [uniffiTypeNameSymbol] = 'MultisigAggregator'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static newWithMessage(committee: MultisigCommittee, message: ArrayBuffer): MultisigAggregator { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let committeeArg = FfiConverterTypeMultisigCommittee.lower(committee); + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_multisigaggregator_new_with_message([ + committeeArg, messageArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMultisigAggregator.lift(returnValue); + } + + static newWithTransaction(committee: MultisigCommittee, transaction: Transaction): MultisigAggregator { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let committeeArg = FfiConverterTypeMultisigCommittee.lower(committee); + let transactionArg = FfiConverterTypeTransaction.lower(transaction); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_multisigaggregator_new_with_transaction([ + committeeArg, transactionArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMultisigAggregator.lift(returnValue); + }// Methods: + + finish(): MultisigAggregatedSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigaggregator_finish([ + uniffiTypeMultisigAggregatorObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMultisigAggregatedSignature.lift(returnValue); + } + + verifier(): MultisigVerifier { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigaggregator_verifier([ + uniffiTypeMultisigAggregatorObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMultisigVerifier.lift(returnValue); + } + + withSignature(signature: UserSignature): MultisigAggregator { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let signatureArg = FfiConverterTypeUserSignature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigaggregator_with_signature([ + uniffiTypeMultisigAggregatorObjectFactory.clonePointer(this), signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMultisigAggregator.lift(returnValue); + } + + withVerifier(verifier: MultisigVerifier): MultisigAggregator { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let verifierArg = FfiConverterTypeMultisigVerifier.lower(verifier); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigaggregator_with_verifier([ + uniffiTypeMultisigAggregatorObjectFactory.clonePointer(this), verifierArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMultisigAggregator.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeMultisigAggregatorObjectFactory.pointer(this); + uniffiTypeMultisigAggregatorObjectFactory.freePointer(pointer); + uniffiTypeMultisigAggregatorObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is MultisigAggregator { + return uniffiTypeMultisigAggregatorObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeMultisigAggregatorObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeMultisigAggregatorObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): MultisigAggregator { + const instance = Object.create(MultisigAggregator.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'MultisigAggregator'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: MultisigAggregator): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: MultisigAggregator): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_multisigaggregator([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_multisigaggregator([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is MultisigAggregator { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'MultisigAggregator' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeMultisigAggregator = new FfiConverterObject( + uniffiTypeMultisigAggregatorObjectFactory +); + + +export type MultisigCommitteeInterface = { + +/** + * Derive an `Address` from this MultisigCommittee. + * + * A MultiSig address + * is defined as the 32-byte Blake2b hash of serializing the + * `SignatureScheme` flag (0x03), the threshold (in little endian), and + * the concatenation of all n flag, public keys and its weight. + * + * `hash(0x03 || threshold || flag_1 || pk_1 || weight_1 + * || ... || flag_n || pk_n || weight_n)`. + * + * When flag_i is ZkLogin, the pk_i for the `ZkLoginPublicIdentifier` + * refers to the same input used when deriving the address using the + * `ZkLoginPublicIdentifier::derive_address_padded` method (using the + * full 32-byte `address_seed` value). + */deriveAddress(): Address; + +/** + * Checks if the Committee is valid. + * + * A valid committee is one that: + * - Has a nonzero threshold + * - Has at least one member + * - Has at most ten members + * - No member has weight 0 + * - the sum of the weights of all members must be larger than the + * threshold + * - contains no duplicate members + */isValid(): boolean; + +/** + * The members of the committee + */members(): Array; + +/** + * Return the flag for this signature scheme + */scheme(): SignatureScheme; + +/** + * The total signature weight required to authorize a transaction for the + * address corresponding to this `MultisigCommittee`. + */threshold(): /*u16*/number; + +}; + + +/** + * A multisig committee + * + * A `MultisigCommittee` is a set of members who collectively control a single + * `Address` on the IOTA blockchain. The number of required signatures to + * authorize the execution of a transaction is determined by + * `(signature_0_weight + signature_1_weight ..) >= threshold`. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * multisig-committee = (vector multisig-member) + * u16 ; threshold + * ``` + * + * There is also a legacy encoding for this type defined as: + * + * ```text + * legacy-multisig-committee = (vector legacy-multisig-member) + * u16 ; threshold + * ``` + */ +export class MultisigCommittee extends UniffiAbstractObject implements MultisigCommitteeInterface { + readonly [uniffiTypeNameSymbol] = 'MultisigCommittee'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + +/** + * Construct a new committee from a list of `MultisigMember`s and a + * `threshold`. + * + * Note that the order of the members is significant towards deriving the + * `Address` governed by this committee. + */ + constructor(members: Array, threshold: /*u16*/number) { + super(); + + let membersArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeMultisigMember)).lower(members)).toStruct(); + let thresholdArg = FfiConverterUInt16.lower(threshold); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_multisigcommittee_new([ + membersArg, thresholdArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeMultisigCommitteeObjectFactory.bless(pointer); + }// Methods: + + +/** + * Derive an `Address` from this MultisigCommittee. + * + * A MultiSig address + * is defined as the 32-byte Blake2b hash of serializing the + * `SignatureScheme` flag (0x03), the threshold (in little endian), and + * the concatenation of all n flag, public keys and its weight. + * + * `hash(0x03 || threshold || flag_1 || pk_1 || weight_1 + * || ... || flag_n || pk_n || weight_n)`. + * + * When flag_i is ZkLogin, the pk_i for the `ZkLoginPublicIdentifier` + * refers to the same input used when deriving the address using the + * `ZkLoginPublicIdentifier::derive_address_padded` method (using the + * full 32-byte `address_seed` value). + */deriveAddress(): Address { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigcommittee_derive_address([ + uniffiTypeMultisigCommitteeObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeAddress.lift(returnValue); + } + + +/** + * Checks if the Committee is valid. + * + * A valid committee is one that: + * - Has a nonzero threshold + * - Has at least one member + * - Has at most ten members + * - No member has weight 0 + * - the sum of the weights of all members must be larger than the + * threshold + * - contains no duplicate members + */isValid(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigcommittee_is_valid([ + uniffiTypeMultisigCommitteeObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + +/** + * The members of the committee + */members(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigcommittee_members([ + uniffiTypeMultisigCommitteeObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeMultisigMember)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Return the flag for this signature scheme + */scheme(): SignatureScheme { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigcommittee_scheme([ + uniffiTypeMultisigCommitteeObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSignatureScheme.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * The total signature weight required to authorize a transaction for the + * address corresponding to this `MultisigCommittee`. + */threshold(): /*u16*/number { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigcommittee_threshold([ + uniffiTypeMultisigCommitteeObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt16.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeMultisigCommitteeObjectFactory.pointer(this); + uniffiTypeMultisigCommitteeObjectFactory.freePointer(pointer); + uniffiTypeMultisigCommitteeObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is MultisigCommittee { + return uniffiTypeMultisigCommitteeObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeMultisigCommitteeObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeMultisigCommitteeObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): MultisigCommittee { + const instance = Object.create(MultisigCommittee.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'MultisigCommittee'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: MultisigCommittee): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: MultisigCommittee): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_multisigcommittee([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_multisigcommittee([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is MultisigCommittee { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'MultisigCommittee' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeMultisigCommittee = new FfiConverterObject( + uniffiTypeMultisigCommitteeObjectFactory +); + + +export type MultisigMemberInterface = { + +/** + * This member's public key. + */publicKey(): MultisigMemberPublicKey; + +/** + * Weight of this member's signature. + */weight(): /*u8*/number; + +}; + + +/** + * A member in a multisig committee + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * multisig-member = multisig-member-public-key + * u8 ; weight + * ``` + * + * There is also a legacy encoding for this type defined as: + * + * ```text + * legacy-multisig-member = legacy-multisig-member-public-key + * u8 ; weight + * ``` + */ +export class MultisigMember extends UniffiAbstractObject implements MultisigMemberInterface { + readonly [uniffiTypeNameSymbol] = 'MultisigMember'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + +/** + * Construct a new member from a `MultisigMemberPublicKey` and a `weight`. + */ + constructor(publicKey: MultisigMemberPublicKey, weight: /*u8*/number) { + super(); + + let publicKeyArg = FfiConverterTypeMultisigMemberPublicKey.lower(publicKey); + let weightArg = FfiConverterUInt8.lower(weight); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_multisigmember_new([ + publicKeyArg, weightArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeMultisigMemberObjectFactory.bless(pointer); + }// Methods: + + +/** + * This member's public key. + */publicKey(): MultisigMemberPublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmember_public_key([ + uniffiTypeMultisigMemberObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMultisigMemberPublicKey.lift(returnValue); + } + + +/** + * Weight of this member's signature. + */weight(): /*u8*/number { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmember_weight([ + uniffiTypeMultisigMemberObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt8.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeMultisigMemberObjectFactory.pointer(this); + uniffiTypeMultisigMemberObjectFactory.freePointer(pointer); + uniffiTypeMultisigMemberObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is MultisigMember { + return uniffiTypeMultisigMemberObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeMultisigMemberObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeMultisigMemberObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): MultisigMember { + const instance = Object.create(MultisigMember.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'MultisigMember'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: MultisigMember): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: MultisigMember): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_multisigmember([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_multisigmember([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is MultisigMember { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'MultisigMember' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeMultisigMember = new FfiConverterObject( + uniffiTypeMultisigMemberObjectFactory +); + + +export type MultisigMemberPublicKeyInterface = { + asEd25519(): Ed25519PublicKey; + asEd25519Opt(): Ed25519PublicKey | undefined; + asSecp256k1(): Secp256k1PublicKey; + asSecp256k1Opt(): Secp256k1PublicKey | undefined; + asSecp256r1(): Secp256r1PublicKey; + asSecp256r1Opt(): Secp256r1PublicKey | undefined; + asZklogin(): ZkLoginPublicIdentifier; + asZkloginOpt(): ZkLoginPublicIdentifier | undefined; + isEd25519(): boolean; + isSecp256k1(): boolean; + isSecp256r1(): boolean; + isZklogin(): boolean; + scheme(): SignatureScheme; + +}; + + +/** + * Enum of valid public keys for multisig committee members + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * multisig-member-public-key = ed25519-multisig-member-public-key / + * secp256k1-multisig-member-public-key / + * secp256r1-multisig-member-public-key / + * zklogin-multisig-member-public-key + * + * ed25519-multisig-member-public-key = %x00 ed25519-public-key + * secp256k1-multisig-member-public-key = %x01 secp256k1-public-key + * secp256r1-multisig-member-public-key = %x02 secp256r1-public-key + * zklogin-multisig-member-public-key = %x03 zklogin-public-identifier + * ``` + * + * There is also a legacy encoding for this type defined as: + * + * ```text + * legacy-multisig-member-public-key = string ; which is valid base64 encoded + * ; and the decoded bytes are defined + * ; by legacy-public-key + * legacy-public-key = (ed25519-flag ed25519-public-key) / + * (secp256k1-flag secp256k1-public-key) / + * (secp256r1-flag secp256r1-public-key) + * ``` + */ +export class MultisigMemberPublicKey extends UniffiAbstractObject implements MultisigMemberPublicKeyInterface { + readonly [uniffiTypeNameSymbol] = 'MultisigMemberPublicKey'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + // Methods: + + asEd25519(): Ed25519PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_ed25519([ + uniffiTypeMultisigMemberPublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEd25519PublicKey.lift(returnValue); + } + + asEd25519Opt(): Ed25519PublicKey | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_ed25519_opt([ + uniffiTypeMultisigMemberPublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeEd25519PublicKey).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + asSecp256k1(): Secp256k1PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_secp256k1([ + uniffiTypeMultisigMemberPublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256k1PublicKey.lift(returnValue); + } + + asSecp256k1Opt(): Secp256k1PublicKey | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_secp256k1_opt([ + uniffiTypeMultisigMemberPublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeSecp256k1PublicKey).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + asSecp256r1(): Secp256r1PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_secp256r1([ + uniffiTypeMultisigMemberPublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1PublicKey.lift(returnValue); + } + + asSecp256r1Opt(): Secp256r1PublicKey | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_secp256r1_opt([ + uniffiTypeMultisigMemberPublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeSecp256r1PublicKey).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + asZklogin(): ZkLoginPublicIdentifier { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_zklogin([ + uniffiTypeMultisigMemberPublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeZkLoginPublicIdentifier.lift(returnValue); + } + + asZkloginOpt(): ZkLoginPublicIdentifier | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_zklogin_opt([ + uniffiTypeMultisigMemberPublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeZkLoginPublicIdentifier).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + isEd25519(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_is_ed25519([ + uniffiTypeMultisigMemberPublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + isSecp256k1(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_is_secp256k1([ + uniffiTypeMultisigMemberPublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + isSecp256r1(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_is_secp256r1([ + uniffiTypeMultisigMemberPublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + isZklogin(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_is_zklogin([ + uniffiTypeMultisigMemberPublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + scheme(): SignatureScheme { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_scheme([ + uniffiTypeMultisigMemberPublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSignatureScheme.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeMultisigMemberPublicKeyObjectFactory.pointer(this); + uniffiTypeMultisigMemberPublicKeyObjectFactory.freePointer(pointer); + uniffiTypeMultisigMemberPublicKeyObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is MultisigMemberPublicKey { + return uniffiTypeMultisigMemberPublicKeyObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeMultisigMemberPublicKeyObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeMultisigMemberPublicKeyObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): MultisigMemberPublicKey { + const instance = Object.create(MultisigMemberPublicKey.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'MultisigMemberPublicKey'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: MultisigMemberPublicKey): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: MultisigMemberPublicKey): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_multisigmemberpublickey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_multisigmemberpublickey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is MultisigMemberPublicKey { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'MultisigMemberPublicKey' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeMultisigMemberPublicKey = new FfiConverterObject( + uniffiTypeMultisigMemberPublicKeyObjectFactory +); + + +export type MultisigMemberSignatureInterface = { + asEd25519(): Ed25519Signature; + asEd25519Opt(): Ed25519Signature | undefined; + asSecp256k1(): Secp256k1Signature; + asSecp256k1Opt(): Secp256k1Signature | undefined; + asSecp256r1(): Secp256r1Signature; + asSecp256r1Opt(): Secp256r1Signature | undefined; + asZklogin(): ZkLoginAuthenticator; + asZkloginOpt(): ZkLoginAuthenticator | undefined; + isEd25519(): boolean; + isSecp256k1(): boolean; + isSecp256r1(): boolean; + isZklogin(): boolean; + +}; + + +/** + * A signature from a member of a multisig committee. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * multisig-member-signature = ed25519-multisig-member-signature / + * secp256k1-multisig-member-signature / + * secp256r1-multisig-member-signature / + * zklogin-multisig-member-signature + * + * ed25519-multisig-member-signature = %x00 ed25519-signature + * secp256k1-multisig-member-signature = %x01 secp256k1-signature + * secp256r1-multisig-member-signature = %x02 secp256r1-signature + * zklogin-multisig-member-signature = %x03 zklogin-authenticator + * ``` + */ +export class MultisigMemberSignature extends UniffiAbstractObject implements MultisigMemberSignatureInterface { + readonly [uniffiTypeNameSymbol] = 'MultisigMemberSignature'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + // Methods: + + asEd25519(): Ed25519Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_ed25519([ + uniffiTypeMultisigMemberSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEd25519Signature.lift(returnValue); + } + + asEd25519Opt(): Ed25519Signature | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_ed25519_opt([ + uniffiTypeMultisigMemberSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeEd25519Signature).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + asSecp256k1(): Secp256k1Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_secp256k1([ + uniffiTypeMultisigMemberSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256k1Signature.lift(returnValue); + } + + asSecp256k1Opt(): Secp256k1Signature | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_secp256k1_opt([ + uniffiTypeMultisigMemberSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeSecp256k1Signature).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + asSecp256r1(): Secp256r1Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_secp256r1([ + uniffiTypeMultisigMemberSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1Signature.lift(returnValue); + } + + asSecp256r1Opt(): Secp256r1Signature | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_secp256r1_opt([ + uniffiTypeMultisigMemberSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeSecp256r1Signature).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + asZklogin(): ZkLoginAuthenticator { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_zklogin([ + uniffiTypeMultisigMemberSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeZkLoginAuthenticator.lift(returnValue); + } + + asZkloginOpt(): ZkLoginAuthenticator | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_zklogin_opt([ + uniffiTypeMultisigMemberSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeZkLoginAuthenticator).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + isEd25519(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_is_ed25519([ + uniffiTypeMultisigMemberSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + isSecp256k1(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_is_secp256k1([ + uniffiTypeMultisigMemberSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + isSecp256r1(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_is_secp256r1([ + uniffiTypeMultisigMemberSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + isZklogin(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_is_zklogin([ + uniffiTypeMultisigMemberSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeMultisigMemberSignatureObjectFactory.pointer(this); + uniffiTypeMultisigMemberSignatureObjectFactory.freePointer(pointer); + uniffiTypeMultisigMemberSignatureObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is MultisigMemberSignature { + return uniffiTypeMultisigMemberSignatureObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeMultisigMemberSignatureObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeMultisigMemberSignatureObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): MultisigMemberSignature { + const instance = Object.create(MultisigMemberSignature.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'MultisigMemberSignature'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: MultisigMemberSignature): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: MultisigMemberSignature): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_multisigmembersignature([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_multisigmembersignature([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is MultisigMemberSignature { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'MultisigMemberSignature' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeMultisigMemberSignature = new FfiConverterObject( + uniffiTypeMultisigMemberSignatureObjectFactory +); + + +export type MultisigVerifierInterface = { + verify(message: ArrayBuffer, signature: MultisigAggregatedSignature): void; + withZkloginVerifier(zkloginVerifier: ZkloginVerifier): MultisigVerifier; + zkloginVerifier(): ZkloginVerifier | undefined; + +}; + + +export class MultisigVerifier extends UniffiAbstractObject implements MultisigVerifierInterface { + readonly [uniffiTypeNameSymbol] = 'MultisigVerifier'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor() { + super(); + + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_multisigverifier_new([ + callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeMultisigVerifierObjectFactory.bless(pointer); + }// Methods: + + verify(message: ArrayBuffer, signature: MultisigAggregatedSignature): void { + /* Regular function call: */ + uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + let signatureArg = FfiConverterTypeMultisigAggregatedSignature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigverifier_verify([ + uniffiTypeMultisigVerifierObjectFactory.clonePointer(this), messageArg, signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + withZkloginVerifier(zkloginVerifier: ZkloginVerifier): MultisigVerifier { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let zkloginVerifierArg = FfiConverterTypeZkloginVerifier.lower(zkloginVerifier); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigverifier_with_zklogin_verifier([ + uniffiTypeMultisigVerifierObjectFactory.clonePointer(this), zkloginVerifierArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMultisigVerifier.lift(returnValue); + } + + zkloginVerifier(): ZkloginVerifier | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_multisigverifier_zklogin_verifier([ + uniffiTypeMultisigVerifierObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeZkloginVerifier).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeMultisigVerifierObjectFactory.pointer(this); + uniffiTypeMultisigVerifierObjectFactory.freePointer(pointer); + uniffiTypeMultisigVerifierObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is MultisigVerifier { + return uniffiTypeMultisigVerifierObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeMultisigVerifierObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeMultisigVerifierObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): MultisigVerifier { + const instance = Object.create(MultisigVerifier.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'MultisigVerifier'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: MultisigVerifier): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: MultisigVerifier): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_multisigverifier([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_multisigverifier([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is MultisigVerifier { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'MultisigVerifier' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeMultisigVerifier = new FfiConverterObject( + uniffiTypeMultisigVerifierObjectFactory +); + + +export type NameInterface = { + +/** + * Formats a name into a string based on the available output formats. + * The default separator is `.` + */format(format: NameFormat): string; + +/** + * Returns whether this name is a second-level name (Ex. `test.iota`) + */isSln(): boolean; + +/** + * Returns whether this name is a subname (Ex. `sub.test.iota`) + */isSubname(): boolean; + +/** + * Get the label at the given index + */label(index: /*u32*/number): string | undefined; + +/** + * Get all of the labels. NOTE: These are in reverse order starting with + * the top-level name and proceeding to subnames. + */labels(): Array; + +/** + * Returns the number of labels including TLN. + */numLabels(): /*u32*/number; + +/** + * parents; second-level names return `None`. + */parent(): Name | undefined; + +}; + + +export class Name extends UniffiAbstractObject implements NameInterface { + readonly [uniffiTypeNameSymbol] = 'Name'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static fromStr(s: string): Name { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let sArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(s)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_name_from_str([ + sArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeName.lift(returnValue); + }// Methods: + + +/** + * Formats a name into a string based on the available output formats. + * The default separator is `.` + */format(format: NameFormat): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let formatArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeNameFormat.lower(format)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_name_format([ + uniffiTypeNameObjectFactory.clonePointer(this), formatArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Returns whether this name is a second-level name (Ex. `test.iota`) + */isSln(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_name_is_sln([ + uniffiTypeNameObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + +/** + * Returns whether this name is a subname (Ex. `sub.test.iota`) + */isSubname(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_name_is_subname([ + uniffiTypeNameObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + +/** + * Get the label at the given index + */label(index: /*u32*/number): string | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let indexArg = FfiConverterUInt32.lower(index); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_name_label([ + uniffiTypeNameObjectFactory.clonePointer(this), indexArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterString).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Get all of the labels. NOTE: These are in reverse order starting with + * the top-level name and proceeding to subnames. + */labels(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_name_labels([ + uniffiTypeNameObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterString)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Returns the number of labels including TLN. + */numLabels(): /*u32*/number { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_name_num_labels([ + uniffiTypeNameObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt32.lift(returnValue); + } + + +/** + * parents; second-level names return `None`. + */parent(): Name | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_name_parent([ + uniffiTypeNameObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeName).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + toString(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_name_uniffi_trait_display([ + uniffiTypeNameObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeNameObjectFactory.pointer(this); + uniffiTypeNameObjectFactory.freePointer(pointer); + uniffiTypeNameObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Name { + return uniffiTypeNameObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeNameObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeNameObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Name { + const instance = Object.create(Name.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Name'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Name): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Name): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_name([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_name([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Name { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Name' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeName = new FfiConverterObject( + uniffiTypeNameObjectFactory +); + + +export type NameRegistrationInterface = { + expirationTimestampMs(): /*u64*/bigint; + id(): ObjectId; + name(): Name; + nameStr(): string; + +}; + + +/** + * An object to manage a second-level name (SLN). + */ +export class NameRegistration extends UniffiAbstractObject implements NameRegistrationInterface { + readonly [uniffiTypeNameSymbol] = 'NameRegistration'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(id: ObjectId, name: Name, nameStr: string, expirationTimestampMs: /*u64*/bigint) { + super(); + + let idArg = FfiConverterTypeObjectId.lower(id); + let nameArg = FfiConverterTypeName.lower(name); + let nameStrArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(nameStr)).toStruct(); + let expirationTimestampMsArg = FfiConverterUInt64.lower(expirationTimestampMs); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_nameregistration_new([ + idArg, nameArg, nameStrArg, expirationTimestampMsArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeNameRegistrationObjectFactory.bless(pointer); + }// Methods: + + expirationTimestampMs(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_nameregistration_expiration_timestamp_ms([ + uniffiTypeNameRegistrationObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + id(): ObjectId { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_nameregistration_id([ + uniffiTypeNameRegistrationObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectId.lift(returnValue); + } + + name(): Name { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_nameregistration_name([ + uniffiTypeNameRegistrationObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeName.lift(returnValue); + } + + nameStr(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_nameregistration_name_str([ + uniffiTypeNameRegistrationObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeNameRegistrationObjectFactory.pointer(this); + uniffiTypeNameRegistrationObjectFactory.freePointer(pointer); + uniffiTypeNameRegistrationObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is NameRegistration { + return uniffiTypeNameRegistrationObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeNameRegistrationObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeNameRegistrationObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): NameRegistration { + const instance = Object.create(NameRegistration.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'NameRegistration'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: NameRegistration): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: NameRegistration): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_nameregistration([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_nameregistration([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is NameRegistration { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'NameRegistration' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeNameRegistration = new FfiConverterObject( + uniffiTypeNameRegistrationObjectFactory +); + + +export type Object_Interface = { + +/** + * Interpret this object as a move package + */asPackage(): MovePackage; + +/** + * Try to interpret this object as a move package + */asPackageOpt(): MovePackage | undefined; + +/** + * Interpret this object as a move struct + */asStruct(): MoveStruct; + +/** + * Try to interpret this object as a move struct + */asStructOpt(): MoveStruct | undefined; + +/** + * Return this object's data + */data(): ObjectData; + +/** + * Calculate the digest of this `Object` + * + * This is done by hashing the BCS bytes of this `Object` prefixed + */digest(): Digest; + +/** + * Return this object's id + */objectId(): ObjectId; + +/** + * Return this object's reference + */objectRef(): ObjectReference; + +/** + * Return this object's type + */objectType(): ObjectType; + +/** + * Return this object's owner + */owner(): Owner; + +/** + * Return the digest of the transaction that last modified this object + */previousTransaction(): Digest; + +/** + * Return the storage rebate locked in this object + * + * Storage rebates are credited to the gas coin used in a transaction that + * deletes this object. + */storageRebate(): /*u64*/bigint; + +/** + * Return this object's version + */version(): /*u64*/bigint; + +}; + + +/** + * An object on the IOTA blockchain + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * object = object-data owner digest u64 + * ``` + */ +export class Object_ extends UniffiAbstractObject implements Object_Interface { + readonly [uniffiTypeNameSymbol] = 'Object'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(data: ObjectData, owner: Owner, previousTransaction: Digest, storageRebate: /*u64*/bigint) { + super(); + + let dataArg = FfiConverterTypeObjectData.lower(data); + let ownerArg = FfiConverterTypeOwner.lower(owner); + let previousTransactionArg = FfiConverterTypeDigest.lower(previousTransaction); + let storageRebateArg = FfiConverterUInt64.lower(storageRebate); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_object_new([ + dataArg, ownerArg, previousTransactionArg, storageRebateArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeObject_ObjectFactory.bless(pointer); + }// Methods: + + +/** + * Interpret this object as a move package + */asPackage(): MovePackage { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_object_as_package([ + uniffiTypeObject_ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMovePackage.lift(returnValue); + } + + +/** + * Try to interpret this object as a move package + */asPackageOpt(): MovePackage | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_object_as_package_opt([ + uniffiTypeObject_ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeMovePackage).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Interpret this object as a move struct + */asStruct(): MoveStruct { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_object_as_struct([ + uniffiTypeObject_ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveStruct.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Try to interpret this object as a move struct + */asStructOpt(): MoveStruct | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_object_as_struct_opt([ + uniffiTypeObject_ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeMoveStruct).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Return this object's data + */data(): ObjectData { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_object_data([ + uniffiTypeObject_ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectData.lift(returnValue); + } + + +/** + * Calculate the digest of this `Object` + * + * This is done by hashing the BCS bytes of this `Object` prefixed + */digest(): Digest { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_object_digest([ + uniffiTypeObject_ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeDigest.lift(returnValue); + } + + +/** + * Return this object's id + */objectId(): ObjectId { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_object_object_id([ + uniffiTypeObject_ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectId.lift(returnValue); + } + + +/** + * Return this object's reference + */objectRef(): ObjectReference { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_object_object_ref([ + uniffiTypeObject_ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectReference.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Return this object's type + */objectType(): ObjectType { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_object_object_type([ + uniffiTypeObject_ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectType.lift(returnValue); + } + + +/** + * Return this object's owner + */owner(): Owner { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_object_owner([ + uniffiTypeObject_ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeOwner.lift(returnValue); + } + + +/** + * Return the digest of the transaction that last modified this object + */previousTransaction(): Digest { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_object_previous_transaction([ + uniffiTypeObject_ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeDigest.lift(returnValue); + } + + +/** + * Return the storage rebate locked in this object + * + * Storage rebates are credited to the gas coin used in a transaction that + * deletes this object. + */storageRebate(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_object_storage_rebate([ + uniffiTypeObject_ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + +/** + * Return this object's version + */version(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_object_version([ + uniffiTypeObject_ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeObject_ObjectFactory.pointer(this); + uniffiTypeObject_ObjectFactory.freePointer(pointer); + uniffiTypeObject_ObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Object_ { + return uniffiTypeObject_ObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeObject_ObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeObject_ObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Object_ { + const instance = Object.create(Object_.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Object'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Object_): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Object_): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_object([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_object([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Object_ { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Object' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeObject = new FfiConverterObject( + uniffiTypeObject_ObjectFactory +); + + +export type ObjectDataInterface = { + +/** + * Try to interpret this object as a `MovePackage` + */asPackageOpt(): MovePackage | undefined; + +/** + * Try to interpret this object as a `MoveStruct` + */asStructOpt(): MoveStruct | undefined; + +/** + * Return whether this object is a `MovePackage` + */isPackage(): boolean; + +/** + * Return whether this object is a `MoveStruct` + */isStruct(): boolean; + +}; + + +/** + * Object data, either a package or struct + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * object-data = object-data-struct / object-data-package + * + * object-data-struct = %x00 object-move-struct + * object-data-package = %x01 object-move-package + * ``` + */ +export class ObjectData extends UniffiAbstractObject implements ObjectDataInterface { + readonly [uniffiTypeNameSymbol] = 'ObjectData'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + +/** + * Create an `ObjectData` from `MovePackage` + */ + + static newMovePackage(movePackage: MovePackage): ObjectData { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let movePackageArg = FfiConverterTypeMovePackage.lower(movePackage); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_objectdata_new_move_package([ + movePackageArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectData.lift(returnValue); + } +/** + * Create an `ObjectData` from a `MoveStruct` + */ + + static newMoveStruct(moveStruct: MoveStruct): ObjectData { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let moveStructArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeMoveStruct.lower(moveStruct)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_objectdata_new_move_struct([ + moveStructArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectData.lift(returnValue); + }// Methods: + + +/** + * Try to interpret this object as a `MovePackage` + */asPackageOpt(): MovePackage | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_objectdata_as_package_opt([ + uniffiTypeObjectDataObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeMovePackage).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Try to interpret this object as a `MoveStruct` + */asStructOpt(): MoveStruct | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_objectdata_as_struct_opt([ + uniffiTypeObjectDataObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeMoveStruct).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Return whether this object is a `MovePackage` + */isPackage(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_objectdata_is_package([ + uniffiTypeObjectDataObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + +/** + * Return whether this object is a `MoveStruct` + */isStruct(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_objectdata_is_struct([ + uniffiTypeObjectDataObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeObjectDataObjectFactory.pointer(this); + uniffiTypeObjectDataObjectFactory.freePointer(pointer); + uniffiTypeObjectDataObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is ObjectData { + return uniffiTypeObjectDataObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeObjectDataObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeObjectDataObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): ObjectData { + const instance = Object.create(ObjectData.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'ObjectData'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: ObjectData): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: ObjectData): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_objectdata([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_objectdata([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is ObjectData { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'ObjectData' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeObjectData = new FfiConverterObject( + uniffiTypeObjectDataObjectFactory +); + + +export type ObjectIdInterface = { + +/** + * Derive an ObjectId for a Dynamic Child Object. + * + * hash(parent || len(key) || key || key_type_tag) + */deriveDynamicChildId(keyTypeTag: TypeTag, keyBytes: ArrayBuffer): ObjectId; + toAddress(): Address; + toBytes(): ArrayBuffer; + +/** + * Returns the string representation of this object ID using the + * canonical display, with or without a `0x` prefix. + */toCanonicalString(withPrefix: boolean): string; + toHex(): string; + +/** + * Returns the shortest possible string representation of the object ID + * (i.e. with leading zeroes trimmed). + */toShortString(withPrefix: boolean): string; + +}; + + +/** + * An `ObjectId` is a 32-byte identifier used to uniquely identify an object on + * the IOTA blockchain. + * + * ## Relationship to Address + * + * `Address`es and `ObjectId`s share the same 32-byte addressable space but + * are derived leveraging different domain-separator values to ensure, + * cryptographically, that there won't be any overlap, e.g. there can't be a + * valid `Object` whose `ObjectId` is equal to that of the `Address` of a user + * account. + * + * # BCS + * + * An `ObjectId`'s BCS serialized form is defined by the following: + * + * ```text + * object-id = 32*OCTET + * ``` + */ +export class ObjectId extends UniffiAbstractObject implements ObjectIdInterface { + readonly [uniffiTypeNameSymbol] = 'ObjectId'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static clock(): ObjectId { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_objectid_clock([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectId.lift(returnValue); + } +/** + * Create an ObjectId from a transaction digest and the number of objects + * that have been created during a transactions. + */ + + static deriveId(digest: Digest, count: /*u64*/bigint): ObjectId { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let digestArg = FfiConverterTypeDigest.lower(digest); + let countArg = FfiConverterUInt64.lower(count); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_objectid_derive_id([ + digestArg, countArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectId.lift(returnValue); + } + + static fromBytes(bytes: ArrayBuffer): ObjectId { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_objectid_from_bytes([ + bytesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectId.lift(returnValue); + } + + static fromHex(hex: string): ObjectId { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let hexArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(hex)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_objectid_from_hex([ + hexArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectId.lift(returnValue); + } + + static system(): ObjectId { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_objectid_system([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectId.lift(returnValue); + } + + static zero(): ObjectId { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_objectid_zero([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectId.lift(returnValue); + }// Methods: + + +/** + * Derive an ObjectId for a Dynamic Child Object. + * + * hash(parent || len(key) || key || key_type_tag) + */deriveDynamicChildId(keyTypeTag: TypeTag, keyBytes: ArrayBuffer): ObjectId { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let keyTypeTagArg = FfiConverterTypeTypeTag.lower(keyTypeTag); + let keyBytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(keyBytes)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_objectid_derive_dynamic_child_id([ + uniffiTypeObjectIdObjectFactory.clonePointer(this), keyTypeTagArg, keyBytesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectId.lift(returnValue); + } + + toAddress(): Address { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_objectid_to_address([ + uniffiTypeObjectIdObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeAddress.lift(returnValue); + } + + toBytes(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_objectid_to_bytes([ + uniffiTypeObjectIdObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Returns the string representation of this object ID using the + * canonical display, with or without a `0x` prefix. + */toCanonicalString(withPrefix: boolean): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let withPrefixArg = FfiConverterBool.lower(withPrefix); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_objectid_to_canonical_string([ + uniffiTypeObjectIdObjectFactory.clonePointer(this), withPrefixArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + toHex(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_objectid_to_hex([ + uniffiTypeObjectIdObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Returns the shortest possible string representation of the object ID + * (i.e. with leading zeroes trimmed). + */toShortString(withPrefix: boolean): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let withPrefixArg = FfiConverterBool.lower(withPrefix); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_objectid_to_short_string([ + uniffiTypeObjectIdObjectFactory.clonePointer(this), withPrefixArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + toString(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_objectid_uniffi_trait_display([ + uniffiTypeObjectIdObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeObjectIdObjectFactory.pointer(this); + uniffiTypeObjectIdObjectFactory.freePointer(pointer); + uniffiTypeObjectIdObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is ObjectId { + return uniffiTypeObjectIdObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeObjectIdObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeObjectIdObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): ObjectId { + const instance = Object.create(ObjectId.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'ObjectId'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: ObjectId): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: ObjectId): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_objectid([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_objectid([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is ObjectId { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'ObjectId' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeObjectId = new FfiConverterObject( + uniffiTypeObjectIdObjectFactory +); + + +export type ObjectTypeInterface = { + asStruct(): StructTag; + asStructOpt(): StructTag | undefined; + isPackage(): boolean; + isStruct(): boolean; + +}; + + +/** + * Type of an IOTA object + */ +export class ObjectType extends UniffiAbstractObject implements ObjectTypeInterface { + readonly [uniffiTypeNameSymbol] = 'ObjectType'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static newPackage(): ObjectType { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_objecttype_new_package([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectType.lift(returnValue); + } + + static newStruct(structTag: StructTag): ObjectType { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let structTagArg = FfiConverterTypeStructTag.lower(structTag); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_objecttype_new_struct([ + structTagArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectType.lift(returnValue); + }// Methods: + + asStruct(): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_objecttype_as_struct([ + uniffiTypeObjectTypeObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + asStructOpt(): StructTag | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_objecttype_as_struct_opt([ + uniffiTypeObjectTypeObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeStructTag).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + isPackage(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_objecttype_is_package([ + uniffiTypeObjectTypeObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + isStruct(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_objecttype_is_struct([ + uniffiTypeObjectTypeObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + + // UniffiTrait implementations: + + toString(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_objecttype_uniffi_trait_display([ + uniffiTypeObjectTypeObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeObjectTypeObjectFactory.pointer(this); + uniffiTypeObjectTypeObjectFactory.freePointer(pointer); + uniffiTypeObjectTypeObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is ObjectType { + return uniffiTypeObjectTypeObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeObjectTypeObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeObjectTypeObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): ObjectType { + const instance = Object.create(ObjectType.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'ObjectType'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: ObjectType): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: ObjectType): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_objecttype([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_objecttype([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is ObjectType { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'ObjectType' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeObjectType = new FfiConverterObject( + uniffiTypeObjectTypeObjectFactory +); + + +export type OwnerInterface = { + asAddress(): Address; + asAddressOpt(): Address | undefined; + asObject(): ObjectId; + asObjectOpt(): ObjectId | undefined; + asShared(): /*u64*/bigint; + asSharedOpt(): /*u64*/bigint | undefined; + isAddress(): boolean; + isImmutable(): boolean; + isObject(): boolean; + isShared(): boolean; + +}; + + +/** + * Enum of different types of ownership for an object. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * owner = owner-address / owner-object / owner-shared / owner-immutable + * + * owner-address = %x00 address + * owner-object = %x01 object-id + * owner-shared = %x02 u64 + * owner-immutable = %x03 + * ``` + */ +export class Owner extends UniffiAbstractObject implements OwnerInterface { + readonly [uniffiTypeNameSymbol] = 'Owner'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static newAddress(address: Address): Owner { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let addressArg = FfiConverterTypeAddress.lower(address); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_owner_new_address([ + addressArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeOwner.lift(returnValue); + } + + static newImmutable(): Owner { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_owner_new_immutable([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeOwner.lift(returnValue); + } + + static newObject(id: ObjectId): Owner { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let idArg = FfiConverterTypeObjectId.lower(id); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_owner_new_object([ + idArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeOwner.lift(returnValue); + } + + static newShared(version: /*u64*/bigint): Owner { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let versionArg = FfiConverterUInt64.lower(version); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_owner_new_shared([ + versionArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeOwner.lift(returnValue); + }// Methods: + + asAddress(): Address { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_owner_as_address([ + uniffiTypeOwnerObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeAddress.lift(returnValue); + } + + asAddressOpt(): Address | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_owner_as_address_opt([ + uniffiTypeOwnerObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeAddress).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + asObject(): ObjectId { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_owner_as_object([ + uniffiTypeOwnerObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectId.lift(returnValue); + } + + asObjectOpt(): ObjectId | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_owner_as_object_opt([ + uniffiTypeOwnerObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeObjectId).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + asShared(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_owner_as_shared([ + uniffiTypeOwnerObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + asSharedOpt(): /*u64*/bigint | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_owner_as_shared_opt([ + uniffiTypeOwnerObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterUInt64).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + isAddress(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_owner_is_address([ + uniffiTypeOwnerObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + isImmutable(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_owner_is_immutable([ + uniffiTypeOwnerObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + isObject(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_owner_is_object([ + uniffiTypeOwnerObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + isShared(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_owner_is_shared([ + uniffiTypeOwnerObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + + // UniffiTrait implementations: + + toString(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_owner_uniffi_trait_display([ + uniffiTypeOwnerObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeOwnerObjectFactory.pointer(this); + uniffiTypeOwnerObjectFactory.freePointer(pointer); + uniffiTypeOwnerObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Owner { + return uniffiTypeOwnerObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeOwnerObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeOwnerObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Owner { + const instance = Object.create(Owner.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Owner'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Owner): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Owner): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_owner([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_owner([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Owner { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Owner' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeOwner = new FfiConverterObject( + uniffiTypeOwnerObjectFactory +); + + +export type PtbArgumentInterface = { + +}; + + +export class PtbArgument extends UniffiAbstractObject implements PtbArgumentInterface { + readonly [uniffiTypeNameSymbol] = 'PTBArgument'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static address(address: Address): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let addressArg = FfiConverterTypeAddress.lower(address); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_address([ + addressArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static addressFromHex(hex: string): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let hexArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(hex)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_address_from_hex([ + hexArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static addressVec(addresses: Array
): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let addressesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeAddress)).lower(addresses)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_address_vec([ + addressesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static addressVecFromHex(addresses: Array): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let addressesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterString)).lower(addresses)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_address_vec_from_hex([ + addressesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static assigned(name: string): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let nameArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(name)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_assigned([ + nameArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static bool(value: boolean): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valueArg = FfiConverterBool.lower(value); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_bool([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static boolVec(values: Array): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valuesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterBool)).lower(values)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_bool_vec([ + valuesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static digest(digest: Digest): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let digestArg = FfiConverterTypeDigest.lower(digest); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_digest([ + digestArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static digestFromBase58(base58: string): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let base58Arg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(base58)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_digest_from_base58([ + base58Arg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static digestVec(digests: Array): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let digestsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeDigest)).lower(digests)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_digest_vec([ + digestsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static digestVecFromBase58(digests: Array): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let digestsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterString)).lower(digests)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_digest_vec_from_base58([ + digestsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static gas(): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_gas([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static moveArg(arg: MoveArg): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let argArg = FfiConverterTypeMoveArg.lower(arg); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_move_arg([ + argArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static objectId(id: ObjectId): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let idArg = FfiConverterTypeObjectId.lower(id); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_object_id([ + idArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static objectIdFromHex(hex: string): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let hexArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(hex)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_object_id_from_hex([ + hexArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static objectRef(id: ObjectReference): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let idArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeObjectReference.lower(id)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_object_ref([ + idArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static option(value: MoveArg | undefined): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valueArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypeMoveArg).lower(value)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_option([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static receiving(id: ObjectId): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let idArg = FfiConverterTypeObjectId.lower(id); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_receiving([ + idArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static receivingFromHex(hex: string): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let hexArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(hex)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_receiving_from_hex([ + hexArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static shared(id: ObjectId): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let idArg = FfiConverterTypeObjectId.lower(id); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_shared([ + idArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static sharedFromHex(hex: string): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let hexArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(hex)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_shared_from_hex([ + hexArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static sharedMut(id: ObjectId): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let idArg = FfiConverterTypeObjectId.lower(id); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_shared_mut([ + idArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static sharedMutFromHex(hex: string): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let hexArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(hex)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_shared_mut_from_hex([ + hexArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static string(string: string): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let stringArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(string)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_string([ + stringArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static u128(value: string): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let valueArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(value)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u128([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static u128Vec(values: Array): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let valuesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterString)).lower(values)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u128_vec([ + valuesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static u16(value: /*u16*/number): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valueArg = FfiConverterUInt16.lower(value); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u16([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static u16Vec(values: Array): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valuesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterUInt16)).lower(values)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u16_vec([ + valuesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static u256(value: string): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let valueArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(value)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u256([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static u256Vec(values: Array): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let valuesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterString)).lower(values)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u256_vec([ + valuesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static u32(value: /*u32*/number): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valueArg = FfiConverterUInt32.lower(value); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u32([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static u32Vec(values: Array): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valuesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterUInt32)).lower(values)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u32_vec([ + valuesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static u64(value: /*u64*/bigint): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valueArg = FfiConverterUInt64.lower(value); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u64([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static u64Vec(values: Array): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valuesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterUInt64)).lower(values)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u64_vec([ + valuesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static u8(value: /*u8*/number): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valueArg = FfiConverterUInt8.lower(value); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u8([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + } + + static u8Vec(values: ArrayBuffer): PtbArgument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let valuesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(values)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u8_vec([ + valuesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePtbArgument.lift(returnValue); + }// Methods: + + + // UniffiTrait implementations: + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypePtbArgumentObjectFactory.pointer(this); + uniffiTypePtbArgumentObjectFactory.freePointer(pointer); + uniffiTypePtbArgumentObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is PtbArgument { + return uniffiTypePtbArgumentObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypePtbArgumentObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypePtbArgumentObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): PtbArgument { + const instance = Object.create(PtbArgument.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'PTBArgument'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: PtbArgument): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: PtbArgument): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_ptbargument([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_ptbargument([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is PtbArgument { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'PTBArgument' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypePtbArgument = new FfiConverterObject( + uniffiTypePtbArgumentObjectFactory +); + + +export type PasskeyAuthenticatorInterface = { + +/** + * Opaque authenticator data for this passkey signature. + * + * See + * for more information on this field. + */authenticatorData(): ArrayBuffer; + +/** + * The parsed challenge message for this passkey signature. + * + * This is parsed by decoding the base64url data from the + * `client_data_json.challenge` field. + */challenge(): ArrayBuffer; + +/** + * Structured, unparsed, JSON for this passkey signature. + * + * See + * for more information on this field. + */clientDataJson(): string; + +/** + * The passkey public key + */publicKey(): PasskeyPublicKey; + +/** + * The passkey signature. + */signature(): SimpleSignature; + +}; + + +/** + * A passkey authenticator. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * passkey-bcs = bytes ; where the contents of the bytes are + * ; defined by + * passkey = passkey-flag + * bytes ; passkey authenticator data + * client-data-json ; valid json + * simple-signature ; required to be a secp256r1 signature + * + * client-data-json = string ; valid json + * ``` + * + * See for + * the required json-schema for the `client-data-json` rule. In addition, IOTA + * currently requires that the `CollectedClientData.type` field is required to + * be `webauthn.get`. + * + * Note: Due to historical reasons, signatures are serialized slightly + * different from the majority of the types in IOTA. In particular if a + * signature is ever embedded in another structure it generally is serialized + * as `bytes` meaning it has a length prefix that defines the length of + * the completely serialized signature. + */ +export class PasskeyAuthenticator extends UniffiAbstractObject implements PasskeyAuthenticatorInterface { + readonly [uniffiTypeNameSymbol] = 'PasskeyAuthenticator'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + // Methods: + + +/** + * Opaque authenticator data for this passkey signature. + * + * See + * for more information on this field. + */authenticatorData(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_authenticator_data([ + uniffiTypePasskeyAuthenticatorObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * The parsed challenge message for this passkey signature. + * + * This is parsed by decoding the base64url data from the + * `client_data_json.challenge` field. + */challenge(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_challenge([ + uniffiTypePasskeyAuthenticatorObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Structured, unparsed, JSON for this passkey signature. + * + * See + * for more information on this field. + */clientDataJson(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_client_data_json([ + uniffiTypePasskeyAuthenticatorObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * The passkey public key + */publicKey(): PasskeyPublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_public_key([ + uniffiTypePasskeyAuthenticatorObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePasskeyPublicKey.lift(returnValue); + } + + +/** + * The passkey signature. + */signature(): SimpleSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_signature([ + uniffiTypePasskeyAuthenticatorObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSimpleSignature.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypePasskeyAuthenticatorObjectFactory.pointer(this); + uniffiTypePasskeyAuthenticatorObjectFactory.freePointer(pointer); + uniffiTypePasskeyAuthenticatorObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is PasskeyAuthenticator { + return uniffiTypePasskeyAuthenticatorObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypePasskeyAuthenticatorObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypePasskeyAuthenticatorObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): PasskeyAuthenticator { + const instance = Object.create(PasskeyAuthenticator.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'PasskeyAuthenticator'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: PasskeyAuthenticator): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: PasskeyAuthenticator): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_passkeyauthenticator([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_passkeyauthenticator([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is PasskeyAuthenticator { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'PasskeyAuthenticator' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypePasskeyAuthenticator = new FfiConverterObject( + uniffiTypePasskeyAuthenticatorObjectFactory +); + + +export type PasskeyPublicKeyInterface = { + +/** + * Derive an `Address` from this Passkey Public Key + * + * An `Address` can be derived from a `PasskeyPublicKey` by hashing the + * bytes of the `Secp256r1PublicKey` that corresponds to this passkey + * prefixed with the Passkey `SignatureScheme` flag (`0x06`). + * + * `hash( 0x06 || 33-byte secp256r1 public key)` + */deriveAddress(): Address; + inner(): Secp256r1PublicKey; + +}; + + +/** + * Public key of a `PasskeyAuthenticator`. + * + * This is used to derive the onchain `Address` for a `PasskeyAuthenticator`. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * passkey-public-key = passkey-flag secp256r1-public-key + * ``` + */ +export class PasskeyPublicKey extends UniffiAbstractObject implements PasskeyPublicKeyInterface { + readonly [uniffiTypeNameSymbol] = 'PasskeyPublicKey'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(publicKey: Secp256r1PublicKey) { + super(); + + let publicKeyArg = FfiConverterTypeSecp256r1PublicKey.lower(publicKey); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_passkeypublickey_new([ + publicKeyArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypePasskeyPublicKeyObjectFactory.bless(pointer); + }// Methods: + + +/** + * Derive an `Address` from this Passkey Public Key + * + * An `Address` can be derived from a `PasskeyPublicKey` by hashing the + * bytes of the `Secp256r1PublicKey` that corresponds to this passkey + * prefixed with the Passkey `SignatureScheme` flag (`0x06`). + * + * `hash( 0x06 || 33-byte secp256r1 public key)` + */deriveAddress(): Address { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_passkeypublickey_derive_address([ + uniffiTypePasskeyPublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeAddress.lift(returnValue); + } + + inner(): Secp256r1PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_passkeypublickey_inner([ + uniffiTypePasskeyPublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1PublicKey.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypePasskeyPublicKeyObjectFactory.pointer(this); + uniffiTypePasskeyPublicKeyObjectFactory.freePointer(pointer); + uniffiTypePasskeyPublicKeyObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is PasskeyPublicKey { + return uniffiTypePasskeyPublicKeyObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypePasskeyPublicKeyObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypePasskeyPublicKeyObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): PasskeyPublicKey { + const instance = Object.create(PasskeyPublicKey.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'PasskeyPublicKey'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: PasskeyPublicKey): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: PasskeyPublicKey): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_passkeypublickey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_passkeypublickey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is PasskeyPublicKey { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'PasskeyPublicKey' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypePasskeyPublicKey = new FfiConverterObject( + uniffiTypePasskeyPublicKeyObjectFactory +); + + +export type PasskeyVerifierInterface = { + verify(message: ArrayBuffer, authenticator: PasskeyAuthenticator): void; + +}; + + +export class PasskeyVerifier extends UniffiAbstractObject implements PasskeyVerifierInterface { + readonly [uniffiTypeNameSymbol] = 'PasskeyVerifier'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor() { + super(); + + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_passkeyverifier_new([ + callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypePasskeyVerifierObjectFactory.bless(pointer); + }// Methods: + + verify(message: ArrayBuffer, authenticator: PasskeyAuthenticator): void { + /* Regular function call: */ + uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + let authenticatorArg = FfiConverterTypePasskeyAuthenticator.lower(authenticator); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_passkeyverifier_verify([ + uniffiTypePasskeyVerifierObjectFactory.clonePointer(this), messageArg, authenticatorArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + + // UniffiTrait implementations: + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypePasskeyVerifierObjectFactory.pointer(this); + uniffiTypePasskeyVerifierObjectFactory.freePointer(pointer); + uniffiTypePasskeyVerifierObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is PasskeyVerifier { + return uniffiTypePasskeyVerifierObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypePasskeyVerifierObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypePasskeyVerifierObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): PasskeyVerifier { + const instance = Object.create(PasskeyVerifier.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'PasskeyVerifier'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: PasskeyVerifier): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: PasskeyVerifier): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_passkeyverifier([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_passkeyverifier([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is PasskeyVerifier { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'PasskeyVerifier' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypePasskeyVerifier = new FfiConverterObject( + uniffiTypePasskeyVerifierObjectFactory +); + + +export type PersonalMessageInterface = { + +/** + * Get the message as bytes. + */messageBytes(): ArrayBuffer; + +/** + * Get the signing digest as bytes. + */signingDigest(): ArrayBuffer; + +/** + * Get the signing digest as hex string. + */signingDigestHex(): string; + +}; + + +/** + * A personal message that wraps around a byte array. + */ +export class PersonalMessage extends UniffiAbstractObject implements PersonalMessageInterface { + readonly [uniffiTypeNameSymbol] = 'PersonalMessage'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + +/** + * Create a new personal message from bytes. + */ + constructor(messageBytes: ArrayBuffer) { + super(); + + let messageBytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(messageBytes)).toStruct(); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_personalmessage_new([ + messageBytesArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypePersonalMessageObjectFactory.bless(pointer); + }// Methods: + + +/** + * Get the message as bytes. + */messageBytes(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_personalmessage_message_bytes([ + uniffiTypePersonalMessageObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Get the signing digest as bytes. + */signingDigest(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_personalmessage_signing_digest([ + uniffiTypePersonalMessageObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Get the signing digest as hex string. + */signingDigestHex(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_personalmessage_signing_digest_hex([ + uniffiTypePersonalMessageObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypePersonalMessageObjectFactory.pointer(this); + uniffiTypePersonalMessageObjectFactory.freePointer(pointer); + uniffiTypePersonalMessageObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is PersonalMessage { + return uniffiTypePersonalMessageObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypePersonalMessageObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypePersonalMessageObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): PersonalMessage { + const instance = Object.create(PersonalMessage.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'PersonalMessage'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: PersonalMessage): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: PersonalMessage): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_personalmessage([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_personalmessage([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is PersonalMessage { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'PersonalMessage' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypePersonalMessage = new FfiConverterObject( + uniffiTypePersonalMessageObjectFactory +); + + +export type ProgrammableTransactionInterface = { + +/** + * The commands to be executed sequentially. A failure in any command will + * result in the failure of the entire transaction. + */commands(): Array; + +/** + * Input objects or primitive values + */inputs(): Array; + +}; + + +/** + * A user transaction + * + * Contains a series of native commands and move calls where the results of one + * command can be used in future commands. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * ptb = (vector input) (vector command) + * ``` + */ +export class ProgrammableTransaction extends UniffiAbstractObject implements ProgrammableTransactionInterface { + readonly [uniffiTypeNameSymbol] = 'ProgrammableTransaction'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(inputs: Array, commands: Array) { + super(); + + let inputsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeInput)).lower(inputs)).toStruct(); + let commandsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeCommand)).lower(commands)).toStruct(); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_programmabletransaction_new([ + inputsArg, commandsArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeProgrammableTransactionObjectFactory.bless(pointer); + }// Methods: + + +/** + * The commands to be executed sequentially. A failure in any command will + * result in the failure of the entire transaction. + */commands(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_programmabletransaction_commands([ + uniffiTypeProgrammableTransactionObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeCommand)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Input objects or primitive values + */inputs(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_programmabletransaction_inputs([ + uniffiTypeProgrammableTransactionObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeInput)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeProgrammableTransactionObjectFactory.pointer(this); + uniffiTypeProgrammableTransactionObjectFactory.freePointer(pointer); + uniffiTypeProgrammableTransactionObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is ProgrammableTransaction { + return uniffiTypeProgrammableTransactionObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeProgrammableTransactionObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeProgrammableTransactionObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): ProgrammableTransaction { + const instance = Object.create(ProgrammableTransaction.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'ProgrammableTransaction'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: ProgrammableTransaction): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: ProgrammableTransaction): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_programmabletransaction([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_programmabletransaction([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is ProgrammableTransaction { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'ProgrammableTransaction' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeProgrammableTransaction = new FfiConverterObject( + uniffiTypeProgrammableTransactionObjectFactory +); + + +export type PublishInterface = { + +/** + * Set of packages that the to-be published package depends on + */dependencies(): Array; + +/** + * The serialized move modules + */modules(): Array; + +}; + + +/** + * Command to publish a new move package + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * publish = (vector bytes) ; the serialized move modules + * (vector object-id) ; the set of package dependencies + * ``` + */ +export class Publish extends UniffiAbstractObject implements PublishInterface { + readonly [uniffiTypeNameSymbol] = 'Publish'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(modules: Array, dependencies: Array) { + super(); + + let modulesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterArrayBuffer)).lower(modules)).toStruct(); + let dependenciesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeObjectId)).lower(dependencies)).toStruct(); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_publish_new([ + modulesArg, dependenciesArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypePublishObjectFactory.bless(pointer); + }// Methods: + + +/** + * Set of packages that the to-be published package depends on + */dependencies(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_publish_dependencies([ + uniffiTypePublishObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeObjectId)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * The serialized move modules + */modules(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_publish_modules([ + uniffiTypePublishObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterArrayBuffer)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypePublishObjectFactory.pointer(this); + uniffiTypePublishObjectFactory.freePointer(pointer); + uniffiTypePublishObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Publish { + return uniffiTypePublishObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypePublishObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypePublishObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Publish { + const instance = Object.create(Publish.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Publish'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Publish): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Publish): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_publish([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_publish([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Publish { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Publish' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypePublish = new FfiConverterObject( + uniffiTypePublishObjectFactory +); + + +export type Secp256k1PrivateKeyInterface = { + publicKey(): Secp256k1PublicKey; + scheme(): SignatureScheme; + +/** + * Sign a personal message and return a UserSignature. + */signPersonalMessage(message: PersonalMessage): UserSignature; + +/** + * Sign a transaction and return a UserSignature. + */signTransaction(transaction: Transaction): UserSignature; + +/** + * Encode this private key as `flag || privkey` in Bech32 starting with + * "iotaprivkey" to a string. + */toBech32(): string; + +/** + * Serialize this private key to bytes. + */toBytes(): ArrayBuffer; + +/** + * Serialize this private key as DER-encoded PKCS#8 + */toDer(): ArrayBuffer; + +/** + * Serialize this private key as PEM-encoded PKCS#8 + */toPem(): string; + trySign(message: ArrayBuffer): Secp256k1Signature; + trySignSimple(message: ArrayBuffer): SimpleSignature; + trySignUser(message: ArrayBuffer): UserSignature; + verifyingKey(): Secp256k1VerifyingKey; + +}; + + +export class Secp256k1PrivateKey extends UniffiAbstractObject implements Secp256k1PrivateKeyInterface { + readonly [uniffiTypeNameSymbol] = 'Secp256k1PrivateKey'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + +/** + * Decode a private key from `flag || privkey` in Bech32 starting with + * "iotaprivkey". + */ + + static fromBech32(value: string): Secp256k1PrivateKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let valueArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(value)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256k1privatekey_from_bech32([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256k1PrivateKey.lift(returnValue); + } +/** + * Deserialize PKCS#8 private key from ASN.1 DER-encoded data (binary + * format). + */ + + static fromDer(bytes: ArrayBuffer): Secp256k1PrivateKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256k1privatekey_from_der([ + bytesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256k1PrivateKey.lift(returnValue); + } +/** + * Construct the private key from a mnemonic phrase + */ + + static fromMnemonic(phrase: string, accountIndex: /*u64*/bigint, password: string): Secp256k1PrivateKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let phraseArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(phrase)).toStruct(); + let accountIndexArg = FfiConverterUInt64.lower(accountIndex); + let passwordArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(password)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256k1privatekey_from_mnemonic([ + phraseArg, accountIndexArg, passwordArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256k1PrivateKey.lift(returnValue); + } +/** + * Create an instance from a mnemonic phrase and a derivation path like + * `"m/54'/4218'/0'/0/0"` + */ + + static fromMnemonicWithPath(phrase: string, path: string, password: string): Secp256k1PrivateKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let phraseArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(phrase)).toStruct(); + let pathArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(path)).toStruct(); + let passwordArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(password)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256k1privatekey_from_mnemonic_with_path([ + phraseArg, pathArg, passwordArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256k1PrivateKey.lift(returnValue); + } +/** + * Deserialize PKCS#8-encoded private key from PEM. + */ + + static fromPem(s: string): Secp256k1PrivateKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let sArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(s)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256k1privatekey_from_pem([ + sArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256k1PrivateKey.lift(returnValue); + } + + static generate(): Secp256k1PrivateKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256k1privatekey_generate([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256k1PrivateKey.lift(returnValue); + } + constructor(bytes: ArrayBuffer) { + super(); + + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + const pointer =uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256k1privatekey_new([ + bytesArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeSecp256k1PrivateKeyObjectFactory.bless(pointer); + }// Methods: + + publicKey(): Secp256k1PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_public_key([ + uniffiTypeSecp256k1PrivateKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256k1PublicKey.lift(returnValue); + } + + scheme(): SignatureScheme { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_scheme([ + uniffiTypeSecp256k1PrivateKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSignatureScheme.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Sign a personal message and return a UserSignature. + */signPersonalMessage(message: PersonalMessage): UserSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = FfiConverterTypePersonalMessage.lower(message); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_sign_personal_message([ + uniffiTypeSecp256k1PrivateKeyObjectFactory.clonePointer(this), messageArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUserSignature.lift(returnValue); + } + + +/** + * Sign a transaction and return a UserSignature. + */signTransaction(transaction: Transaction): UserSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let transactionArg = FfiConverterTypeTransaction.lower(transaction); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_sign_transaction([ + uniffiTypeSecp256k1PrivateKeyObjectFactory.clonePointer(this), transactionArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUserSignature.lift(returnValue); + } + + +/** + * Encode this private key as `flag || privkey` in Bech32 starting with + * "iotaprivkey" to a string. + */toBech32(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_to_bech32([ + uniffiTypeSecp256k1PrivateKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Serialize this private key to bytes. + */toBytes(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_to_bytes([ + uniffiTypeSecp256k1PrivateKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Serialize this private key as DER-encoded PKCS#8 + */toDer(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_to_der([ + uniffiTypeSecp256k1PrivateKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Serialize this private key as PEM-encoded PKCS#8 + */toPem(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_to_pem([ + uniffiTypeSecp256k1PrivateKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + trySign(message: ArrayBuffer): Secp256k1Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_try_sign([ + uniffiTypeSecp256k1PrivateKeyObjectFactory.clonePointer(this), messageArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256k1Signature.lift(returnValue); + } + + trySignSimple(message: ArrayBuffer): SimpleSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_try_sign_simple([ + uniffiTypeSecp256k1PrivateKeyObjectFactory.clonePointer(this), messageArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSimpleSignature.lift(returnValue); + } + + trySignUser(message: ArrayBuffer): UserSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_try_sign_user([ + uniffiTypeSecp256k1PrivateKeyObjectFactory.clonePointer(this), messageArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUserSignature.lift(returnValue); + } + + verifyingKey(): Secp256k1VerifyingKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_verifying_key([ + uniffiTypeSecp256k1PrivateKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256k1VerifyingKey.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeSecp256k1PrivateKeyObjectFactory.pointer(this); + uniffiTypeSecp256k1PrivateKeyObjectFactory.freePointer(pointer); + uniffiTypeSecp256k1PrivateKeyObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Secp256k1PrivateKey { + return uniffiTypeSecp256k1PrivateKeyObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeSecp256k1PrivateKeyObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeSecp256k1PrivateKeyObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Secp256k1PrivateKey { + const instance = Object.create(Secp256k1PrivateKey.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Secp256k1PrivateKey'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Secp256k1PrivateKey): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Secp256k1PrivateKey): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_secp256k1privatekey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_secp256k1privatekey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Secp256k1PrivateKey { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Secp256k1PrivateKey' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeSecp256k1PrivateKey = new FfiConverterObject( + uniffiTypeSecp256k1PrivateKeyObjectFactory +); + + +export type Secp256k1PublicKeyInterface = { + +/** + * Derive an `Address` from this Public Key + * + * An `Address` can be derived from a `Secp256k1PublicKey` by hashing the + * bytes of the public key prefixed with the Secp256k1 + * `SignatureScheme` flag (`0x01`). + * + * `hash( 0x01 || 33-byte secp256k1 public key)` + */deriveAddress(): Address; + +/** + * Returns the signature scheme for this public key. + */scheme(): SignatureScheme; + toBytes(): ArrayBuffer; + +/** + * Returns the bytes with signature scheme flag prepended. + */toFlaggedBytes(): ArrayBuffer; + +}; + + +/** + * A secp256k1 signature. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * secp256k1-signature = 64OCTET + * ``` + */ +export class Secp256k1PublicKey extends UniffiAbstractObject implements Secp256k1PublicKeyInterface { + readonly [uniffiTypeNameSymbol] = 'Secp256k1PublicKey'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static fromBytes(bytes: ArrayBuffer): Secp256k1PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256k1publickey_from_bytes([ + bytesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256k1PublicKey.lift(returnValue); + } + + static fromStr(s: string): Secp256k1PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let sArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(s)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256k1publickey_from_str([ + sArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256k1PublicKey.lift(returnValue); + } + + static generate(): Secp256k1PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256k1publickey_generate([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256k1PublicKey.lift(returnValue); + }// Methods: + + +/** + * Derive an `Address` from this Public Key + * + * An `Address` can be derived from a `Secp256k1PublicKey` by hashing the + * bytes of the public key prefixed with the Secp256k1 + * `SignatureScheme` flag (`0x01`). + * + * `hash( 0x01 || 33-byte secp256k1 public key)` + */deriveAddress(): Address { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256k1publickey_derive_address([ + uniffiTypeSecp256k1PublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeAddress.lift(returnValue); + } + + +/** + * Returns the signature scheme for this public key. + */scheme(): SignatureScheme { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256k1publickey_scheme([ + uniffiTypeSecp256k1PublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSignatureScheme.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + toBytes(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256k1publickey_to_bytes([ + uniffiTypeSecp256k1PublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Returns the bytes with signature scheme flag prepended. + */toFlaggedBytes(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256k1publickey_to_flagged_bytes([ + uniffiTypeSecp256k1PublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeSecp256k1PublicKeyObjectFactory.pointer(this); + uniffiTypeSecp256k1PublicKeyObjectFactory.freePointer(pointer); + uniffiTypeSecp256k1PublicKeyObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Secp256k1PublicKey { + return uniffiTypeSecp256k1PublicKeyObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeSecp256k1PublicKeyObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeSecp256k1PublicKeyObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Secp256k1PublicKey { + const instance = Object.create(Secp256k1PublicKey.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Secp256k1PublicKey'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Secp256k1PublicKey): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Secp256k1PublicKey): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_secp256k1publickey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_secp256k1publickey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Secp256k1PublicKey { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Secp256k1PublicKey' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeSecp256k1PublicKey = new FfiConverterObject( + uniffiTypeSecp256k1PublicKeyObjectFactory +); + + +export type Secp256k1SignatureInterface = { + toBytes(): ArrayBuffer; + +}; + + +/** + * A secp256k1 public key. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * secp256k1-public-key = 33OCTET + * ``` + */ +export class Secp256k1Signature extends UniffiAbstractObject implements Secp256k1SignatureInterface { + readonly [uniffiTypeNameSymbol] = 'Secp256k1Signature'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static fromBytes(bytes: ArrayBuffer): Secp256k1Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256k1signature_from_bytes([ + bytesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256k1Signature.lift(returnValue); + } + + static fromStr(s: string): Secp256k1Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let sArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(s)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256k1signature_from_str([ + sArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256k1Signature.lift(returnValue); + } + + static generate(): Secp256k1Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256k1signature_generate([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256k1Signature.lift(returnValue); + }// Methods: + + toBytes(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256k1signature_to_bytes([ + uniffiTypeSecp256k1SignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeSecp256k1SignatureObjectFactory.pointer(this); + uniffiTypeSecp256k1SignatureObjectFactory.freePointer(pointer); + uniffiTypeSecp256k1SignatureObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Secp256k1Signature { + return uniffiTypeSecp256k1SignatureObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeSecp256k1SignatureObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeSecp256k1SignatureObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Secp256k1Signature { + const instance = Object.create(Secp256k1Signature.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Secp256k1Signature'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Secp256k1Signature): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Secp256k1Signature): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_secp256k1signature([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_secp256k1signature([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Secp256k1Signature { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Secp256k1Signature' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeSecp256k1Signature = new FfiConverterObject( + uniffiTypeSecp256k1SignatureObjectFactory +); + + +export type Secp256k1VerifierInterface = { + verifySimple(message: ArrayBuffer, signature: SimpleSignature): void; + verifyUser(message: ArrayBuffer, signature: UserSignature): void; + +}; + + +export class Secp256k1Verifier extends UniffiAbstractObject implements Secp256k1VerifierInterface { + readonly [uniffiTypeNameSymbol] = 'Secp256k1Verifier'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor() { + super(); + + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256k1verifier_new([ + callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeSecp256k1VerifierObjectFactory.bless(pointer); + }// Methods: + + verifySimple(message: ArrayBuffer, signature: SimpleSignature): void { + /* Regular function call: */ + uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + let signatureArg = FfiConverterTypeSimpleSignature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256k1verifier_verify_simple([ + uniffiTypeSecp256k1VerifierObjectFactory.clonePointer(this), messageArg, signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + verifyUser(message: ArrayBuffer, signature: UserSignature): void { + /* Regular function call: */ + uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + let signatureArg = FfiConverterTypeUserSignature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256k1verifier_verify_user([ + uniffiTypeSecp256k1VerifierObjectFactory.clonePointer(this), messageArg, signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + + // UniffiTrait implementations: + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeSecp256k1VerifierObjectFactory.pointer(this); + uniffiTypeSecp256k1VerifierObjectFactory.freePointer(pointer); + uniffiTypeSecp256k1VerifierObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Secp256k1Verifier { + return uniffiTypeSecp256k1VerifierObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeSecp256k1VerifierObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeSecp256k1VerifierObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Secp256k1Verifier { + const instance = Object.create(Secp256k1Verifier.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Secp256k1Verifier'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Secp256k1Verifier): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Secp256k1Verifier): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_secp256k1verifier([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_secp256k1verifier([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Secp256k1Verifier { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Secp256k1Verifier' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeSecp256k1Verifier = new FfiConverterObject( + uniffiTypeSecp256k1VerifierObjectFactory +); + + +export type Secp256k1VerifyingKeyInterface = { + publicKey(): Secp256k1PublicKey; + +/** + * Serialize this public key as DER-encoded data + */toDer(): ArrayBuffer; + +/** + * Serialize this public key into PEM + */toPem(): string; + verify(message: ArrayBuffer, signature: Secp256k1Signature): void; + verifySimple(message: ArrayBuffer, signature: SimpleSignature): void; + verifyUser(message: ArrayBuffer, signature: UserSignature): void; + +}; + + +export class Secp256k1VerifyingKey extends UniffiAbstractObject implements Secp256k1VerifyingKeyInterface { + readonly [uniffiTypeNameSymbol] = 'Secp256k1VerifyingKey'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + +/** + * Deserialize public key from ASN.1 DER-encoded data (binary format). + */ + + static fromDer(bytes: ArrayBuffer): Secp256k1VerifyingKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256k1verifyingkey_from_der([ + bytesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256k1VerifyingKey.lift(returnValue); + } +/** + * Deserialize public key from PEM. + */ + + static fromPem(s: string): Secp256k1VerifyingKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let sArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(s)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256k1verifyingkey_from_pem([ + sArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256k1VerifyingKey.lift(returnValue); + } + constructor(publicKey: Secp256k1PublicKey) { + super(); + + let publicKeyArg = FfiConverterTypeSecp256k1PublicKey.lower(publicKey); + const pointer =uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256k1verifyingkey_new([ + publicKeyArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeSecp256k1VerifyingKeyObjectFactory.bless(pointer); + }// Methods: + + publicKey(): Secp256k1PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256k1verifyingkey_public_key([ + uniffiTypeSecp256k1VerifyingKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256k1PublicKey.lift(returnValue); + } + + +/** + * Serialize this public key as DER-encoded data + */toDer(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256k1verifyingkey_to_der([ + uniffiTypeSecp256k1VerifyingKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Serialize this public key into PEM + */toPem(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256k1verifyingkey_to_pem([ + uniffiTypeSecp256k1VerifyingKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + verify(message: ArrayBuffer, signature: Secp256k1Signature): void { + /* Regular function call: */ + uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + let signatureArg = FfiConverterTypeSecp256k1Signature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256k1verifyingkey_verify([ + uniffiTypeSecp256k1VerifyingKeyObjectFactory.clonePointer(this), messageArg, signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + verifySimple(message: ArrayBuffer, signature: SimpleSignature): void { + /* Regular function call: */ + uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + let signatureArg = FfiConverterTypeSimpleSignature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256k1verifyingkey_verify_simple([ + uniffiTypeSecp256k1VerifyingKeyObjectFactory.clonePointer(this), messageArg, signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + verifyUser(message: ArrayBuffer, signature: UserSignature): void { + /* Regular function call: */ + uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + let signatureArg = FfiConverterTypeUserSignature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256k1verifyingkey_verify_user([ + uniffiTypeSecp256k1VerifyingKeyObjectFactory.clonePointer(this), messageArg, signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeSecp256k1VerifyingKeyObjectFactory.pointer(this); + uniffiTypeSecp256k1VerifyingKeyObjectFactory.freePointer(pointer); + uniffiTypeSecp256k1VerifyingKeyObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Secp256k1VerifyingKey { + return uniffiTypeSecp256k1VerifyingKeyObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeSecp256k1VerifyingKeyObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeSecp256k1VerifyingKeyObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Secp256k1VerifyingKey { + const instance = Object.create(Secp256k1VerifyingKey.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Secp256k1VerifyingKey'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Secp256k1VerifyingKey): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Secp256k1VerifyingKey): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_secp256k1verifyingkey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_secp256k1verifyingkey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Secp256k1VerifyingKey { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Secp256k1VerifyingKey' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeSecp256k1VerifyingKey = new FfiConverterObject( + uniffiTypeSecp256k1VerifyingKeyObjectFactory +); + + +export type Secp256r1PrivateKeyInterface = { + +/** + * Get the public key corresponding to this private key. + */publicKey(): Secp256r1PublicKey; + scheme(): SignatureScheme; + +/** + * Sign a personal message and return a UserSignature. + */signPersonalMessage(message: PersonalMessage): UserSignature; + +/** + * Sign a transaction and return a UserSignature. + */signTransaction(transaction: Transaction): UserSignature; + +/** + * Encode this private key as `flag || privkey` in Bech32 starting with + * "iotaprivkey" to a string. + */toBech32(): string; + +/** + * Serialize this private key to bytes. + */toBytes(): ArrayBuffer; + +/** + * Serialize this private key as DER-encoded PKCS#8 + */toDer(): ArrayBuffer; + +/** + * Serialize this private key as PEM-encoded PKCS#8 + */toPem(): string; + +/** + * Sign a message and return a Secp256r1Signature. + */trySign(message: ArrayBuffer): Secp256r1Signature; + +/** + * Sign a message and return a SimpleSignature. + */trySignSimple(message: ArrayBuffer): SimpleSignature; + +/** + * Sign a message and return a UserSignature. + */trySignUser(message: ArrayBuffer): UserSignature; + verifyingKey(): Secp256r1VerifyingKey; + +}; + + +export class Secp256r1PrivateKey extends UniffiAbstractObject implements Secp256r1PrivateKeyInterface { + readonly [uniffiTypeNameSymbol] = 'Secp256r1PrivateKey'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + +/** + * Decode a private key from `flag || privkey` in Bech32 starting with + * "iotaprivkey". + */ + + static fromBech32(value: string): Secp256r1PrivateKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let valueArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(value)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256r1privatekey_from_bech32([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1PrivateKey.lift(returnValue); + } +/** + * Deserialize PKCS#8 private key from ASN.1 DER-encoded data (binary + * format). + */ + + static fromDer(bytes: ArrayBuffer): Secp256r1PrivateKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256r1privatekey_from_der([ + bytesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1PrivateKey.lift(returnValue); + } +/** + * Construct the private key from a mnemonic phrase + */ + + static fromMnemonic(phrase: string, accountIndex: /*u64*/bigint, password: string): Secp256r1PrivateKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let phraseArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(phrase)).toStruct(); + let accountIndexArg = FfiConverterUInt64.lower(accountIndex); + let passwordArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(password)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256r1privatekey_from_mnemonic([ + phraseArg, accountIndexArg, passwordArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1PrivateKey.lift(returnValue); + } +/** + * Create an instance from a mnemonic phrase and a derivation path like + * `"m/74'/4218'/0'/0/0"` + */ + + static fromMnemonicWithPath(phrase: string, path: string, password: string): Secp256r1PrivateKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let phraseArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(phrase)).toStruct(); + let pathArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(path)).toStruct(); + let passwordArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(password)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256r1privatekey_from_mnemonic_with_path([ + phraseArg, pathArg, passwordArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1PrivateKey.lift(returnValue); + } +/** + * Deserialize PKCS#8-encoded private key from PEM. + */ + + static fromPem(s: string): Secp256r1PrivateKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let sArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(s)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256r1privatekey_from_pem([ + sArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1PrivateKey.lift(returnValue); + } +/** + * Generate a new random Secp256r1PrivateKey + */ + + static generate(): Secp256r1PrivateKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256r1privatekey_generate([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1PrivateKey.lift(returnValue); + } + constructor(bytes: ArrayBuffer) { + super(); + + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + const pointer =uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256r1privatekey_new([ + bytesArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeSecp256r1PrivateKeyObjectFactory.bless(pointer); + }// Methods: + + +/** + * Get the public key corresponding to this private key. + */publicKey(): Secp256r1PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_public_key([ + uniffiTypeSecp256r1PrivateKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1PublicKey.lift(returnValue); + } + + scheme(): SignatureScheme { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_scheme([ + uniffiTypeSecp256r1PrivateKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSignatureScheme.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Sign a personal message and return a UserSignature. + */signPersonalMessage(message: PersonalMessage): UserSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = FfiConverterTypePersonalMessage.lower(message); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_sign_personal_message([ + uniffiTypeSecp256r1PrivateKeyObjectFactory.clonePointer(this), messageArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUserSignature.lift(returnValue); + } + + +/** + * Sign a transaction and return a UserSignature. + */signTransaction(transaction: Transaction): UserSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let transactionArg = FfiConverterTypeTransaction.lower(transaction); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_sign_transaction([ + uniffiTypeSecp256r1PrivateKeyObjectFactory.clonePointer(this), transactionArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUserSignature.lift(returnValue); + } + + +/** + * Encode this private key as `flag || privkey` in Bech32 starting with + * "iotaprivkey" to a string. + */toBech32(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_to_bech32([ + uniffiTypeSecp256r1PrivateKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Serialize this private key to bytes. + */toBytes(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_to_bytes([ + uniffiTypeSecp256r1PrivateKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Serialize this private key as DER-encoded PKCS#8 + */toDer(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_to_der([ + uniffiTypeSecp256r1PrivateKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Serialize this private key as PEM-encoded PKCS#8 + */toPem(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_to_pem([ + uniffiTypeSecp256r1PrivateKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Sign a message and return a Secp256r1Signature. + */trySign(message: ArrayBuffer): Secp256r1Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_try_sign([ + uniffiTypeSecp256r1PrivateKeyObjectFactory.clonePointer(this), messageArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1Signature.lift(returnValue); + } + + +/** + * Sign a message and return a SimpleSignature. + */trySignSimple(message: ArrayBuffer): SimpleSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_try_sign_simple([ + uniffiTypeSecp256r1PrivateKeyObjectFactory.clonePointer(this), messageArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSimpleSignature.lift(returnValue); + } + + +/** + * Sign a message and return a UserSignature. + */trySignUser(message: ArrayBuffer): UserSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_try_sign_user([ + uniffiTypeSecp256r1PrivateKeyObjectFactory.clonePointer(this), messageArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUserSignature.lift(returnValue); + } + + verifyingKey(): Secp256r1VerifyingKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_verifying_key([ + uniffiTypeSecp256r1PrivateKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1VerifyingKey.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeSecp256r1PrivateKeyObjectFactory.pointer(this); + uniffiTypeSecp256r1PrivateKeyObjectFactory.freePointer(pointer); + uniffiTypeSecp256r1PrivateKeyObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Secp256r1PrivateKey { + return uniffiTypeSecp256r1PrivateKeyObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeSecp256r1PrivateKeyObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeSecp256r1PrivateKeyObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Secp256r1PrivateKey { + const instance = Object.create(Secp256r1PrivateKey.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Secp256r1PrivateKey'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Secp256r1PrivateKey): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Secp256r1PrivateKey): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_secp256r1privatekey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_secp256r1privatekey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Secp256r1PrivateKey { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Secp256r1PrivateKey' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeSecp256r1PrivateKey = new FfiConverterObject( + uniffiTypeSecp256r1PrivateKeyObjectFactory +); + + +export type Secp256r1PublicKeyInterface = { + +/** + * Derive an `Address` from this Public Key + * + * An `Address` can be derived from a `Secp256r1PublicKey` by hashing the + * bytes of the public key prefixed with the Secp256r1 + * `SignatureScheme` flag (`0x02`). + * + * `hash( 0x02 || 33-byte secp256r1 public key)` + */deriveAddress(): Address; + +/** + * Returns the signature scheme for this public key. + */scheme(): SignatureScheme; + toBytes(): ArrayBuffer; + +/** + * Returns the bytes with signature scheme flag prepended + */toFlaggedBytes(): ArrayBuffer; + +}; + + +/** + * A secp256r1 signature. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * secp256r1-signature = 64OCTET + * ``` + */ +export class Secp256r1PublicKey extends UniffiAbstractObject implements Secp256r1PublicKeyInterface { + readonly [uniffiTypeNameSymbol] = 'Secp256r1PublicKey'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static fromBytes(bytes: ArrayBuffer): Secp256r1PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256r1publickey_from_bytes([ + bytesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1PublicKey.lift(returnValue); + } + + static fromStr(s: string): Secp256r1PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let sArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(s)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256r1publickey_from_str([ + sArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1PublicKey.lift(returnValue); + } + + static generate(): Secp256r1PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256r1publickey_generate([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1PublicKey.lift(returnValue); + }// Methods: + + +/** + * Derive an `Address` from this Public Key + * + * An `Address` can be derived from a `Secp256r1PublicKey` by hashing the + * bytes of the public key prefixed with the Secp256r1 + * `SignatureScheme` flag (`0x02`). + * + * `hash( 0x02 || 33-byte secp256r1 public key)` + */deriveAddress(): Address { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256r1publickey_derive_address([ + uniffiTypeSecp256r1PublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeAddress.lift(returnValue); + } + + +/** + * Returns the signature scheme for this public key. + */scheme(): SignatureScheme { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256r1publickey_scheme([ + uniffiTypeSecp256r1PublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSignatureScheme.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + toBytes(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256r1publickey_to_bytes([ + uniffiTypeSecp256r1PublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Returns the bytes with signature scheme flag prepended + */toFlaggedBytes(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256r1publickey_to_flagged_bytes([ + uniffiTypeSecp256r1PublicKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeSecp256r1PublicKeyObjectFactory.pointer(this); + uniffiTypeSecp256r1PublicKeyObjectFactory.freePointer(pointer); + uniffiTypeSecp256r1PublicKeyObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Secp256r1PublicKey { + return uniffiTypeSecp256r1PublicKeyObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeSecp256r1PublicKeyObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeSecp256r1PublicKeyObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Secp256r1PublicKey { + const instance = Object.create(Secp256r1PublicKey.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Secp256r1PublicKey'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Secp256r1PublicKey): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Secp256r1PublicKey): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_secp256r1publickey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_secp256r1publickey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Secp256r1PublicKey { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Secp256r1PublicKey' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeSecp256r1PublicKey = new FfiConverterObject( + uniffiTypeSecp256r1PublicKeyObjectFactory +); + + +export type Secp256r1SignatureInterface = { + toBytes(): ArrayBuffer; + +}; + + +/** + * A secp256r1 public key. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * secp256r1-public-key = 33OCTET + * ``` + */ +export class Secp256r1Signature extends UniffiAbstractObject implements Secp256r1SignatureInterface { + readonly [uniffiTypeNameSymbol] = 'Secp256r1Signature'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static fromBytes(bytes: ArrayBuffer): Secp256r1Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256r1signature_from_bytes([ + bytesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1Signature.lift(returnValue); + } + + static fromStr(s: string): Secp256r1Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let sArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(s)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256r1signature_from_str([ + sArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1Signature.lift(returnValue); + } + + static generate(): Secp256r1Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256r1signature_generate([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1Signature.lift(returnValue); + }// Methods: + + toBytes(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256r1signature_to_bytes([ + uniffiTypeSecp256r1SignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeSecp256r1SignatureObjectFactory.pointer(this); + uniffiTypeSecp256r1SignatureObjectFactory.freePointer(pointer); + uniffiTypeSecp256r1SignatureObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Secp256r1Signature { + return uniffiTypeSecp256r1SignatureObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeSecp256r1SignatureObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeSecp256r1SignatureObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Secp256r1Signature { + const instance = Object.create(Secp256r1Signature.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Secp256r1Signature'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Secp256r1Signature): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Secp256r1Signature): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_secp256r1signature([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_secp256r1signature([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Secp256r1Signature { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Secp256r1Signature' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeSecp256r1Signature = new FfiConverterObject( + uniffiTypeSecp256r1SignatureObjectFactory +); + + +export type Secp256r1VerifierInterface = { + verifySimple(message: ArrayBuffer, signature: SimpleSignature): void; + verifyUser(message: ArrayBuffer, signature: UserSignature): void; + +}; + + +export class Secp256r1Verifier extends UniffiAbstractObject implements Secp256r1VerifierInterface { + readonly [uniffiTypeNameSymbol] = 'Secp256r1Verifier'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor() { + super(); + + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256r1verifier_new([ + callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeSecp256r1VerifierObjectFactory.bless(pointer); + }// Methods: + + verifySimple(message: ArrayBuffer, signature: SimpleSignature): void { + /* Regular function call: */ + uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + let signatureArg = FfiConverterTypeSimpleSignature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256r1verifier_verify_simple([ + uniffiTypeSecp256r1VerifierObjectFactory.clonePointer(this), messageArg, signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + verifyUser(message: ArrayBuffer, signature: UserSignature): void { + /* Regular function call: */ + uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + let signatureArg = FfiConverterTypeUserSignature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256r1verifier_verify_user([ + uniffiTypeSecp256r1VerifierObjectFactory.clonePointer(this), messageArg, signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + + // UniffiTrait implementations: + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeSecp256r1VerifierObjectFactory.pointer(this); + uniffiTypeSecp256r1VerifierObjectFactory.freePointer(pointer); + uniffiTypeSecp256r1VerifierObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Secp256r1Verifier { + return uniffiTypeSecp256r1VerifierObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeSecp256r1VerifierObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeSecp256r1VerifierObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Secp256r1Verifier { + const instance = Object.create(Secp256r1Verifier.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Secp256r1Verifier'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Secp256r1Verifier): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Secp256r1Verifier): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_secp256r1verifier([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_secp256r1verifier([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Secp256r1Verifier { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Secp256r1Verifier' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeSecp256r1Verifier = new FfiConverterObject( + uniffiTypeSecp256r1VerifierObjectFactory +); + + +export type Secp256r1VerifyingKeyInterface = { + publicKey(): Secp256r1PublicKey; + +/** + * Serialize this public key as DER-encoded data. + */toDer(): ArrayBuffer; + +/** + * Serialize this public key into PEM. + */toPem(): string; + verify(message: ArrayBuffer, signature: Secp256r1Signature): void; + verifySimple(message: ArrayBuffer, signature: SimpleSignature): void; + verifyUser(message: ArrayBuffer, signature: UserSignature): void; + +}; + + +export class Secp256r1VerifyingKey extends UniffiAbstractObject implements Secp256r1VerifyingKeyInterface { + readonly [uniffiTypeNameSymbol] = 'Secp256r1VerifyingKey'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + +/** + * Deserialize public key from ASN.1 DER-encoded data (binary format). + */ + + static fromDer(bytes: ArrayBuffer): Secp256r1VerifyingKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256r1verifyingkey_from_der([ + bytesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1VerifyingKey.lift(returnValue); + } +/** + * Deserialize public key from PEM. + */ + + static fromPem(s: string): Secp256r1VerifyingKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let sArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(s)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256r1verifyingkey_from_pem([ + sArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1VerifyingKey.lift(returnValue); + } + constructor(publicKey: Secp256r1PublicKey) { + super(); + + let publicKeyArg = FfiConverterTypeSecp256r1PublicKey.lower(publicKey); + const pointer =uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_secp256r1verifyingkey_new([ + publicKeyArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeSecp256r1VerifyingKeyObjectFactory.bless(pointer); + }// Methods: + + publicKey(): Secp256r1PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256r1verifyingkey_public_key([ + uniffiTypeSecp256r1VerifyingKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1PublicKey.lift(returnValue); + } + + +/** + * Serialize this public key as DER-encoded data. + */toDer(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256r1verifyingkey_to_der([ + uniffiTypeSecp256r1VerifyingKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Serialize this public key into PEM. + */toPem(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256r1verifyingkey_to_pem([ + uniffiTypeSecp256r1VerifyingKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + verify(message: ArrayBuffer, signature: Secp256r1Signature): void { + /* Regular function call: */ + uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + let signatureArg = FfiConverterTypeSecp256r1Signature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256r1verifyingkey_verify([ + uniffiTypeSecp256r1VerifyingKeyObjectFactory.clonePointer(this), messageArg, signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + verifySimple(message: ArrayBuffer, signature: SimpleSignature): void { + /* Regular function call: */ + uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + let signatureArg = FfiConverterTypeSimpleSignature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256r1verifyingkey_verify_simple([ + uniffiTypeSecp256r1VerifyingKeyObjectFactory.clonePointer(this), messageArg, signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + verifyUser(message: ArrayBuffer, signature: UserSignature): void { + /* Regular function call: */ + uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + let signatureArg = FfiConverterTypeUserSignature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_secp256r1verifyingkey_verify_user([ + uniffiTypeSecp256r1VerifyingKeyObjectFactory.clonePointer(this), messageArg, signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeSecp256r1VerifyingKeyObjectFactory.pointer(this); + uniffiTypeSecp256r1VerifyingKeyObjectFactory.freePointer(pointer); + uniffiTypeSecp256r1VerifyingKeyObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Secp256r1VerifyingKey { + return uniffiTypeSecp256r1VerifyingKeyObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeSecp256r1VerifyingKeyObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeSecp256r1VerifyingKeyObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Secp256r1VerifyingKey { + const instance = Object.create(Secp256r1VerifyingKey.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Secp256r1VerifyingKey'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Secp256r1VerifyingKey): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Secp256r1VerifyingKey): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_secp256r1verifyingkey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_secp256r1verifyingkey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Secp256r1VerifyingKey { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Secp256r1VerifyingKey' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeSecp256r1VerifyingKey = new FfiConverterObject( + uniffiTypeSecp256r1VerifyingKeyObjectFactory +); + + +export type SimpleKeypairInterface = { + publicKey(): MultisigMemberPublicKey; + scheme(): SignatureScheme; + +/** + * Sign a personal message and return a UserSignature. + */signPersonalMessage(message: PersonalMessage): UserSignature; + +/** + * Sign a transaction and return a UserSignature. + */signTransaction(transaction: Transaction): UserSignature; + +/** + * Encode a SimpleKeypair as `flag || privkey` in Bech32 starting with + * "iotaprivkey" to a string. Note that the pubkey is not encoded. + */toBech32(): string; + +/** + * Encode a SimpleKeypair as `flag || privkey` in bytes + */toBytes(): ArrayBuffer; + +/** + * Serialize this private key as DER-encoded PKCS#8 + */toDer(): ArrayBuffer; + +/** + * Serialize this private key as DER-encoded PKCS#8 + */toPem(): string; + trySign(message: ArrayBuffer): SimpleSignature; + trySignUser(message: ArrayBuffer): UserSignature; + verifyingKey(): SimpleVerifyingKey; + +}; + + +export class SimpleKeypair extends UniffiAbstractObject implements SimpleKeypairInterface { + readonly [uniffiTypeNameSymbol] = 'SimpleKeypair'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + +/** + * Decode a SimpleKeypair from `flag || privkey` in Bech32 starting with + * "iotaprivkey" to SimpleKeypair. The public key is computed directly from + * the private key bytes. + */ + + static fromBech32(value: string): SimpleKeypair { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let valueArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(value)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_simplekeypair_from_bech32([ + valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSimpleKeypair.lift(returnValue); + } +/** + * Decode a SimpleKeypair from `flag || privkey` bytes + */ + + static fromBytes(bytes: ArrayBuffer): SimpleKeypair { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_simplekeypair_from_bytes([ + bytesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSimpleKeypair.lift(returnValue); + } +/** + * Deserialize PKCS#8 private key from ASN.1 DER-encoded data (binary + * format). + */ + + static fromDer(bytes: ArrayBuffer): SimpleKeypair { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_simplekeypair_from_der([ + bytesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSimpleKeypair.lift(returnValue); + } + + static fromEd25519(keypair: Ed25519PrivateKey): SimpleKeypair { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let keypairArg = FfiConverterTypeEd25519PrivateKey.lower(keypair); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_simplekeypair_from_ed25519([ + keypairArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSimpleKeypair.lift(returnValue); + } +/** + * Deserialize PKCS#8-encoded private key from PEM. + */ + + static fromPem(s: string): SimpleKeypair { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let sArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(s)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_simplekeypair_from_pem([ + sArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSimpleKeypair.lift(returnValue); + } + + static fromSecp256k1(keypair: Secp256k1PrivateKey): SimpleKeypair { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let keypairArg = FfiConverterTypeSecp256k1PrivateKey.lower(keypair); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_simplekeypair_from_secp256k1([ + keypairArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSimpleKeypair.lift(returnValue); + } + + static fromSecp256r1(keypair: Secp256r1PrivateKey): SimpleKeypair { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let keypairArg = FfiConverterTypeSecp256r1PrivateKey.lower(keypair); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_simplekeypair_from_secp256r1([ + keypairArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSimpleKeypair.lift(returnValue); + }// Methods: + + publicKey(): MultisigMemberPublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplekeypair_public_key([ + uniffiTypeSimpleKeypairObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMultisigMemberPublicKey.lift(returnValue); + } + + scheme(): SignatureScheme { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplekeypair_scheme([ + uniffiTypeSimpleKeypairObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSignatureScheme.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Sign a personal message and return a UserSignature. + */signPersonalMessage(message: PersonalMessage): UserSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = FfiConverterTypePersonalMessage.lower(message); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplekeypair_sign_personal_message([ + uniffiTypeSimpleKeypairObjectFactory.clonePointer(this), messageArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUserSignature.lift(returnValue); + } + + +/** + * Sign a transaction and return a UserSignature. + */signTransaction(transaction: Transaction): UserSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let transactionArg = FfiConverterTypeTransaction.lower(transaction); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplekeypair_sign_transaction([ + uniffiTypeSimpleKeypairObjectFactory.clonePointer(this), transactionArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUserSignature.lift(returnValue); + } + + +/** + * Encode a SimpleKeypair as `flag || privkey` in Bech32 starting with + * "iotaprivkey" to a string. Note that the pubkey is not encoded. + */toBech32(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplekeypair_to_bech32([ + uniffiTypeSimpleKeypairObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Encode a SimpleKeypair as `flag || privkey` in bytes + */toBytes(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplekeypair_to_bytes([ + uniffiTypeSimpleKeypairObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Serialize this private key as DER-encoded PKCS#8 + */toDer(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplekeypair_to_der([ + uniffiTypeSimpleKeypairObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Serialize this private key as DER-encoded PKCS#8 + */toPem(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplekeypair_to_pem([ + uniffiTypeSimpleKeypairObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + trySign(message: ArrayBuffer): SimpleSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplekeypair_try_sign([ + uniffiTypeSimpleKeypairObjectFactory.clonePointer(this), messageArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSimpleSignature.lift(returnValue); + } + + trySignUser(message: ArrayBuffer): UserSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplekeypair_try_sign_user([ + uniffiTypeSimpleKeypairObjectFactory.clonePointer(this), messageArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUserSignature.lift(returnValue); + } + + verifyingKey(): SimpleVerifyingKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplekeypair_verifying_key([ + uniffiTypeSimpleKeypairObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSimpleVerifyingKey.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeSimpleKeypairObjectFactory.pointer(this); + uniffiTypeSimpleKeypairObjectFactory.freePointer(pointer); + uniffiTypeSimpleKeypairObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is SimpleKeypair { + return uniffiTypeSimpleKeypairObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeSimpleKeypairObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeSimpleKeypairObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): SimpleKeypair { + const instance = Object.create(SimpleKeypair.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'SimpleKeypair'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: SimpleKeypair): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: SimpleKeypair): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_simplekeypair([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_simplekeypair([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is SimpleKeypair { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'SimpleKeypair' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeSimpleKeypair = new FfiConverterObject( + uniffiTypeSimpleKeypairObjectFactory +); + + +export type SimpleSignatureInterface = { + ed25519PubKey(): Ed25519PublicKey; + ed25519PubKeyOpt(): Ed25519PublicKey | undefined; + ed25519Sig(): Ed25519Signature; + ed25519SigOpt(): Ed25519Signature | undefined; + isEd25519(): boolean; + isSecp256k1(): boolean; + isSecp256r1(): boolean; + scheme(): SignatureScheme; + secp256k1PubKey(): Secp256k1PublicKey; + secp256k1PubKeyOpt(): Secp256k1PublicKey | undefined; + secp256k1Sig(): Secp256k1Signature; + secp256k1SigOpt(): Secp256k1Signature | undefined; + secp256r1PubKey(): Secp256r1PublicKey; + secp256r1PubKeyOpt(): Secp256r1PublicKey | undefined; + secp256r1Sig(): Secp256r1Signature; + secp256r1SigOpt(): Secp256r1Signature | undefined; + toBytes(): ArrayBuffer; + +}; + + +/** + * A basic signature + * + * This enumeration defines the set of simple or basic signature schemes + * supported by IOTA. Most signature schemes supported by IOTA end up + * comprising of a at least one simple signature scheme. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * simple-signature-bcs = bytes ; where the contents of the bytes are defined by + * simple-signature = (ed25519-flag ed25519-signature ed25519-public-key) / + * (secp256k1-flag secp256k1-signature secp256k1-public-key) / + * (secp256r1-flag secp256r1-signature secp256r1-public-key) + * ``` + * + * Note: Due to historical reasons, signatures are serialized slightly + * different from the majority of the types in IOTA. In particular if a + * signature is ever embedded in another structure it generally is serialized + * as `bytes` meaning it has a length prefix that defines the length of + * the completely serialized signature. + */ +export class SimpleSignature extends UniffiAbstractObject implements SimpleSignatureInterface { + readonly [uniffiTypeNameSymbol] = 'SimpleSignature'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static newEd25519(signature: Ed25519Signature, publicKey: Ed25519PublicKey): SimpleSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let signatureArg = FfiConverterTypeEd25519Signature.lower(signature); + let publicKeyArg = FfiConverterTypeEd25519PublicKey.lower(publicKey); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_simplesignature_new_ed25519([ + signatureArg, publicKeyArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSimpleSignature.lift(returnValue); + } + + static newSecp256k1(signature: Secp256k1Signature, publicKey: Secp256k1PublicKey): SimpleSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let signatureArg = FfiConverterTypeSecp256k1Signature.lower(signature); + let publicKeyArg = FfiConverterTypeSecp256k1PublicKey.lower(publicKey); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_simplesignature_new_secp256k1([ + signatureArg, publicKeyArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSimpleSignature.lift(returnValue); + } + + static newSecp256r1(signature: Secp256r1Signature, publicKey: Secp256r1PublicKey): SimpleSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let signatureArg = FfiConverterTypeSecp256r1Signature.lower(signature); + let publicKeyArg = FfiConverterTypeSecp256r1PublicKey.lower(publicKey); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_simplesignature_new_secp256r1([ + signatureArg, publicKeyArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSimpleSignature.lift(returnValue); + }// Methods: + + ed25519PubKey(): Ed25519PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplesignature_ed25519_pub_key([ + uniffiTypeSimpleSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEd25519PublicKey.lift(returnValue); + } + + ed25519PubKeyOpt(): Ed25519PublicKey | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplesignature_ed25519_pub_key_opt([ + uniffiTypeSimpleSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeEd25519PublicKey).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + ed25519Sig(): Ed25519Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplesignature_ed25519_sig([ + uniffiTypeSimpleSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEd25519Signature.lift(returnValue); + } + + ed25519SigOpt(): Ed25519Signature | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplesignature_ed25519_sig_opt([ + uniffiTypeSimpleSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeEd25519Signature).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + isEd25519(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplesignature_is_ed25519([ + uniffiTypeSimpleSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + isSecp256k1(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplesignature_is_secp256k1([ + uniffiTypeSimpleSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + isSecp256r1(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplesignature_is_secp256r1([ + uniffiTypeSimpleSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + scheme(): SignatureScheme { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplesignature_scheme([ + uniffiTypeSimpleSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSignatureScheme.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + secp256k1PubKey(): Secp256k1PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256k1_pub_key([ + uniffiTypeSimpleSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256k1PublicKey.lift(returnValue); + } + + secp256k1PubKeyOpt(): Secp256k1PublicKey | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256k1_pub_key_opt([ + uniffiTypeSimpleSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeSecp256k1PublicKey).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + secp256k1Sig(): Secp256k1Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256k1_sig([ + uniffiTypeSimpleSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256k1Signature.lift(returnValue); + } + + secp256k1SigOpt(): Secp256k1Signature | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256k1_sig_opt([ + uniffiTypeSimpleSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeSecp256k1Signature).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + secp256r1PubKey(): Secp256r1PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256r1_pub_key([ + uniffiTypeSimpleSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1PublicKey.lift(returnValue); + } + + secp256r1PubKeyOpt(): Secp256r1PublicKey | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256r1_pub_key_opt([ + uniffiTypeSimpleSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeSecp256r1PublicKey).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + secp256r1Sig(): Secp256r1Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256r1_sig([ + uniffiTypeSimpleSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1Signature.lift(returnValue); + } + + secp256r1SigOpt(): Secp256r1Signature | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256r1_sig_opt([ + uniffiTypeSimpleSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeSecp256r1Signature).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + toBytes(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simplesignature_to_bytes([ + uniffiTypeSimpleSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeSimpleSignatureObjectFactory.pointer(this); + uniffiTypeSimpleSignatureObjectFactory.freePointer(pointer); + uniffiTypeSimpleSignatureObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is SimpleSignature { + return uniffiTypeSimpleSignatureObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeSimpleSignatureObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeSimpleSignatureObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): SimpleSignature { + const instance = Object.create(SimpleSignature.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'SimpleSignature'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: SimpleSignature): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: SimpleSignature): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_simplesignature([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_simplesignature([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is SimpleSignature { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'SimpleSignature' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeSimpleSignature = new FfiConverterObject( + uniffiTypeSimpleSignatureObjectFactory +); + + +export type SimpleVerifierInterface = { + verify(message: ArrayBuffer, signature: SimpleSignature): void; + +}; + + +export class SimpleVerifier extends UniffiAbstractObject implements SimpleVerifierInterface { + readonly [uniffiTypeNameSymbol] = 'SimpleVerifier'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor() { + super(); + + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_simpleverifier_new([ + callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeSimpleVerifierObjectFactory.bless(pointer); + }// Methods: + + verify(message: ArrayBuffer, signature: SimpleSignature): void { + /* Regular function call: */ + uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + let signatureArg = FfiConverterTypeSimpleSignature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simpleverifier_verify([ + uniffiTypeSimpleVerifierObjectFactory.clonePointer(this), messageArg, signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + + // UniffiTrait implementations: + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeSimpleVerifierObjectFactory.pointer(this); + uniffiTypeSimpleVerifierObjectFactory.freePointer(pointer); + uniffiTypeSimpleVerifierObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is SimpleVerifier { + return uniffiTypeSimpleVerifierObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeSimpleVerifierObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeSimpleVerifierObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): SimpleVerifier { + const instance = Object.create(SimpleVerifier.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'SimpleVerifier'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: SimpleVerifier): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: SimpleVerifier): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_simpleverifier([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_simpleverifier([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is SimpleVerifier { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'SimpleVerifier' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeSimpleVerifier = new FfiConverterObject( + uniffiTypeSimpleVerifierObjectFactory +); + + +export type SimpleVerifyingKeyInterface = { + publicKey(): MultisigMemberPublicKey; + scheme(): SignatureScheme; + +/** + * Serialize this private key as DER-encoded PKCS#8 + */toDer(): ArrayBuffer; + +/** + * Serialize this private key as DER-encoded PKCS#8 + */toPem(): string; + verify(message: ArrayBuffer, signature: SimpleSignature): void; + +}; + + +export class SimpleVerifyingKey extends UniffiAbstractObject implements SimpleVerifyingKeyInterface { + readonly [uniffiTypeNameSymbol] = 'SimpleVerifyingKey'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + +/** + * Deserialize PKCS#8 private key from ASN.1 DER-encoded data (binary + * format). + */ + + static fromDer(bytes: ArrayBuffer): SimpleVerifyingKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_simpleverifyingkey_from_der([ + bytesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSimpleVerifyingKey.lift(returnValue); + } +/** + * Deserialize PKCS#8-encoded private key from PEM. + */ + + static fromPem(s: string): SimpleVerifyingKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let sArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(s)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_simpleverifyingkey_from_pem([ + sArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSimpleVerifyingKey.lift(returnValue); + }// Methods: + + publicKey(): MultisigMemberPublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simpleverifyingkey_public_key([ + uniffiTypeSimpleVerifyingKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMultisigMemberPublicKey.lift(returnValue); + } + + scheme(): SignatureScheme { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simpleverifyingkey_scheme([ + uniffiTypeSimpleVerifyingKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSignatureScheme.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Serialize this private key as DER-encoded PKCS#8 + */toDer(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simpleverifyingkey_to_der([ + uniffiTypeSimpleVerifyingKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Serialize this private key as DER-encoded PKCS#8 + */toPem(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simpleverifyingkey_to_pem([ + uniffiTypeSimpleVerifyingKeyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + verify(message: ArrayBuffer, signature: SimpleSignature): void { + /* Regular function call: */ + uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + let signatureArg = FfiConverterTypeSimpleSignature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_simpleverifyingkey_verify([ + uniffiTypeSimpleVerifyingKeyObjectFactory.clonePointer(this), messageArg, signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeSimpleVerifyingKeyObjectFactory.pointer(this); + uniffiTypeSimpleVerifyingKeyObjectFactory.freePointer(pointer); + uniffiTypeSimpleVerifyingKeyObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is SimpleVerifyingKey { + return uniffiTypeSimpleVerifyingKeyObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeSimpleVerifyingKeyObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeSimpleVerifyingKeyObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): SimpleVerifyingKey { + const instance = Object.create(SimpleVerifyingKey.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'SimpleVerifyingKey'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: SimpleVerifyingKey): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: SimpleVerifyingKey): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_simpleverifyingkey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_simpleverifyingkey([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is SimpleVerifyingKey { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'SimpleVerifyingKey' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeSimpleVerifyingKey = new FfiConverterObject( + uniffiTypeSimpleVerifyingKeyObjectFactory +); + + +export type SplitCoinsInterface = { + +/** + * The amounts to split off + */amounts(): Array; + +/** + * The coin to split + */coin(): Argument; + +}; + + +/** + * Command to split a single coin object into multiple coins + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * split-coins = argument (vector argument) + * ``` + */ +export class SplitCoins extends UniffiAbstractObject implements SplitCoinsInterface { + readonly [uniffiTypeNameSymbol] = 'SplitCoins'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(coin: Argument, amounts: Array) { + super(); + + let coinArg = FfiConverterTypeArgument.lower(coin); + let amountsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeArgument)).lower(amounts)).toStruct(); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_splitcoins_new([ + coinArg, amountsArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeSplitCoinsObjectFactory.bless(pointer); + }// Methods: + + +/** + * The amounts to split off + */amounts(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_splitcoins_amounts([ + uniffiTypeSplitCoinsObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeArgument)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * The coin to split + */coin(): Argument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_splitcoins_coin([ + uniffiTypeSplitCoinsObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeArgument.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeSplitCoinsObjectFactory.pointer(this); + uniffiTypeSplitCoinsObjectFactory.freePointer(pointer); + uniffiTypeSplitCoinsObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is SplitCoins { + return uniffiTypeSplitCoinsObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeSplitCoinsObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeSplitCoinsObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): SplitCoins { + const instance = Object.create(SplitCoins.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'SplitCoins'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: SplitCoins): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: SplitCoins): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_splitcoins([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_splitcoins([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is SplitCoins { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'SplitCoins' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeSplitCoins = new FfiConverterObject( + uniffiTypeSplitCoinsObjectFactory +); + + +export type StructTagInterface = { + +/** + * Returns the address part of a `StructTag` + */address(): Address; + +/** + * Checks if this is a Coin type + */coinType(): TypeTag; + +/** + * Checks if this is a Coin type + */coinTypeOpt(): TypeTag | undefined; + +/** + * Returns the module part of a `StructTag` + */module(): Identifier; + +/** + * Returns the name part of a `StructTag` + */name(): Identifier; + +/** + * Returns the string representation of this struct tag using the + * canonical display, with or without a `0x` prefix. + */toCanonicalString(withPrefix: boolean): string; + +/** + * Returns the type params part of a `StructTag` + */typeArgs(): Array; + +}; + + +/** + * Type information for a move struct + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * struct-tag = address ; address of the package + * identifier ; name of the module + * identifier ; name of the type + * (vector type-tag) ; type parameters + * ``` + */ +export class StructTag extends UniffiAbstractObject implements StructTagInterface { + readonly [uniffiTypeNameSymbol] = 'StructTag'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(address: Address, module: Identifier, name: Identifier, typeParams: Array) { + super(); + + let addressArg = FfiConverterTypeAddress.lower(address); + let moduleArg = FfiConverterTypeIdentifier.lower(module); + let nameArg = FfiConverterTypeIdentifier.lower(name); + let typeParamsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeTypeTag)).lower(typeParams)).toStruct(); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new([ + addressArg, moduleArg, nameArg, typeParamsArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeStructTagObjectFactory.bless(pointer); + } + + static newAsciiString(): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_ascii_string([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newBalance(typeTag: TypeTag): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let typeTagArg = FfiConverterTypeTypeTag.lower(typeTag); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_balance([ + typeTagArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newClock(): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_clock([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newCoin(typeTag: TypeTag): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let typeTagArg = FfiConverterTypeTypeTag.lower(typeTag); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_coin([ + typeTagArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newCoinManager(structTag: StructTag): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let structTagArg = FfiConverterTypeStructTag.lower(structTag); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_coin_manager([ + structTagArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newCoinMetadata(structTag: StructTag): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let structTagArg = FfiConverterTypeStructTag.lower(structTag); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_coin_metadata([ + structTagArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newConfig(): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_config([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newConfigSetting(typeTag: TypeTag): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let typeTagArg = FfiConverterTypeTypeTag.lower(typeTag); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_config_setting([ + typeTagArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newDenyListAddressKey(): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_deny_list_address_key([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newDenyListConfigKey(): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_deny_list_config_key([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newDenyListGlobalPauseKey(): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_deny_list_global_pause_key([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newDisplayCreated(structTag: StructTag): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let structTagArg = FfiConverterTypeStructTag.lower(structTag); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_display_created([ + structTagArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newDynamicObjectFieldWrapper(typeTag: TypeTag): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let typeTagArg = FfiConverterTypeTypeTag.lower(typeTag); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_dynamic_object_field_wrapper([ + typeTagArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newField(key: TypeTag, value: TypeTag): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let keyArg = FfiConverterTypeTypeTag.lower(key); + let valueArg = FfiConverterTypeTypeTag.lower(value); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_field([ + keyArg, valueArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newGasCoin(): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_gas_coin([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newId(): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_id([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newIotaCoinType(): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_iota_coin_type([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newIotaSystemAdminCap(): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_iota_system_admin_cap([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newIotaSystemState(): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_iota_system_state([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newIotaTreasuryCap(): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_iota_treasury_cap([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newName(address: Address): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let addressArg = FfiConverterTypeAddress.lower(address); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_name([ + addressArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newStakedIota(): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_staked_iota([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newString(): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_string([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newSystemEpochInfoEvent(): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_system_epoch_info_event([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newTimeLock(typeTag: TypeTag): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let typeTagArg = FfiConverterTypeTypeTag.lower(typeTag); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_time_lock([ + typeTagArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newTimelockedStakedIota(): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_timelocked_staked_iota([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newTransferReceiving(): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_transfer_receiving([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newTreasuryCap(structTag: StructTag): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let structTagArg = FfiConverterTypeStructTag.lower(structTag); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_treasury_cap([ + structTagArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newUid(): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_uid([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newUpgradeCap(): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_upgrade_cap([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newUpgradeReceipt(): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_upgrade_receipt([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newUpgradeTicket(): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_upgrade_ticket([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + static newVersionUpdated(structTag: StructTag): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let structTagArg = FfiConverterTypeStructTag.lower(structTag); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_structtag_new_version_updated([ + structTagArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + }// Methods: + + +/** + * Returns the address part of a `StructTag` + */address(): Address { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_structtag_address([ + uniffiTypeStructTagObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeAddress.lift(returnValue); + } + + +/** + * Checks if this is a Coin type + */coinType(): TypeTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_structtag_coin_type([ + uniffiTypeStructTagObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTypeTag.lift(returnValue); + } + + +/** + * Checks if this is a Coin type + */coinTypeOpt(): TypeTag | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_structtag_coin_type_opt([ + uniffiTypeStructTagObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeTypeTag).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Returns the module part of a `StructTag` + */module(): Identifier { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_structtag_module([ + uniffiTypeStructTagObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeIdentifier.lift(returnValue); + } + + +/** + * Returns the name part of a `StructTag` + */name(): Identifier { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_structtag_name([ + uniffiTypeStructTagObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeIdentifier.lift(returnValue); + } + + +/** + * Returns the string representation of this struct tag using the + * canonical display, with or without a `0x` prefix. + */toCanonicalString(withPrefix: boolean): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let withPrefixArg = FfiConverterBool.lower(withPrefix); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_structtag_to_canonical_string([ + uniffiTypeStructTagObjectFactory.clonePointer(this), withPrefixArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Returns the type params part of a `StructTag` + */typeArgs(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_structtag_type_args([ + uniffiTypeStructTagObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeTypeTag)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + toString(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_structtag_uniffi_trait_display([ + uniffiTypeStructTagObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeStructTagObjectFactory.pointer(this); + uniffiTypeStructTagObjectFactory.freePointer(pointer); + uniffiTypeStructTagObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is StructTag { + return uniffiTypeStructTagObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeStructTagObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeStructTagObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): StructTag { + const instance = Object.create(StructTag.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'StructTag'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: StructTag): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: StructTag): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_structtag([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_structtag([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is StructTag { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'StructTag' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeStructTag = new FfiConverterObject( + uniffiTypeStructTagObjectFactory +); + + +export type SystemPackageInterface = { + dependencies(): Array; + modules(): Array; + version(): /*u64*/bigint; + +}; + + +/** + * System package + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * system-package = u64 ; version + * (vector bytes) ; modules + * (vector object-id) ; dependencies + * ``` + */ +export class SystemPackage extends UniffiAbstractObject implements SystemPackageInterface { + readonly [uniffiTypeNameSymbol] = 'SystemPackage'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(version: /*u64*/bigint, modules: Array, dependencies: Array) { + super(); + + let versionArg = FfiConverterUInt64.lower(version); + let modulesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterArrayBuffer)).lower(modules)).toStruct(); + let dependenciesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeObjectId)).lower(dependencies)).toStruct(); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_systempackage_new([ + versionArg, modulesArg, dependenciesArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeSystemPackageObjectFactory.bless(pointer); + }// Methods: + + dependencies(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_systempackage_dependencies([ + uniffiTypeSystemPackageObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeObjectId)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + modules(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_systempackage_modules([ + uniffiTypeSystemPackageObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterArrayBuffer)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + version(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_systempackage_version([ + uniffiTypeSystemPackageObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeSystemPackageObjectFactory.pointer(this); + uniffiTypeSystemPackageObjectFactory.freePointer(pointer); + uniffiTypeSystemPackageObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is SystemPackage { + return uniffiTypeSystemPackageObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeSystemPackageObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeSystemPackageObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): SystemPackage { + const instance = Object.create(SystemPackage.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'SystemPackage'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: SystemPackage): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: SystemPackage): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_systempackage([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_systempackage([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is SystemPackage { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'SystemPackage' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeSystemPackage = new FfiConverterObject( + uniffiTypeSystemPackageObjectFactory +); + + +export type TransactionInterface = { + asV1(): TransactionV1; + digest(): Digest; + expiration(): TransactionExpiration; + gasPayment(): GasPayment; + kind(): TransactionKind; + sender(): Address; + +/** + * Get the signing digest. + */signingDigest(): ArrayBuffer; + +/** + * Get the signing digest as a hex string. + */signingDigestHex(): string; + +/** + * Serialize the transaction as a base64-encoded string. + */toBase64(): string; + +}; + + +/** + * Transaction + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * transaction = %x00 transaction-v1 + * + * transaction-v1 = transaction-kind address gas-payment transaction-expiration + * ``` + */ +export class Transaction extends UniffiAbstractObject implements TransactionInterface { + readonly [uniffiTypeNameSymbol] = 'Transaction'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + +/** + * Deserialize a transaction from a base64-encoded string. + */ + + static fromBase64(base64: string): Transaction { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let base64Arg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(base64)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_transaction_from_base64([ + base64Arg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransaction.lift(returnValue); + } + + static newV1(transactionV1: TransactionV1): Transaction { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let transactionV1Arg = FfiConverterTypeTransactionV1.lower(transactionV1); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_transaction_new_v1([ + transactionV1Arg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransaction.lift(returnValue); + }// Methods: + + asV1(): TransactionV1 { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transaction_as_v1([ + uniffiTypeTransactionObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionV1.lift(returnValue); + } + + digest(): Digest { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transaction_digest([ + uniffiTypeTransactionObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeDigest.lift(returnValue); + } + + expiration(): TransactionExpiration { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transaction_expiration([ + uniffiTypeTransactionObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionExpiration.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + gasPayment(): GasPayment { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transaction_gas_payment([ + uniffiTypeTransactionObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeGasPayment.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + kind(): TransactionKind { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transaction_kind([ + uniffiTypeTransactionObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionKind.lift(returnValue); + } + + sender(): Address { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transaction_sender([ + uniffiTypeTransactionObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeAddress.lift(returnValue); + } + + +/** + * Get the signing digest. + */signingDigest(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transaction_signing_digest([ + uniffiTypeTransactionObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Get the signing digest as a hex string. + */signingDigestHex(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transaction_signing_digest_hex([ + uniffiTypeTransactionObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Serialize the transaction as a base64-encoded string. + */toBase64(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transaction_to_base64([ + uniffiTypeTransactionObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeTransactionObjectFactory.pointer(this); + uniffiTypeTransactionObjectFactory.freePointer(pointer); + uniffiTypeTransactionObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Transaction { + return uniffiTypeTransactionObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeTransactionObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeTransactionObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Transaction { + const instance = Object.create(Transaction.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Transaction'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Transaction): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Transaction): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_transaction([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_transaction([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Transaction { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Transaction' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeTransaction = new FfiConverterObject( + uniffiTypeTransactionObjectFactory +); + + +export type TransactionBuilderInterface = { + +/** + * Execute the transaction using the gas station and return the JSON + * transaction effects. This will fail unless data is set with the + * `gas_station_sponsor` function. + * + * NOTE: These effects are not necessarily compatible with + * `TransactionEffects` + *//* async */ executeWithGasStation(signer: TransactionSigner, asyncOpts_?: { signal: AbortSignal }): Promise; + +/** + * Set the expiration of the transaction to be a specific epoch. + */expiration(epoch: /*u64*/bigint): TransactionBuilder; + +/** + * Convert this builder into a transaction. + */finish(): Transaction; + +/** + * Add gas coins that will be consumed. Optional. + */gas(objectRefs: Array): TransactionBuilder; + +/** + * Set the gas budget for the transaction. + */gasBudget(budget: /*u64*/bigint): TransactionBuilder; + +/** + * Set the gas price for the transaction. + */gasPrice(price: /*u64*/bigint): TransactionBuilder; + +/** + * Set the gas station sponsor. + */gasStationSponsor(url: string, duration: number /* in milliseconds */ | undefined, headers: Map> | undefined): TransactionBuilder; + +/** + * Make a move vector from a list of elements. The elements must all be of + * the type indicated by `type_tag`. + */makeMoveVec(elements: Array, typeTag: TypeTag, name: string): TransactionBuilder; + +/** + * Merge multiple coins into one. + * + * This method combines the balances of multiple coins of the same coin + * type into a single coin. The `primary_coin` will receive the balances + * from all `consumed_coins`. After merging, the `consumed_coins` will + * be consumed and no longer exist. + */mergeCoins(primaryCoin: PtbArgument, consumedCoins: Array): TransactionBuilder; + +/** + * Call a Move function with the given arguments. + */moveCall(package_: Address, module: Identifier, function_: Identifier, arguments_: Array, typeArgs: Array, names: Array): TransactionBuilder; + +/** + * Publish a list of modules with the given dependencies. The result + * assigned to `upgrade_cap_name` is the `0x2::package::UpgradeCap` + * Move type. Note that the upgrade capability needs to be handled + * after this call: + * - transfer it to the transaction sender or another address + * - burn it + * - wrap it for access control + * - discard the it to make a package immutable + * + * The arguments required for this command are: + * - `modules`: is the modules' bytecode to be published + * - `dependencies`: is the list of IDs of the transitive dependencies of + * the package + */publish(packageData: MovePackageData, upgradeCapName: string): TransactionBuilder; + +/** + * Transfer some coins to a recipient address. If multiple coins are + * provided then they will be merged. + * + * The `amount` parameter specifies the quantity in NANOS, where 1 IOTA + * equals 1_000_000_000 NANOS. + * If `amount` is provided, that amount is split from the provided coins + * and sent. + * If `amount` is `None`, the entire coins are transferred. + * + * All provided coins must have the same coin type. Mixing coins of + * different types will result in an error. + * + * If you intend to transfer all provided coins to another address in a + * single transaction, consider using + * `TransactionBuilder::transfer_objects()` instead. + */sendCoins(coins: Array, recipient: Address, amount: PtbArgument | undefined): TransactionBuilder; + +/** + * Send IOTA to a recipient address. + * + * The `amount` parameter specifies the quantity in NANOS, where 1 IOTA + * equals 1_000_000_000 NANOS. That amount is split from the gas coin and + * sent. + */sendIota(recipient: Address, amount: PtbArgument): TransactionBuilder; + +/** + * Set the sender address. + */setSender(sender: Address): void; + +/** + * Split a coin by the provided amounts. + */splitCoins(coin: PtbArgument, amounts: Array, names: Array): TransactionBuilder; + +/** + * Set the sponsor of the transaction. + */sponsor(sponsor: Address): TransactionBuilder; + +/** + * Add stake to a validator's staking pool. + * + * This is a high-level function which will split the provided stake amount + * from the gas coin and then stake using the resulting coin. + */stake(stake: PtbArgument, validatorAddress: Address): TransactionBuilder; + +/** + * Transfer a list of objects to the given address, without producing any + * result. + */transferObjects(recipient: Address, objects: Array): TransactionBuilder; + +/** + * Withdraw stake from a validator's staking pool. + */unstake(stakedIota: PtbArgument): TransactionBuilder; + +/** + * Upgrade a Move package. + * + * - `modules`: is the modules' bytecode for the modules to be published + * - `dependencies`: is the list of IDs of the transitive dependencies of + * the package to be upgraded + * - `package`: is the ID of the current package being upgraded + * - `ticket`: is the upgrade ticket + * + * To get the ticket, you have to call the + * `0x2::package::authorize_upgrade` function, and pass the package + * ID, the upgrade policy, and package digest. + */upgrade(packageId: ObjectId, packageData: MovePackageData, upgradeTicket: PtbArgument, name: string | undefined): TransactionBuilder; + withClient(client: GraphQlClient): ClientTransactionBuilder; + +}; + + +/** + * A builder for creating transactions. Use `finish` to finalize the + * transaction data. + */ +export class TransactionBuilder extends UniffiAbstractObject implements TransactionBuilderInterface { + readonly [uniffiTypeNameSymbol] = 'TransactionBuilder'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + +/** + * Create a new transaction builder and initialize its elements to default. + */ + constructor(sender: Address) { + super(); + + let senderArg = FfiConverterTypeAddress.lower(sender); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_transactionbuilder_new([ + senderArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeTransactionBuilderObjectFactory.bless(pointer); + }// Methods: + + +/** + * Execute the transaction using the gas station and return the JSON + * transaction effects. This will fail unless data is set with the + * `gas_station_sponsor` function. + * + * NOTE: These effects are not necessarily compatible with + * `TransactionEffects` + */async executeWithGasStation(signer: TransactionSigner, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let signerArg = FfiConverterTypeTransactionSigner.lower(signer); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionbuilder_execute_with_gas_station([ + uniffiTypeTransactionBuilderObjectFactory.clonePointer(this), signerArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterString.lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + +/** + * Set the expiration of the transaction to be a specific epoch. + */expiration(epoch: /*u64*/bigint): TransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let epochArg = FfiConverterUInt64.lower(epoch); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionbuilder_expiration([ + uniffiTypeTransactionBuilderObjectFactory.clonePointer(this), epochArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionBuilder.lift(returnValue); + } + + +/** + * Convert this builder into a transaction. + */finish(): Transaction { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionbuilder_finish([ + uniffiTypeTransactionBuilderObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransaction.lift(returnValue); + } + + +/** + * Add gas coins that will be consumed. Optional. + */gas(objectRefs: Array): TransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let objectRefsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeObjectReference)).lower(objectRefs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionbuilder_gas([ + uniffiTypeTransactionBuilderObjectFactory.clonePointer(this), objectRefsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionBuilder.lift(returnValue); + } + + +/** + * Set the gas budget for the transaction. + */gasBudget(budget: /*u64*/bigint): TransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let budgetArg = FfiConverterUInt64.lower(budget); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionbuilder_gas_budget([ + uniffiTypeTransactionBuilderObjectFactory.clonePointer(this), budgetArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionBuilder.lift(returnValue); + } + + +/** + * Set the gas price for the transaction. + */gasPrice(price: /*u64*/bigint): TransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let priceArg = FfiConverterUInt64.lower(price); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionbuilder_gas_price([ + uniffiTypeTransactionBuilderObjectFactory.clonePointer(this), priceArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionBuilder.lift(returnValue); + } + + +/** + * Set the gas station sponsor. + */gasStationSponsor(url: string, duration: number /* in milliseconds */ | undefined, headers: Map> | undefined): TransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let urlArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(url)).toStruct(); + let durationArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterDuration).lower(duration)).toStruct(); + let headersArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional((new FfiConverterMap(FfiConverterString, (new FfiConverterArray(FfiConverterString))))).lower(headers)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionbuilder_gas_station_sponsor([ + uniffiTypeTransactionBuilderObjectFactory.clonePointer(this), urlArg, durationArg, headersArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionBuilder.lift(returnValue); + } + + +/** + * Make a move vector from a list of elements. The elements must all be of + * the type indicated by `type_tag`. + */makeMoveVec(elements: Array, typeTag: TypeTag, name: string): TransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let elementsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeMoveArg)).lower(elements)).toStruct(); + let typeTagArg = FfiConverterTypeTypeTag.lower(typeTag); + let nameArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(name)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionbuilder_make_move_vec([ + uniffiTypeTransactionBuilderObjectFactory.clonePointer(this), elementsArg, typeTagArg, nameArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionBuilder.lift(returnValue); + } + + +/** + * Merge multiple coins into one. + * + * This method combines the balances of multiple coins of the same coin + * type into a single coin. The `primary_coin` will receive the balances + * from all `consumed_coins`. After merging, the `consumed_coins` will + * be consumed and no longer exist. + */mergeCoins(primaryCoin: PtbArgument, consumedCoins: Array): TransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let primaryCoinArg = FfiConverterTypePtbArgument.lower(primaryCoin); + let consumedCoinsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypePtbArgument)).lower(consumedCoins)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionbuilder_merge_coins([ + uniffiTypeTransactionBuilderObjectFactory.clonePointer(this), primaryCoinArg, consumedCoinsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionBuilder.lift(returnValue); + } + + +/** + * Call a Move function with the given arguments. + */moveCall(package_: Address, module: Identifier, function_: Identifier, arguments_: Array, typeArgs: Array, names: Array): TransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let package_Arg = FfiConverterTypeAddress.lower(package_); + let moduleArg = FfiConverterTypeIdentifier.lower(module); + let function_Arg = FfiConverterTypeIdentifier.lower(function_); + let arguments_Arg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypePtbArgument)).lower(arguments_)).toStruct(); + let typeArgsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeTypeTag)).lower(typeArgs)).toStruct(); + let namesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterString)).lower(names)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionbuilder_move_call([ + uniffiTypeTransactionBuilderObjectFactory.clonePointer(this), package_Arg, moduleArg, function_Arg, arguments_Arg, typeArgsArg, namesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionBuilder.lift(returnValue); + } + + +/** + * Publish a list of modules with the given dependencies. The result + * assigned to `upgrade_cap_name` is the `0x2::package::UpgradeCap` + * Move type. Note that the upgrade capability needs to be handled + * after this call: + * - transfer it to the transaction sender or another address + * - burn it + * - wrap it for access control + * - discard the it to make a package immutable + * + * The arguments required for this command are: + * - `modules`: is the modules' bytecode to be published + * - `dependencies`: is the list of IDs of the transitive dependencies of + * the package + */publish(packageData: MovePackageData, upgradeCapName: string): TransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let packageDataArg = FfiConverterTypeMovePackageData.lower(packageData); + let upgradeCapNameArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(upgradeCapName)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionbuilder_publish([ + uniffiTypeTransactionBuilderObjectFactory.clonePointer(this), packageDataArg, upgradeCapNameArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionBuilder.lift(returnValue); + } + + +/** + * Transfer some coins to a recipient address. If multiple coins are + * provided then they will be merged. + * + * The `amount` parameter specifies the quantity in NANOS, where 1 IOTA + * equals 1_000_000_000 NANOS. + * If `amount` is provided, that amount is split from the provided coins + * and sent. + * If `amount` is `None`, the entire coins are transferred. + * + * All provided coins must have the same coin type. Mixing coins of + * different types will result in an error. + * + * If you intend to transfer all provided coins to another address in a + * single transaction, consider using + * `TransactionBuilder::transfer_objects()` instead. + */sendCoins(coins: Array, recipient: Address, amount: PtbArgument | undefined): TransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let coinsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypePtbArgument)).lower(coins)).toStruct(); + let recipientArg = FfiConverterTypeAddress.lower(recipient); + let amountArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypePtbArgument).lower(amount)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionbuilder_send_coins([ + uniffiTypeTransactionBuilderObjectFactory.clonePointer(this), coinsArg, recipientArg, amountArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionBuilder.lift(returnValue); + } + + +/** + * Send IOTA to a recipient address. + * + * The `amount` parameter specifies the quantity in NANOS, where 1 IOTA + * equals 1_000_000_000 NANOS. That amount is split from the gas coin and + * sent. + */sendIota(recipient: Address, amount: PtbArgument): TransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let recipientArg = FfiConverterTypeAddress.lower(recipient); + let amountArg = FfiConverterTypePtbArgument.lower(amount); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionbuilder_send_iota([ + uniffiTypeTransactionBuilderObjectFactory.clonePointer(this), recipientArg, amountArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionBuilder.lift(returnValue); + } + + +/** + * Set the sender address. + */setSender(sender: Address): void { + /* Regular function call: */ + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let senderArg = FfiConverterTypeAddress.lower(sender); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionbuilder_set_sender([ + uniffiTypeTransactionBuilderObjectFactory.clonePointer(this), senderArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + +/** + * Split a coin by the provided amounts. + */splitCoins(coin: PtbArgument, amounts: Array, names: Array): TransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let coinArg = FfiConverterTypePtbArgument.lower(coin); + let amountsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypePtbArgument)).lower(amounts)).toStruct(); + let namesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterString)).lower(names)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionbuilder_split_coins([ + uniffiTypeTransactionBuilderObjectFactory.clonePointer(this), coinArg, amountsArg, namesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionBuilder.lift(returnValue); + } + + +/** + * Set the sponsor of the transaction. + */sponsor(sponsor: Address): TransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let sponsorArg = FfiConverterTypeAddress.lower(sponsor); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionbuilder_sponsor([ + uniffiTypeTransactionBuilderObjectFactory.clonePointer(this), sponsorArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionBuilder.lift(returnValue); + } + + +/** + * Add stake to a validator's staking pool. + * + * This is a high-level function which will split the provided stake amount + * from the gas coin and then stake using the resulting coin. + */stake(stake: PtbArgument, validatorAddress: Address): TransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let stakeArg = FfiConverterTypePtbArgument.lower(stake); + let validatorAddressArg = FfiConverterTypeAddress.lower(validatorAddress); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionbuilder_stake([ + uniffiTypeTransactionBuilderObjectFactory.clonePointer(this), stakeArg, validatorAddressArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionBuilder.lift(returnValue); + } + + +/** + * Transfer a list of objects to the given address, without producing any + * result. + */transferObjects(recipient: Address, objects: Array): TransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let recipientArg = FfiConverterTypeAddress.lower(recipient); + let objectsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypePtbArgument)).lower(objects)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionbuilder_transfer_objects([ + uniffiTypeTransactionBuilderObjectFactory.clonePointer(this), recipientArg, objectsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionBuilder.lift(returnValue); + } + + +/** + * Withdraw stake from a validator's staking pool. + */unstake(stakedIota: PtbArgument): TransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let stakedIotaArg = FfiConverterTypePtbArgument.lower(stakedIota); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionbuilder_unstake([ + uniffiTypeTransactionBuilderObjectFactory.clonePointer(this), stakedIotaArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionBuilder.lift(returnValue); + } + + +/** + * Upgrade a Move package. + * + * - `modules`: is the modules' bytecode for the modules to be published + * - `dependencies`: is the list of IDs of the transitive dependencies of + * the package to be upgraded + * - `package`: is the ID of the current package being upgraded + * - `ticket`: is the upgrade ticket + * + * To get the ticket, you have to call the + * `0x2::package::authorize_upgrade` function, and pass the package + * ID, the upgrade policy, and package digest. + */upgrade(packageId: ObjectId, packageData: MovePackageData, upgradeTicket: PtbArgument, name: string | undefined): TransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let packageIdArg = FfiConverterTypeObjectId.lower(packageId); + let packageDataArg = FfiConverterTypeMovePackageData.lower(packageData); + let upgradeTicketArg = FfiConverterTypePtbArgument.lower(upgradeTicket); + let nameArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterString).lower(name)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionbuilder_upgrade([ + uniffiTypeTransactionBuilderObjectFactory.clonePointer(this), packageIdArg, packageDataArg, upgradeTicketArg, nameArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionBuilder.lift(returnValue); + } + + withClient(client: GraphQlClient): ClientTransactionBuilder { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let clientArg = FfiConverterTypeGraphQlClient.lower(client); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionbuilder_with_client([ + uniffiTypeTransactionBuilderObjectFactory.clonePointer(this), clientArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeClientTransactionBuilder.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeTransactionBuilderObjectFactory.pointer(this); + uniffiTypeTransactionBuilderObjectFactory.freePointer(pointer); + uniffiTypeTransactionBuilderObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is TransactionBuilder { + return uniffiTypeTransactionBuilderObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeTransactionBuilderObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeTransactionBuilderObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): TransactionBuilder { + const instance = Object.create(TransactionBuilder.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'TransactionBuilder'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: TransactionBuilder): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: TransactionBuilder): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_transactionbuilder([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_transactionbuilder([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is TransactionBuilder { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'TransactionBuilder' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeTransactionBuilder = new FfiConverterObject( + uniffiTypeTransactionBuilderObjectFactory +); + + +export type TransactionEffectsInterface = { + asV1(): TransactionEffectsV1; + digest(): Digest; + isV1(): boolean; + +}; + + +/** + * The output or effects of executing a transaction + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * transaction-effects = %x00 effects-v1 + * =/ %x01 effects-v2 + * ``` + */ +export class TransactionEffects extends UniffiAbstractObject implements TransactionEffectsInterface { + readonly [uniffiTypeNameSymbol] = 'TransactionEffects'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static newV1(effects: TransactionEffectsV1): TransactionEffects { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let effectsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeTransactionEffectsV1.lower(effects)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_transactioneffects_new_v1([ + effectsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionEffects.lift(returnValue); + }// Methods: + + asV1(): TransactionEffectsV1 { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactioneffects_as_v1([ + uniffiTypeTransactionEffectsObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionEffectsV1.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + digest(): Digest { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactioneffects_digest([ + uniffiTypeTransactionEffectsObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeDigest.lift(returnValue); + } + + isV1(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactioneffects_is_v1([ + uniffiTypeTransactionEffectsObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeTransactionEffectsObjectFactory.pointer(this); + uniffiTypeTransactionEffectsObjectFactory.freePointer(pointer); + uniffiTypeTransactionEffectsObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is TransactionEffects { + return uniffiTypeTransactionEffectsObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeTransactionEffectsObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeTransactionEffectsObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): TransactionEffects { + const instance = Object.create(TransactionEffects.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'TransactionEffects'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: TransactionEffects): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: TransactionEffects): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_transactioneffects([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_transactioneffects([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is TransactionEffects { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'TransactionEffects' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeTransactionEffects = new FfiConverterObject( + uniffiTypeTransactionEffectsObjectFactory +); + + +export type TransactionEventsInterface = { + digest(): Digest; + events(): Array; + +}; + + +/** + * Events emitted during the successful execution of a transaction + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * transaction-events = vector event + * ``` + */ +export class TransactionEvents extends UniffiAbstractObject implements TransactionEventsInterface { + readonly [uniffiTypeNameSymbol] = 'TransactionEvents'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(events: Array) { + super(); + + let eventsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeEvent)).lower(events)).toStruct(); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_transactionevents_new([ + eventsArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeTransactionEventsObjectFactory.bless(pointer); + }// Methods: + + digest(): Digest { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionevents_digest([ + uniffiTypeTransactionEventsObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeDigest.lift(returnValue); + } + + events(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionevents_events([ + uniffiTypeTransactionEventsObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeEvent)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeTransactionEventsObjectFactory.pointer(this); + uniffiTypeTransactionEventsObjectFactory.freePointer(pointer); + uniffiTypeTransactionEventsObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is TransactionEvents { + return uniffiTypeTransactionEventsObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeTransactionEventsObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeTransactionEventsObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): TransactionEvents { + const instance = Object.create(TransactionEvents.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'TransactionEvents'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: TransactionEvents): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: TransactionEvents): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_transactionevents([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_transactionevents([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is TransactionEvents { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'TransactionEvents' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeTransactionEvents = new FfiConverterObject( + uniffiTypeTransactionEventsObjectFactory +); + + +export type TransactionKindInterface = { + +}; + + +/** + * Transaction type + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * transaction-kind = %x00 ptb + * =/ %x01 change-epoch + * =/ %x02 genesis-transaction + * =/ %x03 consensus-commit-prologue + * =/ %x04 authenticator-state-update + * =/ %x05 (vector end-of-epoch-transaction-kind) + * =/ %x06 randomness-state-update + * =/ %x07 consensus-commit-prologue-v2 + * =/ %x08 consensus-commit-prologue-v3 + * ``` + */ +export class TransactionKind extends UniffiAbstractObject implements TransactionKindInterface { + readonly [uniffiTypeNameSymbol] = 'TransactionKind'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static newAuthenticatorStateUpdateV1(tx: AuthenticatorStateUpdateV1): TransactionKind { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let txArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeAuthenticatorStateUpdateV1.lower(tx)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_transactionkind_new_authenticator_state_update_v1([ + txArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionKind.lift(returnValue); + } + + static newConsensusCommitPrologueV1(tx: ConsensusCommitPrologueV1): TransactionKind { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let txArg = FfiConverterTypeConsensusCommitPrologueV1.lower(tx); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_transactionkind_new_consensus_commit_prologue_v1([ + txArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionKind.lift(returnValue); + } + + static newEndOfEpoch(tx: Array): TransactionKind { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let txArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeEndOfEpochTransactionKind)).lower(tx)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_transactionkind_new_end_of_epoch([ + txArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionKind.lift(returnValue); + } + + static newGenesis(tx: GenesisTransaction): TransactionKind { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let txArg = FfiConverterTypeGenesisTransaction.lower(tx); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_transactionkind_new_genesis([ + txArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionKind.lift(returnValue); + } + + static newProgrammableTransaction(tx: ProgrammableTransaction): TransactionKind { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let txArg = FfiConverterTypeProgrammableTransaction.lower(tx); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_transactionkind_new_programmable_transaction([ + txArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionKind.lift(returnValue); + } + + static newRandomnessStateUpdate(tx: RandomnessStateUpdate): TransactionKind { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let txArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeRandomnessStateUpdate.lower(tx)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_transactionkind_new_randomness_state_update([ + txArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionKind.lift(returnValue); + }// Methods: + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeTransactionKindObjectFactory.pointer(this); + uniffiTypeTransactionKindObjectFactory.freePointer(pointer); + uniffiTypeTransactionKindObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is TransactionKind { + return uniffiTypeTransactionKindObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeTransactionKindObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeTransactionKindObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): TransactionKind { + const instance = Object.create(TransactionKind.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'TransactionKind'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: TransactionKind): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: TransactionKind): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_transactionkind([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_transactionkind([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is TransactionKind { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'TransactionKind' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeTransactionKind = new FfiConverterObject( + uniffiTypeTransactionKindObjectFactory +); + + +export type TransactionSignerInterface = { + /* async */ sign(txn: Transaction, asyncOpts_?: { signal: AbortSignal }): Promise; + +}; + + +/** + * An async signer implementation which wraps a `TransactionSignerFn` + * definition, which can be used to sign a transaction with a callback. + */ +export class TransactionSigner extends UniffiAbstractObject implements TransactionSignerInterface { + readonly [uniffiTypeNameSymbol] = 'TransactionSigner'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static fromEd25519(key: Ed25519PrivateKey): TransactionSigner { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let keyArg = FfiConverterTypeEd25519PrivateKey.lower(key); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_transactionsigner_from_ed25519([ + keyArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionSigner.lift(returnValue); + } + + static fromKeypair(key: SimpleKeypair): TransactionSigner { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let keyArg = FfiConverterTypeSimpleKeypair.lower(key); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_transactionsigner_from_keypair([ + keyArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionSigner.lift(returnValue); + } + + static fromMoveAuthenticator(auth: MoveAuthenticator): TransactionSigner { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let authArg = FfiConverterTypeMoveAuthenticator.lower(auth); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_transactionsigner_from_move_authenticator([ + authArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionSigner.lift(returnValue); + } + + static fromSecp256k1(key: Secp256k1PrivateKey): TransactionSigner { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let keyArg = FfiConverterTypeSecp256k1PrivateKey.lower(key); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_transactionsigner_from_secp256k1([ + keyArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionSigner.lift(returnValue); + } + + static fromSecp256r1(key: Secp256r1PrivateKey): TransactionSigner { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let keyArg = FfiConverterTypeSecp256r1PrivateKey.lower(key); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_transactionsigner_from_secp256r1([ + keyArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionSigner.lift(returnValue); + } + constructor(signerFn: TransactionSignerFn) { + super(); + + let signerFnArg = FfiConverterTypeTransactionSignerFn.lower(signerFn); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_transactionsigner_new([ + signerFnArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeTransactionSignerObjectFactory.bless(pointer); + }// Methods: + + async sign(txn: Transaction, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let txnArg = FfiConverterTypeTransaction.lower(txn); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionsigner_sign([ + uniffiTypeTransactionSignerObjectFactory.clonePointer(this), txnArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_pointer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_pointer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_pointer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_pointer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeUserSignature.lift(value), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + + // UniffiTrait implementations: + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeTransactionSignerObjectFactory.pointer(this); + uniffiTypeTransactionSignerObjectFactory.freePointer(pointer); + uniffiTypeTransactionSignerObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is TransactionSigner { + return uniffiTypeTransactionSignerObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeTransactionSignerObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeTransactionSignerObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): TransactionSigner { + const instance = Object.create(TransactionSigner.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'TransactionSigner'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: TransactionSigner): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: TransactionSigner): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_transactionsigner([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_transactionsigner([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is TransactionSigner { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'TransactionSigner' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeTransactionSigner = new FfiConverterObject( + uniffiTypeTransactionSignerObjectFactory +); + + +export type TransactionSignerFnInterface = { + +/** + * Sign a transaction and return a `UserSignature`. + *//* async */ sign(transaction: Transaction, asyncOpts_?: { signal: AbortSignal }): Promise; + +}; + + +/** + * Defines a type which can sign a transaction asynchronously. + * + * This trait can be implemented downstream to enable signing when using the + * `TransactionBuilder::execute` function. + */ +export class TransactionSignerFn extends UniffiAbstractObject implements TransactionSignerFnInterface { + readonly [uniffiTypeNameSymbol] = 'TransactionSignerFn'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + // Methods: + + +/** + * Sign a transaction and return a `UserSignature`. + */async sign(transaction: Transaction, asyncOpts_?: { signal: AbortSignal }): Promise { + /* Async function call: */ + let lastPollCallbackPointer: Array | null = null; + const cleanupLastPollCallbackPointer = () => { + if (!lastPollCallbackPointer) { + return; + } + + + freePointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: lastPollCallbackPointer, + pointerType: PointerType.RsPointer, + }); + }; + + let transactionArg = FfiConverterTypeTransaction.lower(transaction); + const returnValue = await uniffiRustCallAsync( + // NOTE: this type assertion is being done to silence the fact that a completely custom (ie, + // not just a superclass) `UniffiRustCaller` implementer is being used here, which is + // required so that custom `free`ing logic can be run that the stock UniffiRustCaller + // doesn't support. + /*rustCaller:*/ uniffiCaller as unknown as UniffiRustCaller, + /*rustFutureFunc:*/ () => { + + const returnedHandle = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionsignerfn_sign([ + uniffiTypeTransactionSignerFnObjectFactory.clonePointer(this), transactionArg + ]); + + return returnedHandle; + }, + /*pollFunc:*/ (handle, callback, callbackData) => { + cleanupLastPollCallbackPointer(); + + + const wrappedCallback = ( + callbackData: number /* FIXME: this should be bigint, but ffi-rs seems to pass a number here instead? Investigate this. */, + pollCodeRaw: number, + ) => { + // NOTE: ffi-rs doesn't support a DataType.I8 value under the hood, so instead `pollCode` + // is being returned as a DataType.U8 as it is the same byte size. The below code + // does the conversion from U8 -> I8. + const pollCode = ((pollCodeRaw & 0b10000000) > 0 ? -1 : 1) * (pollCodeRaw & 0b01111111); + + + callback(BigInt(callbackData), pollCode); + }; + const callbackExternal = createPointer({ + paramsType: [funcConstructor({ + paramsType: [DataType.U64, /* i8 */ DataType.U8], + retType: DataType.Void, + })], + paramsValue: [wrappedCallback], + }); + lastPollCallbackPointer = callbackExternal; + const [ unwrapped ] = unwrapPointer(callbackExternal); + + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_poll_rust_buffer([ + handle, + unwrapped, + callbackData, + ]); + + }, + /*cancelFunc:*/ (handle) => { + + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer([handle]) + }, + /*completeFunc:*/ (handle, callStatusWithIncorrectType) => { + + // FIXME: because of the `rustCaller:` type assertion happening above, the type of the + // callStatus value is incorrect. It should be `JsExternal`, but is being typed as + // `UniffiRustCallStatus`. So, hack around it here. Longer term figure out a way to + // reabstract this to not rely so tightly on the UBRN helper library maybe? + const callStatus = callStatusWithIncorrectType as unknown as JsExternal; + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_complete_rust_buffer([handle, callStatus]); + }, + /*freeFunc:*/ (handle) => { + + cleanupLastPollCallbackPointer(); + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rust_future_free_rust_buffer([handle]) + }, + + /*liftFunc:*/ (value) => FfiConverterTypeTransactionSignerFnOutput.lift(new UniffiRustBufferValue(value).consumeIntoUint8Array()), + /*liftString:*/ FfiConverterString.lift, + /*asyncOpts:*/ asyncOpts_, + /*errorHandler:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + ); + + return returnValue; + + } + + + // UniffiTrait implementations: + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeTransactionSignerFnObjectFactory.pointer(this); + uniffiTypeTransactionSignerFnObjectFactory.freePointer(pointer); + uniffiTypeTransactionSignerFnObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is TransactionSignerFn { + return uniffiTypeTransactionSignerFnObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeTransactionSignerFnObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeTransactionSignerFnObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): TransactionSignerFn { + const instance = Object.create(TransactionSignerFn.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'TransactionSignerFn'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: TransactionSignerFn): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: TransactionSignerFn): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_transactionsignerfn([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_transactionsignerfn([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is TransactionSignerFn { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'TransactionSignerFn' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeTransactionSignerFn = new FfiConverterObject( + uniffiTypeTransactionSignerFnObjectFactory +); + + +export type TransactionV1Interface = { + digest(): Digest; + expiration(): TransactionExpiration; + gasPayment(): GasPayment; + kind(): TransactionKind; + sender(): Address; + +/** + * Get the signing digest. + */signingDigest(): ArrayBuffer; + +/** + * Get the signing digest as a hex string. + */signingDigestHex(): string; + +/** + * Serialize the transaction as a base64-encoded string. + */toBase64(): string; + +}; + + +/** + * A transaction + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * transaction = %x00 transaction-v1 + * + * transaction-v1 = transaction-kind address gas-payment transaction-expiration + * ``` + */ +export class TransactionV1 extends UniffiAbstractObject implements TransactionV1Interface { + readonly [uniffiTypeNameSymbol] = 'TransactionV1'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + +/** + * Deserialize a transaction from a base64-encoded string. + */ + + static fromBase64(bytes: string): TransactionV1 { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(bytes)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_transactionv1_from_base64([ + bytesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionV1.lift(returnValue); + } + constructor(kind: TransactionKind, sender: Address, gasPayment: GasPayment, expiration: TransactionExpiration) { + super(); + + let kindArg = FfiConverterTypeTransactionKind.lower(kind); + let senderArg = FfiConverterTypeAddress.lower(sender); + let gasPaymentArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeGasPayment.lower(gasPayment)).toStruct(); + let expirationArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeTransactionExpiration.lower(expiration)).toStruct(); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_transactionv1_new([ + kindArg, senderArg, gasPaymentArg, expirationArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeTransactionV1ObjectFactory.bless(pointer); + }// Methods: + + digest(): Digest { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionv1_digest([ + uniffiTypeTransactionV1ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeDigest.lift(returnValue); + } + + expiration(): TransactionExpiration { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionv1_expiration([ + uniffiTypeTransactionV1ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionExpiration.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + gasPayment(): GasPayment { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionv1_gas_payment([ + uniffiTypeTransactionV1ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeGasPayment.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + kind(): TransactionKind { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionv1_kind([ + uniffiTypeTransactionV1ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionKind.lift(returnValue); + } + + sender(): Address { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionv1_sender([ + uniffiTypeTransactionV1ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeAddress.lift(returnValue); + } + + +/** + * Get the signing digest. + */signingDigest(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionv1_signing_digest([ + uniffiTypeTransactionV1ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Get the signing digest as a hex string. + */signingDigestHex(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionv1_signing_digest_hex([ + uniffiTypeTransactionV1ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Serialize the transaction as a base64-encoded string. + */toBase64(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transactionv1_to_base64([ + uniffiTypeTransactionV1ObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeTransactionV1ObjectFactory.pointer(this); + uniffiTypeTransactionV1ObjectFactory.freePointer(pointer); + uniffiTypeTransactionV1ObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is TransactionV1 { + return uniffiTypeTransactionV1ObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeTransactionV1ObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeTransactionV1ObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): TransactionV1 { + const instance = Object.create(TransactionV1.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'TransactionV1'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: TransactionV1): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: TransactionV1): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_transactionv1([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_transactionv1([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is TransactionV1 { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'TransactionV1' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeTransactionV1 = new FfiConverterObject( + uniffiTypeTransactionV1ObjectFactory +); + + +export type TransferObjectsInterface = { + +/** + * The address to transfer ownership to + */address(): Argument; + +/** + * Set of objects to transfer + */objects(): Array; + +}; + + +/** + * Command to transfer ownership of a set of objects to an address + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * transfer-objects = (vector argument) argument + * ``` + */ +export class TransferObjects extends UniffiAbstractObject implements TransferObjectsInterface { + readonly [uniffiTypeNameSymbol] = 'TransferObjects'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(objects: Array, address: Argument) { + super(); + + let objectsArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeArgument)).lower(objects)).toStruct(); + let addressArg = FfiConverterTypeArgument.lower(address); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_transferobjects_new([ + objectsArg, addressArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeTransferObjectsObjectFactory.bless(pointer); + }// Methods: + + +/** + * The address to transfer ownership to + */address(): Argument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transferobjects_address([ + uniffiTypeTransferObjectsObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeArgument.lift(returnValue); + } + + +/** + * Set of objects to transfer + */objects(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_transferobjects_objects([ + uniffiTypeTransferObjectsObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeArgument)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeTransferObjectsObjectFactory.pointer(this); + uniffiTypeTransferObjectsObjectFactory.freePointer(pointer); + uniffiTypeTransferObjectsObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is TransferObjects { + return uniffiTypeTransferObjectsObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeTransferObjectsObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeTransferObjectsObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): TransferObjects { + const instance = Object.create(TransferObjects.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'TransferObjects'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: TransferObjects): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: TransferObjects): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_transferobjects([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_transferobjects([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is TransferObjects { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'TransferObjects' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeTransferObjects = new FfiConverterObject( + uniffiTypeTransferObjectsObjectFactory +); + + +export type TypeTagInterface = { + asStructTag(): StructTag; + asStructTagOpt(): StructTag | undefined; + asVectorTypeTag(): TypeTag; + asVectorTypeTagOpt(): TypeTag | undefined; + isAddress(): boolean; + isBool(): boolean; + isSigner(): boolean; + isStruct(): boolean; + isU128(): boolean; + isU16(): boolean; + isU256(): boolean; + isU32(): boolean; + isU64(): boolean; + isU8(): boolean; + isVector(): boolean; + +/** + * Returns the string representation of this type tag using the + * canonical display, with or without a `0x` prefix. + */toCanonicalString(withPrefix: boolean): string; + +}; + + +/** + * Type of a move value + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * type-tag = type-tag-u8 \ + * type-tag-u16 \ + * type-tag-u32 \ + * type-tag-u64 \ + * type-tag-u128 \ + * type-tag-u256 \ + * type-tag-bool \ + * type-tag-address \ + * type-tag-signer \ + * type-tag-vector \ + * type-tag-struct + * + * type-tag-u8 = %x01 + * type-tag-u16 = %x08 + * type-tag-u32 = %x09 + * type-tag-u64 = %x02 + * type-tag-u128 = %x03 + * type-tag-u256 = %x0a + * type-tag-bool = %x00 + * type-tag-address = %x04 + * type-tag-signer = %x05 + * type-tag-vector = %x06 type-tag + * type-tag-struct = %x07 struct-tag + * ``` + */ +export class TypeTag extends UniffiAbstractObject implements TypeTagInterface { + readonly [uniffiTypeNameSymbol] = 'TypeTag'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static newAddress(): TypeTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_typetag_new_address([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTypeTag.lift(returnValue); + } + + static newBool(): TypeTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_typetag_new_bool([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTypeTag.lift(returnValue); + } + + static newSigner(): TypeTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_typetag_new_signer([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTypeTag.lift(returnValue); + } + + static newStruct(structTag: StructTag): TypeTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let structTagArg = FfiConverterTypeStructTag.lower(structTag); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_typetag_new_struct([ + structTagArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTypeTag.lift(returnValue); + } + + static newU128(): TypeTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_typetag_new_u128([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTypeTag.lift(returnValue); + } + + static newU16(): TypeTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_typetag_new_u16([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTypeTag.lift(returnValue); + } + + static newU256(): TypeTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_typetag_new_u256([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTypeTag.lift(returnValue); + } + + static newU32(): TypeTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_typetag_new_u32([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTypeTag.lift(returnValue); + } + + static newU64(): TypeTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_typetag_new_u64([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTypeTag.lift(returnValue); + } + + static newU8(): TypeTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_typetag_new_u8([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTypeTag.lift(returnValue); + } + + static newVector(typeTag: TypeTag): TypeTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let typeTagArg = FfiConverterTypeTypeTag.lower(typeTag); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_typetag_new_vector([ + typeTagArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTypeTag.lift(returnValue); + }// Methods: + + asStructTag(): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_typetag_as_struct_tag([ + uniffiTypeTypeTagObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + asStructTagOpt(): StructTag | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_typetag_as_struct_tag_opt([ + uniffiTypeTypeTagObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeStructTag).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + asVectorTypeTag(): TypeTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_typetag_as_vector_type_tag([ + uniffiTypeTypeTagObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTypeTag.lift(returnValue); + } + + asVectorTypeTagOpt(): TypeTag | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_typetag_as_vector_type_tag_opt([ + uniffiTypeTypeTagObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeTypeTag).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + isAddress(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_typetag_is_address([ + uniffiTypeTypeTagObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + isBool(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_typetag_is_bool([ + uniffiTypeTypeTagObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + isSigner(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_typetag_is_signer([ + uniffiTypeTypeTagObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + isStruct(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_typetag_is_struct([ + uniffiTypeTypeTagObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + isU128(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_typetag_is_u128([ + uniffiTypeTypeTagObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + isU16(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_typetag_is_u16([ + uniffiTypeTypeTagObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + isU256(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_typetag_is_u256([ + uniffiTypeTypeTagObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + isU32(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_typetag_is_u32([ + uniffiTypeTypeTagObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + isU64(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_typetag_is_u64([ + uniffiTypeTypeTagObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + isU8(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_typetag_is_u8([ + uniffiTypeTypeTagObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + isVector(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_typetag_is_vector([ + uniffiTypeTypeTagObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + +/** + * Returns the string representation of this type tag using the + * canonical display, with or without a `0x` prefix. + */toCanonicalString(withPrefix: boolean): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let withPrefixArg = FfiConverterBool.lower(withPrefix); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_typetag_to_canonical_string([ + uniffiTypeTypeTagObjectFactory.clonePointer(this), withPrefixArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + toString(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_typetag_uniffi_trait_display([ + uniffiTypeTypeTagObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeTypeTagObjectFactory.pointer(this); + uniffiTypeTypeTagObjectFactory.freePointer(pointer); + uniffiTypeTypeTagObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is TypeTag { + return uniffiTypeTypeTagObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeTypeTagObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeTypeTagObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): TypeTag { + const instance = Object.create(TypeTag.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'TypeTag'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: TypeTag): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: TypeTag): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_typetag([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_typetag([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is TypeTag { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'TypeTag' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeTypeTag = new FfiConverterObject( + uniffiTypeTypeTagObjectFactory +); + + +export type UpgradeInterface = { + +/** + * Set of packages that the to-be published package depends on + */dependencies(): Array; + +/** + * The serialized move modules + */modules(): Array; + +/** + * Package id of the package to upgrade + */package_(): ObjectId; + +/** + * Ticket authorizing the upgrade + */ticket(): Argument; + +}; + + +/** + * Command to upgrade an already published package + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * upgrade = (vector bytes) ; move modules + * (vector object-id) ; dependencies + * object-id ; package-id of the package + * argument ; upgrade ticket + * ``` + */ +export class Upgrade extends UniffiAbstractObject implements UpgradeInterface { + readonly [uniffiTypeNameSymbol] = 'Upgrade'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(modules: Array, dependencies: Array, package_: ObjectId, ticket: Argument) { + super(); + + let modulesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterArrayBuffer)).lower(modules)).toStruct(); + let dependenciesArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterArray(FfiConverterTypeObjectId)).lower(dependencies)).toStruct(); + let package_Arg = FfiConverterTypeObjectId.lower(package_); + let ticketArg = FfiConverterTypeArgument.lower(ticket); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_upgrade_new([ + modulesArg, dependenciesArg, package_Arg, ticketArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeUpgradeObjectFactory.bless(pointer); + }// Methods: + + +/** + * Set of packages that the to-be published package depends on + */dependencies(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_upgrade_dependencies([ + uniffiTypeUpgradeObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeObjectId)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * The serialized move modules + */modules(): Array { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_upgrade_modules([ + uniffiTypeUpgradeObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterArrayBuffer)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Package id of the package to upgrade + */package_(): ObjectId { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_upgrade_package([ + uniffiTypeUpgradeObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectId.lift(returnValue); + } + + +/** + * Ticket authorizing the upgrade + */ticket(): Argument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_upgrade_ticket([ + uniffiTypeUpgradeObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeArgument.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeUpgradeObjectFactory.pointer(this); + uniffiTypeUpgradeObjectFactory.freePointer(pointer); + uniffiTypeUpgradeObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is Upgrade { + return uniffiTypeUpgradeObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeUpgradeObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeUpgradeObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): Upgrade { + const instance = Object.create(Upgrade.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'Upgrade'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: Upgrade): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: Upgrade): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_upgrade([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_upgrade([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is Upgrade { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'Upgrade' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeUpgrade = new FfiConverterObject( + uniffiTypeUpgradeObjectFactory +); + + +export type UpgradePolicyInterface = { + +/** + * Returns the internal representation. + */asU8(): /*u8*/number; + +}; + + +/** + * Representation of upgrade policy constants in `iota::package`. + */ +export class UpgradePolicy extends UniffiAbstractObject implements UpgradePolicyInterface { + readonly [uniffiTypeNameSymbol] = 'UpgradePolicy'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + +/** + * Allows adding new functionalities (e.g., new public functions or + * structs) but restricts changes to existing functionalities. + */ + + static additive(): UpgradePolicy { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_upgradepolicy_additive([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUpgradePolicy.lift(returnValue); + } +/** + * The least restrictive policy. Permits changes to all function + * implementations, the removal of ability constraints on generic type + * parameters in function signatures, and modifications to private, + * public(friend), and entry function signatures. However, public function + * signatures and existing types cannot be changed. + */ + + static compatible(): UpgradePolicy { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_upgradepolicy_compatible([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUpgradePolicy.lift(returnValue); + } +/** + * Limits modifications to the package’s dependencies only. + */ + + static depOnly(): UpgradePolicy { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_upgradepolicy_dep_only([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUpgradePolicy.lift(returnValue); + }// Methods: + + +/** + * Returns the internal representation. + */asU8(): /*u8*/number { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_upgradepolicy_as_u8([ + uniffiTypeUpgradePolicyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt8.lift(returnValue); + } + + + // UniffiTrait implementations: + + toString(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_upgradepolicy_uniffi_trait_display([ + uniffiTypeUpgradePolicyObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeUpgradePolicyObjectFactory.pointer(this); + uniffiTypeUpgradePolicyObjectFactory.freePointer(pointer); + uniffiTypeUpgradePolicyObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is UpgradePolicy { + return uniffiTypeUpgradePolicyObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeUpgradePolicyObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeUpgradePolicyObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): UpgradePolicy { + const instance = Object.create(UpgradePolicy.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'UpgradePolicy'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: UpgradePolicy): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: UpgradePolicy): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_upgradepolicy([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_upgradepolicy([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is UpgradePolicy { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'UpgradePolicy' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeUpgradePolicy = new FfiConverterObject( + uniffiTypeUpgradePolicyObjectFactory +); + + +export type UserSignatureInterface = { + asMoveAuthenticator(): MoveAuthenticator; + asMoveAuthenticatorOpt(): MoveAuthenticator | undefined; + asMultisig(): MultisigAggregatedSignature; + asMultisigOpt(): MultisigAggregatedSignature | undefined; + asPasskeyAuthenticator(): PasskeyAuthenticator; + asPasskeyAuthenticatorOpt(): PasskeyAuthenticator | undefined; + asSimple(): SimpleSignature; + asSimpleOpt(): SimpleSignature | undefined; + asZkloginAuthenticator(): ZkLoginAuthenticator; + asZkloginAuthenticatorOpt(): ZkLoginAuthenticator | undefined; + isMoveAuthenticator(): boolean; + isMultisig(): boolean; + isPasskeyAuthenticator(): boolean; + isSimple(): boolean; + isZkloginAuthenticator(): boolean; + +/** + * Return the flag for this signature scheme + */scheme(): SignatureScheme; + toBase64(): string; + toBytes(): ArrayBuffer; + +}; + + +/** + * A signature from a user + * + * A `UserSignature` is most commonly used to authorize the execution and + * inclusion of a transaction to the blockchain. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * user-signature-bcs = bytes ; where the contents of the bytes are defined by + * user-signature = simple-signature / multisig / multisig-legacy / zklogin / passkey / move-authenticator + * ``` + * + * Note: Due to historical reasons, signatures are serialized slightly + * different from the majority of the types in IOTA. In particular if a + * signature is ever embedded in another structure it generally is serialized + * as `bytes` meaning it has a length prefix that defines the length of + * the completely serialized signature. + */ +export class UserSignature extends UniffiAbstractObject implements UserSignatureInterface { + readonly [uniffiTypeNameSymbol] = 'UserSignature'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static fromBase64(base64: string): UserSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let base64Arg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(base64)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_usersignature_from_base64([ + base64Arg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUserSignature.lift(returnValue); + } + + static fromBytes(bytes: ArrayBuffer): UserSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bytes)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_usersignature_from_bytes([ + bytesArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUserSignature.lift(returnValue); + } + + static newMoveAuthenticator(authenticator: MoveAuthenticator): UserSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let authenticatorArg = FfiConverterTypeMoveAuthenticator.lower(authenticator); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_usersignature_new_move_authenticator([ + authenticatorArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUserSignature.lift(returnValue); + } + + static newMultisig(signature: MultisigAggregatedSignature): UserSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let signatureArg = FfiConverterTypeMultisigAggregatedSignature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_usersignature_new_multisig([ + signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUserSignature.lift(returnValue); + } + + static newPasskeyAuthenticator(authenticator: PasskeyAuthenticator): UserSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let authenticatorArg = FfiConverterTypePasskeyAuthenticator.lower(authenticator); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_usersignature_new_passkey_authenticator([ + authenticatorArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUserSignature.lift(returnValue); + } + + static newSimple(signature: SimpleSignature): UserSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let signatureArg = FfiConverterTypeSimpleSignature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_usersignature_new_simple([ + signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUserSignature.lift(returnValue); + } + + static newZkloginAuthenticator(authenticator: ZkLoginAuthenticator): UserSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let authenticatorArg = FfiConverterTypeZkLoginAuthenticator.lower(authenticator); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_usersignature_new_zklogin_authenticator([ + authenticatorArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUserSignature.lift(returnValue); + }// Methods: + + asMoveAuthenticator(): MoveAuthenticator { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_usersignature_as_move_authenticator([ + uniffiTypeUserSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveAuthenticator.lift(returnValue); + } + + asMoveAuthenticatorOpt(): MoveAuthenticator | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_usersignature_as_move_authenticator_opt([ + uniffiTypeUserSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeMoveAuthenticator).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + asMultisig(): MultisigAggregatedSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_usersignature_as_multisig([ + uniffiTypeUserSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMultisigAggregatedSignature.lift(returnValue); + } + + asMultisigOpt(): MultisigAggregatedSignature | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_usersignature_as_multisig_opt([ + uniffiTypeUserSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeMultisigAggregatedSignature).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + asPasskeyAuthenticator(): PasskeyAuthenticator { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_usersignature_as_passkey_authenticator([ + uniffiTypeUserSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePasskeyAuthenticator.lift(returnValue); + } + + asPasskeyAuthenticatorOpt(): PasskeyAuthenticator | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_usersignature_as_passkey_authenticator_opt([ + uniffiTypeUserSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypePasskeyAuthenticator).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + asSimple(): SimpleSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_usersignature_as_simple([ + uniffiTypeUserSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSimpleSignature.lift(returnValue); + } + + asSimpleOpt(): SimpleSignature | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_usersignature_as_simple_opt([ + uniffiTypeUserSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeSimpleSignature).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + asZkloginAuthenticator(): ZkLoginAuthenticator { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_usersignature_as_zklogin_authenticator([ + uniffiTypeUserSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeZkLoginAuthenticator.lift(returnValue); + } + + asZkloginAuthenticatorOpt(): ZkLoginAuthenticator | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_usersignature_as_zklogin_authenticator_opt([ + uniffiTypeUserSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeZkLoginAuthenticator).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + isMoveAuthenticator(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_usersignature_is_move_authenticator([ + uniffiTypeUserSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + isMultisig(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_usersignature_is_multisig([ + uniffiTypeUserSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + isPasskeyAuthenticator(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_usersignature_is_passkey_authenticator([ + uniffiTypeUserSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + isSimple(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_usersignature_is_simple([ + uniffiTypeUserSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + isZkloginAuthenticator(): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_usersignature_is_zklogin_authenticator([ + uniffiTypeUserSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + +/** + * Return the flag for this signature scheme + */scheme(): SignatureScheme { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_usersignature_scheme([ + uniffiTypeUserSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSignatureScheme.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + toBase64(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_usersignature_to_base64([ + uniffiTypeUserSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + toBytes(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_usersignature_to_bytes([ + uniffiTypeUserSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeUserSignatureObjectFactory.pointer(this); + uniffiTypeUserSignatureObjectFactory.freePointer(pointer); + uniffiTypeUserSignatureObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is UserSignature { + return uniffiTypeUserSignatureObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeUserSignatureObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeUserSignatureObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): UserSignature { + const instance = Object.create(UserSignature.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'UserSignature'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: UserSignature): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: UserSignature): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_usersignature([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_usersignature([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is UserSignature { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'UserSignature' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeUserSignature = new FfiConverterObject( + uniffiTypeUserSignatureObjectFactory +); + + +export type UserSignatureVerifierInterface = { + verify(message: ArrayBuffer, signature: UserSignature): void; + withZkloginVerifier(zkloginVerifier: ZkloginVerifier): UserSignatureVerifier; + zkloginVerifier(): ZkloginVerifier | undefined; + +}; + + +/** + * Verifier that will verify all UserSignature variants + */ +export class UserSignatureVerifier extends UniffiAbstractObject implements UserSignatureVerifierInterface { + readonly [uniffiTypeNameSymbol] = 'UserSignatureVerifier'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor() { + super(); + + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_usersignatureverifier_new([ + callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeUserSignatureVerifierObjectFactory.bless(pointer); + }// Methods: + + verify(message: ArrayBuffer, signature: UserSignature): void { + /* Regular function call: */ + uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + let signatureArg = FfiConverterTypeUserSignature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_usersignatureverifier_verify([ + uniffiTypeUserSignatureVerifierObjectFactory.clonePointer(this), messageArg, signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + withZkloginVerifier(zkloginVerifier: ZkloginVerifier): UserSignatureVerifier { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let zkloginVerifierArg = FfiConverterTypeZkloginVerifier.lower(zkloginVerifier); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_usersignatureverifier_with_zklogin_verifier([ + uniffiTypeUserSignatureVerifierObjectFactory.clonePointer(this), zkloginVerifierArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUserSignatureVerifier.lift(returnValue); + } + + zkloginVerifier(): ZkloginVerifier | undefined { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_usersignatureverifier_zklogin_verifier([ + uniffiTypeUserSignatureVerifierObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return new FfiConverterOptional(FfiConverterTypeZkloginVerifier).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeUserSignatureVerifierObjectFactory.pointer(this); + uniffiTypeUserSignatureVerifierObjectFactory.freePointer(pointer); + uniffiTypeUserSignatureVerifierObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is UserSignatureVerifier { + return uniffiTypeUserSignatureVerifierObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeUserSignatureVerifierObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeUserSignatureVerifierObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): UserSignatureVerifier { + const instance = Object.create(UserSignatureVerifier.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'UserSignatureVerifier'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: UserSignatureVerifier): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: UserSignatureVerifier): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_usersignatureverifier([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_usersignatureverifier([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is UserSignatureVerifier { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'UserSignatureVerifier' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeUserSignatureVerifier = new FfiConverterObject( + uniffiTypeUserSignatureVerifierObjectFactory +); + + +export type ValidatorAggregatedSignatureInterface = { + bitmapBytes(): ArrayBuffer; + epoch(): /*u64*/bigint; + signature(): Bls12381Signature; + +}; + + +/** + * An aggregated signature from multiple Validators. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * validator-aggregated-signature = u64 ; epoch + * bls-signature + * roaring-bitmap + * roaring-bitmap = bytes ; where the contents of the bytes are valid + * ; according to the serialized spec for + * ; roaring bitmaps + * ``` + * + * See for the specification for the + * serialized format of RoaringBitmaps. + */ +export class ValidatorAggregatedSignature extends UniffiAbstractObject implements ValidatorAggregatedSignatureInterface { + readonly [uniffiTypeNameSymbol] = 'ValidatorAggregatedSignature'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(epoch: /*u64*/bigint, signature: Bls12381Signature, bitmapBytes: ArrayBuffer) { + super(); + + let epochArg = FfiConverterUInt64.lower(epoch); + let signatureArg = FfiConverterTypeBls12381Signature.lower(signature); + let bitmapBytesArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bitmapBytes)).toStruct(); + const pointer =uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_validatoraggregatedsignature_new([ + epochArg, signatureArg, bitmapBytesArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeValidatorAggregatedSignatureObjectFactory.bless(pointer); + }// Methods: + + bitmapBytes(): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_validatoraggregatedsignature_bitmap_bytes([ + uniffiTypeValidatorAggregatedSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + epoch(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_validatoraggregatedsignature_epoch([ + uniffiTypeValidatorAggregatedSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + signature(): Bls12381Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_validatoraggregatedsignature_signature([ + uniffiTypeValidatorAggregatedSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeBls12381Signature.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeValidatorAggregatedSignatureObjectFactory.pointer(this); + uniffiTypeValidatorAggregatedSignatureObjectFactory.freePointer(pointer); + uniffiTypeValidatorAggregatedSignatureObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is ValidatorAggregatedSignature { + return uniffiTypeValidatorAggregatedSignatureObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeValidatorAggregatedSignatureObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeValidatorAggregatedSignatureObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): ValidatorAggregatedSignature { + const instance = Object.create(ValidatorAggregatedSignature.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'ValidatorAggregatedSignature'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: ValidatorAggregatedSignature): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: ValidatorAggregatedSignature): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_validatoraggregatedsignature([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_validatoraggregatedsignature([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is ValidatorAggregatedSignature { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'ValidatorAggregatedSignature' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeValidatorAggregatedSignature = new FfiConverterObject( + uniffiTypeValidatorAggregatedSignatureObjectFactory +); + + +export type ValidatorCommitteeSignatureAggregatorInterface = { + addSignature(signature: ValidatorSignature): void; + committee(): ValidatorCommittee; + finish(): ValidatorAggregatedSignature; + +}; + + +export class ValidatorCommitteeSignatureAggregator extends UniffiAbstractObject implements ValidatorCommitteeSignatureAggregatorInterface { + readonly [uniffiTypeNameSymbol] = 'ValidatorCommitteeSignatureAggregator'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + + static newCheckpointSummary(committee: ValidatorCommittee, summary: CheckpointSummary): ValidatorCommitteeSignatureAggregator { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let committeeArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeValidatorCommittee.lower(committee)).toStruct(); + let summaryArg = FfiConverterTypeCheckpointSummary.lower(summary); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_validatorcommitteesignatureaggregator_new_checkpoint_summary([ + committeeArg, summaryArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeValidatorCommitteeSignatureAggregator.lift(returnValue); + }// Methods: + + addSignature(signature: ValidatorSignature): void { + /* Regular function call: */ + uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let signatureArg = FfiConverterTypeValidatorSignature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_validatorcommitteesignatureaggregator_add_signature([ + uniffiTypeValidatorCommitteeSignatureAggregatorObjectFactory.clonePointer(this), signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + committee(): ValidatorCommittee { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_validatorcommitteesignatureaggregator_committee([ + uniffiTypeValidatorCommitteeSignatureAggregatorObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeValidatorCommittee.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + finish(): ValidatorAggregatedSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_validatorcommitteesignatureaggregator_finish([ + uniffiTypeValidatorCommitteeSignatureAggregatorObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeValidatorAggregatedSignature.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeValidatorCommitteeSignatureAggregatorObjectFactory.pointer(this); + uniffiTypeValidatorCommitteeSignatureAggregatorObjectFactory.freePointer(pointer); + uniffiTypeValidatorCommitteeSignatureAggregatorObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is ValidatorCommitteeSignatureAggregator { + return uniffiTypeValidatorCommitteeSignatureAggregatorObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeValidatorCommitteeSignatureAggregatorObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeValidatorCommitteeSignatureAggregatorObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): ValidatorCommitteeSignatureAggregator { + const instance = Object.create(ValidatorCommitteeSignatureAggregator.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'ValidatorCommitteeSignatureAggregator'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: ValidatorCommitteeSignatureAggregator): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: ValidatorCommitteeSignatureAggregator): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_validatorcommitteesignatureaggregator([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_validatorcommitteesignatureaggregator([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is ValidatorCommitteeSignatureAggregator { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'ValidatorCommitteeSignatureAggregator' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeValidatorCommitteeSignatureAggregator = new FfiConverterObject( + uniffiTypeValidatorCommitteeSignatureAggregatorObjectFactory +); + + +export type ValidatorCommitteeSignatureVerifierInterface = { + committee(): ValidatorCommittee; + verify(message: ArrayBuffer, signature: ValidatorSignature): void; + verifyAggregated(message: ArrayBuffer, signature: ValidatorAggregatedSignature): void; + verifyCheckpointSummary(summary: CheckpointSummary, signature: ValidatorAggregatedSignature): void; + +}; + + +export class ValidatorCommitteeSignatureVerifier extends UniffiAbstractObject implements ValidatorCommitteeSignatureVerifierInterface { + readonly [uniffiTypeNameSymbol] = 'ValidatorCommitteeSignatureVerifier'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(committee: ValidatorCommittee) { + super(); + + let committeeArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeValidatorCommittee.lower(committee)).toStruct(); + const pointer =uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_validatorcommitteesignatureverifier_new([ + committeeArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeValidatorCommitteeSignatureVerifierObjectFactory.bless(pointer); + }// Methods: + + committee(): ValidatorCommittee { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_validatorcommitteesignatureverifier_committee([ + uniffiTypeValidatorCommitteeSignatureVerifierObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeValidatorCommittee.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + verify(message: ArrayBuffer, signature: ValidatorSignature): void { + /* Regular function call: */ + uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + let signatureArg = FfiConverterTypeValidatorSignature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_validatorcommitteesignatureverifier_verify([ + uniffiTypeValidatorCommitteeSignatureVerifierObjectFactory.clonePointer(this), messageArg, signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + verifyAggregated(message: ArrayBuffer, signature: ValidatorAggregatedSignature): void { + /* Regular function call: */ + uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + let signatureArg = FfiConverterTypeValidatorAggregatedSignature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_validatorcommitteesignatureverifier_verify_aggregated([ + uniffiTypeValidatorCommitteeSignatureVerifierObjectFactory.clonePointer(this), messageArg, signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + verifyCheckpointSummary(summary: CheckpointSummary, signature: ValidatorAggregatedSignature): void { + /* Regular function call: */ + uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let summaryArg = FfiConverterTypeCheckpointSummary.lower(summary); + let signatureArg = FfiConverterTypeValidatorAggregatedSignature.lower(signature); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_validatorcommitteesignatureverifier_verify_checkpoint_summary([ + uniffiTypeValidatorCommitteeSignatureVerifierObjectFactory.clonePointer(this), summaryArg, signatureArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + + // UniffiTrait implementations: + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeValidatorCommitteeSignatureVerifierObjectFactory.pointer(this); + uniffiTypeValidatorCommitteeSignatureVerifierObjectFactory.freePointer(pointer); + uniffiTypeValidatorCommitteeSignatureVerifierObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is ValidatorCommitteeSignatureVerifier { + return uniffiTypeValidatorCommitteeSignatureVerifierObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeValidatorCommitteeSignatureVerifierObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeValidatorCommitteeSignatureVerifierObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): ValidatorCommitteeSignatureVerifier { + const instance = Object.create(ValidatorCommitteeSignatureVerifier.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'ValidatorCommitteeSignatureVerifier'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: ValidatorCommitteeSignatureVerifier): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: ValidatorCommitteeSignatureVerifier): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_validatorcommitteesignatureverifier([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_validatorcommitteesignatureverifier([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is ValidatorCommitteeSignatureVerifier { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'ValidatorCommitteeSignatureVerifier' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeValidatorCommitteeSignatureVerifier = new FfiConverterObject( + uniffiTypeValidatorCommitteeSignatureVerifierObjectFactory +); + + +export type ValidatorExecutionTimeObservationInterface = { + duration(): number /* in milliseconds */; + validator(): Bls12381PublicKey; + +}; + + +/** + * An execution time observation from a particular validator + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * execution-time-observation = bls-public-key duration + * duration = u64 ; seconds + * u32 ; subsecond nanoseconds + * ``` + */ +export class ValidatorExecutionTimeObservation extends UniffiAbstractObject implements ValidatorExecutionTimeObservationInterface { + readonly [uniffiTypeNameSymbol] = 'ValidatorExecutionTimeObservation'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(validator: Bls12381PublicKey, duration: number /* in milliseconds */) { + super(); + + let validatorArg = FfiConverterTypeBls12381PublicKey.lower(validator); + let durationArg = FfiConverterDuration.lower(duration); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_validatorexecutiontimeobservation_new([ + validatorArg, durationArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeValidatorExecutionTimeObservationObjectFactory.bless(pointer); + }// Methods: + + duration(): number /* in milliseconds */ { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_validatorexecutiontimeobservation_duration([ + uniffiTypeValidatorExecutionTimeObservationObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterDuration.lift(returnValue); + } + + validator(): Bls12381PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_validatorexecutiontimeobservation_validator([ + uniffiTypeValidatorExecutionTimeObservationObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeBls12381PublicKey.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeValidatorExecutionTimeObservationObjectFactory.pointer(this); + uniffiTypeValidatorExecutionTimeObservationObjectFactory.freePointer(pointer); + uniffiTypeValidatorExecutionTimeObservationObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is ValidatorExecutionTimeObservation { + return uniffiTypeValidatorExecutionTimeObservationObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeValidatorExecutionTimeObservationObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeValidatorExecutionTimeObservationObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): ValidatorExecutionTimeObservation { + const instance = Object.create(ValidatorExecutionTimeObservation.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'ValidatorExecutionTimeObservation'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: ValidatorExecutionTimeObservation): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: ValidatorExecutionTimeObservation): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_validatorexecutiontimeobservation([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_validatorexecutiontimeobservation([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is ValidatorExecutionTimeObservation { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'ValidatorExecutionTimeObservation' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeValidatorExecutionTimeObservation = new FfiConverterObject( + uniffiTypeValidatorExecutionTimeObservationObjectFactory +); + + +export type ValidatorSignatureInterface = { + epoch(): /*u64*/bigint; + publicKey(): Bls12381PublicKey; + signature(): Bls12381Signature; + +}; + + +/** + * A signature from a Validator + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * validator-signature = u64 ; epoch + * bls-public-key + * bls-signature + * ``` + */ +export class ValidatorSignature extends UniffiAbstractObject implements ValidatorSignatureInterface { + readonly [uniffiTypeNameSymbol] = 'ValidatorSignature'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(epoch: /*u64*/bigint, publicKey: Bls12381PublicKey, signature: Bls12381Signature) { + super(); + + let epochArg = FfiConverterUInt64.lower(epoch); + let publicKeyArg = FfiConverterTypeBls12381PublicKey.lower(publicKey); + let signatureArg = FfiConverterTypeBls12381Signature.lower(signature); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_validatorsignature_new([ + epochArg, publicKeyArg, signatureArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeValidatorSignatureObjectFactory.bless(pointer); + }// Methods: + + epoch(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_validatorsignature_epoch([ + uniffiTypeValidatorSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + publicKey(): Bls12381PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_validatorsignature_public_key([ + uniffiTypeValidatorSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeBls12381PublicKey.lift(returnValue); + } + + signature(): Bls12381Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_validatorsignature_signature([ + uniffiTypeValidatorSignatureObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeBls12381Signature.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeValidatorSignatureObjectFactory.pointer(this); + uniffiTypeValidatorSignatureObjectFactory.freePointer(pointer); + uniffiTypeValidatorSignatureObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is ValidatorSignature { + return uniffiTypeValidatorSignatureObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeValidatorSignatureObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeValidatorSignatureObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): ValidatorSignature { + const instance = Object.create(ValidatorSignature.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'ValidatorSignature'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: ValidatorSignature): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: ValidatorSignature): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_validatorsignature([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_validatorsignature([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is ValidatorSignature { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'ValidatorSignature' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeValidatorSignature = new FfiConverterObject( + uniffiTypeValidatorSignatureObjectFactory +); + + +export type VersionAssignmentInterface = { + objectId(): ObjectId; + version(): /*u64*/bigint; + +}; + + +/** + * Object version assignment from consensus + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * version-assignment = object-id u64 + * ``` + */ +export class VersionAssignment extends UniffiAbstractObject implements VersionAssignmentInterface { + readonly [uniffiTypeNameSymbol] = 'VersionAssignment'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(objectId: ObjectId, version: /*u64*/bigint) { + super(); + + let objectIdArg = FfiConverterTypeObjectId.lower(objectId); + let versionArg = FfiConverterUInt64.lower(version); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_versionassignment_new([ + objectIdArg, versionArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeVersionAssignmentObjectFactory.bless(pointer); + }// Methods: + + objectId(): ObjectId { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_versionassignment_object_id([ + uniffiTypeVersionAssignmentObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectId.lift(returnValue); + } + + version(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_versionassignment_version([ + uniffiTypeVersionAssignmentObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeVersionAssignmentObjectFactory.pointer(this); + uniffiTypeVersionAssignmentObjectFactory.freePointer(pointer); + uniffiTypeVersionAssignmentObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is VersionAssignment { + return uniffiTypeVersionAssignmentObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeVersionAssignmentObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeVersionAssignmentObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): VersionAssignment { + const instance = Object.create(VersionAssignment.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'VersionAssignment'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: VersionAssignment): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: VersionAssignment): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_versionassignment([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_versionassignment([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is VersionAssignment { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'VersionAssignment' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeVersionAssignment = new FfiConverterObject( + uniffiTypeVersionAssignmentObjectFactory +); + + +export type ZkLoginAuthenticatorInterface = { + inputs(): ZkLoginInputs; + maxEpoch(): /*u64*/bigint; + signature(): SimpleSignature; + +}; + + +/** + * A zklogin authenticator + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * zklogin-bcs = bytes ; contents are defined by + * zklogin = zklogin-flag + * zklogin-inputs + * u64 ; max epoch + * simple-signature + * ``` + * + * Note: Due to historical reasons, signatures are serialized slightly + * different from the majority of the types in IOTA. In particular if a + * signature is ever embedded in another structure it generally is serialized + * as `bytes` meaning it has a length prefix that defines the length of + * the completely serialized signature. + */ +export class ZkLoginAuthenticator extends UniffiAbstractObject implements ZkLoginAuthenticatorInterface { + readonly [uniffiTypeNameSymbol] = 'ZkLoginAuthenticator'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(inputs: ZkLoginInputs, maxEpoch: /*u64*/bigint, signature: SimpleSignature) { + super(); + + let inputsArg = FfiConverterTypeZkLoginInputs.lower(inputs); + let maxEpochArg = FfiConverterUInt64.lower(maxEpoch); + let signatureArg = FfiConverterTypeSimpleSignature.lower(signature); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_zkloginauthenticator_new([ + inputsArg, maxEpochArg, signatureArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeZkLoginAuthenticatorObjectFactory.bless(pointer); + }// Methods: + + inputs(): ZkLoginInputs { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_zkloginauthenticator_inputs([ + uniffiTypeZkLoginAuthenticatorObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeZkLoginInputs.lift(returnValue); + } + + maxEpoch(): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_zkloginauthenticator_max_epoch([ + uniffiTypeZkLoginAuthenticatorObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + signature(): SimpleSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_zkloginauthenticator_signature([ + uniffiTypeZkLoginAuthenticatorObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSimpleSignature.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeZkLoginAuthenticatorObjectFactory.pointer(this); + uniffiTypeZkLoginAuthenticatorObjectFactory.freePointer(pointer); + uniffiTypeZkLoginAuthenticatorObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is ZkLoginAuthenticator { + return uniffiTypeZkLoginAuthenticatorObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeZkLoginAuthenticatorObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeZkLoginAuthenticatorObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): ZkLoginAuthenticator { + const instance = Object.create(ZkLoginAuthenticator.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'ZkLoginAuthenticator'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: ZkLoginAuthenticator): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: ZkLoginAuthenticator): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_zkloginauthenticator([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_zkloginauthenticator([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is ZkLoginAuthenticator { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'ZkLoginAuthenticator' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeZkLoginAuthenticator = new FfiConverterObject( + uniffiTypeZkLoginAuthenticatorObjectFactory +); + + +export type ZkLoginInputsInterface = { + addressSeed(): Bn254FieldElement; + headerBase64(): string; + iss(): string; + issBase64Details(): ZkLoginClaim; + jwkId(): JwkId; + proofPoints(): ZkLoginProof; + publicIdentifier(): ZkLoginPublicIdentifier; + +}; + + +/** + * A zklogin groth16 proof and the required inputs to perform proof + * verification. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * zklogin-inputs = zklogin-proof + * zklogin-claim + * string ; base64url-unpadded encoded JwtHeader + * bn254-field-element ; address_seed + * ``` + */ +export class ZkLoginInputs extends UniffiAbstractObject implements ZkLoginInputsInterface { + readonly [uniffiTypeNameSymbol] = 'ZkLoginInputs'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(proofPoints: ZkLoginProof, issBase64Details: ZkLoginClaim, headerBase64: string, addressSeed: Bn254FieldElement) { + super(); + + let proofPointsArg = FfiConverterTypeZkLoginProof.lower(proofPoints); + let issBase64DetailsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeZkLoginClaim.lower(issBase64Details)).toStruct(); + let headerBase64Arg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(headerBase64)).toStruct(); + let addressSeedArg = FfiConverterTypeBn254FieldElement.lower(addressSeed); + const pointer =uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_zklogininputs_new([ + proofPointsArg, issBase64DetailsArg, headerBase64Arg, addressSeedArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeZkLoginInputsObjectFactory.bless(pointer); + }// Methods: + + addressSeed(): Bn254FieldElement { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_zklogininputs_address_seed([ + uniffiTypeZkLoginInputsObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeBn254FieldElement.lift(returnValue); + } + + headerBase64(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_zklogininputs_header_base64([ + uniffiTypeZkLoginInputsObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + iss(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_zklogininputs_iss([ + uniffiTypeZkLoginInputsObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + issBase64Details(): ZkLoginClaim { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_zklogininputs_iss_base64_details([ + uniffiTypeZkLoginInputsObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeZkLoginClaim.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + jwkId(): JwkId { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_zklogininputs_jwk_id([ + uniffiTypeZkLoginInputsObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeJwkId.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + proofPoints(): ZkLoginProof { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_zklogininputs_proof_points([ + uniffiTypeZkLoginInputsObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeZkLoginProof.lift(returnValue); + } + + publicIdentifier(): ZkLoginPublicIdentifier { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_zklogininputs_public_identifier([ + uniffiTypeZkLoginInputsObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeZkLoginPublicIdentifier.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeZkLoginInputsObjectFactory.pointer(this); + uniffiTypeZkLoginInputsObjectFactory.freePointer(pointer); + uniffiTypeZkLoginInputsObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is ZkLoginInputs { + return uniffiTypeZkLoginInputsObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeZkLoginInputsObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeZkLoginInputsObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): ZkLoginInputs { + const instance = Object.create(ZkLoginInputs.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'ZkLoginInputs'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: ZkLoginInputs): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: ZkLoginInputs): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_zklogininputs([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_zklogininputs([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is ZkLoginInputs { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'ZkLoginInputs' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeZkLoginInputs = new FfiConverterObject( + uniffiTypeZkLoginInputsObjectFactory +); + + +export type ZkLoginProofInterface = { + a(): CircomG1; + b(): CircomG2; + c(): CircomG1; + +}; + + +/** + * A zklogin groth16 proof + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * zklogin-proof = circom-g1 circom-g2 circom-g1 + * ``` + */ +export class ZkLoginProof extends UniffiAbstractObject implements ZkLoginProofInterface { + readonly [uniffiTypeNameSymbol] = 'ZkLoginProof'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(a: CircomG1, b: CircomG2, c: CircomG1) { + super(); + + let aArg = FfiConverterTypeCircomG1.lower(a); + let bArg = FfiConverterTypeCircomG2.lower(b); + let cArg = FfiConverterTypeCircomG1.lower(c); + const pointer =uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_zkloginproof_new([ + aArg, bArg, cArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeZkLoginProofObjectFactory.bless(pointer); + }// Methods: + + a(): CircomG1 { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_zkloginproof_a([ + uniffiTypeZkLoginProofObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCircomG1.lift(returnValue); + } + + b(): CircomG2 { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_zkloginproof_b([ + uniffiTypeZkLoginProofObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCircomG2.lift(returnValue); + } + + c(): CircomG1 { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_zkloginproof_c([ + uniffiTypeZkLoginProofObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCircomG1.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeZkLoginProofObjectFactory.pointer(this); + uniffiTypeZkLoginProofObjectFactory.freePointer(pointer); + uniffiTypeZkLoginProofObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is ZkLoginProof { + return uniffiTypeZkLoginProofObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeZkLoginProofObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeZkLoginProofObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): ZkLoginProof { + const instance = Object.create(ZkLoginProof.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'ZkLoginProof'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: ZkLoginProof): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: ZkLoginProof): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_zkloginproof([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_zkloginproof([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is ZkLoginProof { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'ZkLoginProof' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeZkLoginProof = new FfiConverterObject( + uniffiTypeZkLoginProofObjectFactory +); + + +export type ZkLoginPublicIdentifierInterface = { + addressSeed(): Bn254FieldElement; + +/** + * Provides an iterator over the addresses that correspond to this zklogin + * authenticator. + * + * In the majority of instances this will only yield a single address, + * except for the instances where the `address_seed` value has a + * leading zero-byte, in such cases the returned iterator will yield + * two addresses. + */deriveAddress(): Array
; + +/** + * Derive an `Address` from this `ZkLoginPublicIdentifier` by hashing the + * byte length of the `iss` followed by the `iss` bytes themselves and + * the full 32 byte `address_seed` value, all prefixed with the zklogin + * `SignatureScheme` flag (`0x05`). + * + * `hash( 0x05 || iss_bytes_len || iss_bytes || 32_byte_address_seed )` + */deriveAddressPadded(): Address; + +/** + * Derive an `Address` from this `ZkLoginPublicIdentifier` by hashing the + * byte length of the `iss` followed by the `iss` bytes themselves and + * the `address_seed` bytes with any leading zero-bytes stripped, all + * prefixed with the zklogin `SignatureScheme` flag (`0x05`). + * + * `hash( 0x05 || iss_bytes_len || iss_bytes || + * unpadded_32_byte_address_seed )` + */deriveAddressUnpadded(): Address; + iss(): string; + +}; + + +/** + * Public Key equivalent for Zklogin authenticators + * + * A `ZkLoginPublicIdentifier` is the equivalent of a public key for other + * account authenticators, and contains the information required to derive the + * onchain account `Address` for a Zklogin authenticator. + * + * ## Note + * + * Due to a historical bug that was introduced in the IOTA Typescript SDK when + * the zklogin authenticator was first introduced, there are now possibly two + * "valid" addresses for each zklogin authenticator depending on the + * bit-pattern of the `address_seed` value. + * + * The original bug incorrectly derived a zklogin's address by stripping any + * leading zero-bytes that could have been present in the 32-byte length + * `address_seed` value prior to hashing, leading to a different derived + * address. This incorrectly derived address was presented to users of various + * wallets, leading them to sending funds to these addresses that they couldn't + * access. Instead of letting these users lose any assets that were sent to + * these addresses, the IOTA network decided to change the protocol to allow + * for a zklogin authenticator who's `address_seed` value had leading + * zero-bytes be authorized to sign for both the addresses derived from both + * the unpadded and padded `address_seed` value. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * zklogin-public-identifier-bcs = bytes ; where the contents are defined by + * ; + * + * zklogin-public-identifier = zklogin-public-identifier-iss + * address-seed + * + * zklogin-public-identifier-unpadded = zklogin-public-identifier-iss + * address-seed-unpadded + * + * ; The iss, or issuer, is a utf8 string that is less than 255 bytes long + * ; and is serialized with the iss's length in bytes as a u8 followed by + * ; the bytes of the iss + * zklogin-public-identifier-iss = u8 *255(OCTET) + * + * ; A Bn254FieldElement serialized as a 32-byte big-endian value + * address-seed = 32(OCTET) + * + * ; A Bn254FieldElement serialized as a 32-byte big-endian value + * ; with any leading zero bytes stripped + * address-seed-unpadded = %x00 / %x01-ff *31(OCTET) + * ``` + */ +export class ZkLoginPublicIdentifier extends UniffiAbstractObject implements ZkLoginPublicIdentifierInterface { + readonly [uniffiTypeNameSymbol] = 'ZkLoginPublicIdentifier'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + + constructor(iss: string, addressSeed: Bn254FieldElement) { + super(); + + let issArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(iss)).toStruct(); + let addressSeedArg = FfiConverterTypeBn254FieldElement.lower(addressSeed); + const pointer =uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_zkloginpublicidentifier_new([ + issArg, addressSeedArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + + this[pointerLiteralSymbol] = pointer; + this[destructorGuardSymbol] = uniffiTypeZkLoginPublicIdentifierObjectFactory.bless(pointer); + }// Methods: + + addressSeed(): Bn254FieldElement { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_zkloginpublicidentifier_address_seed([ + uniffiTypeZkLoginPublicIdentifierObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeBn254FieldElement.lift(returnValue); + } + + +/** + * Provides an iterator over the addresses that correspond to this zklogin + * authenticator. + * + * In the majority of instances this will only yield a single address, + * except for the instances where the `address_seed` value has a + * leading zero-byte, in such cases the returned iterator will yield + * two addresses. + */deriveAddress(): Array
{ + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_zkloginpublicidentifier_derive_address([ + uniffiTypeZkLoginPublicIdentifierObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterArray(FfiConverterTypeAddress)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + +/** + * Derive an `Address` from this `ZkLoginPublicIdentifier` by hashing the + * byte length of the `iss` followed by the `iss` bytes themselves and + * the full 32 byte `address_seed` value, all prefixed with the zklogin + * `SignatureScheme` flag (`0x05`). + * + * `hash( 0x05 || iss_bytes_len || iss_bytes || 32_byte_address_seed )` + */deriveAddressPadded(): Address { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_zkloginpublicidentifier_derive_address_padded([ + uniffiTypeZkLoginPublicIdentifierObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeAddress.lift(returnValue); + } + + +/** + * Derive an `Address` from this `ZkLoginPublicIdentifier` by hashing the + * byte length of the `iss` followed by the `iss` bytes themselves and + * the `address_seed` bytes with any leading zero-bytes stripped, all + * prefixed with the zklogin `SignatureScheme` flag (`0x05`). + * + * `hash( 0x05 || iss_bytes_len || iss_bytes || + * unpadded_32_byte_address_seed )` + */deriveAddressUnpadded(): Address { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_zkloginpublicidentifier_derive_address_unpadded([ + uniffiTypeZkLoginPublicIdentifierObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeAddress.lift(returnValue); + } + + iss(): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_zkloginpublicidentifier_iss([ + uniffiTypeZkLoginPublicIdentifierObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + // UniffiTrait implementations: + + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeZkLoginPublicIdentifierObjectFactory.pointer(this); + uniffiTypeZkLoginPublicIdentifierObjectFactory.freePointer(pointer); + uniffiTypeZkLoginPublicIdentifierObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is ZkLoginPublicIdentifier { + return uniffiTypeZkLoginPublicIdentifierObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeZkLoginPublicIdentifierObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeZkLoginPublicIdentifierObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): ZkLoginPublicIdentifier { + const instance = Object.create(ZkLoginPublicIdentifier.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'ZkLoginPublicIdentifier'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: ZkLoginPublicIdentifier): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: ZkLoginPublicIdentifier): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_zkloginpublicidentifier([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_zkloginpublicidentifier([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is ZkLoginPublicIdentifier { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'ZkLoginPublicIdentifier' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeZkLoginPublicIdentifier = new FfiConverterObject( + uniffiTypeZkLoginPublicIdentifierObjectFactory +); + + +export type ZkloginVerifierInterface = { + jwks(): Map; + verify(message: ArrayBuffer, authenticator: ZkLoginAuthenticator): void; + withJwks(jwks: Map): ZkloginVerifier; + +}; + + +export class ZkloginVerifier extends UniffiAbstractObject implements ZkloginVerifierInterface { + readonly [uniffiTypeNameSymbol] = 'ZkloginVerifier'; + readonly [destructorGuardSymbol]: UniffiRustArcPtr; + readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer; + + // Constructors: + +/** + * Load a fixed verifying key from zkLogin.vkey output. This is based on a + * local setup and should not be used in production. + */ + + static newDev(): ZkloginVerifier { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_zkloginverifier_new_dev([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeZkloginVerifier.lift(returnValue); + } + + static newMainnet(): ZkloginVerifier { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_constructor_zkloginverifier_new_mainnet([ + callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeZkloginVerifier.lift(returnValue); + }// Methods: + + jwks(): Map { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_zkloginverifier_jwks([ + uniffiTypeZkloginVerifierObjectFactory.clonePointer(this), callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return (new FfiConverterMap(FfiConverterTypeJwkId, FfiConverterTypeJwk)).lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + verify(message: ArrayBuffer, authenticator: ZkLoginAuthenticator): void { + /* Regular function call: */ + uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let messageArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(message)).toStruct(); + let authenticatorArg = FfiConverterTypeZkLoginAuthenticator.lower(authenticator); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_zkloginverifier_verify([ + uniffiTypeZkloginVerifierObjectFactory.clonePointer(this), messageArg, authenticatorArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + + } + + withJwks(jwks: Map): ZkloginVerifier { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let jwksArg = UniffiRustBufferValue.allocateWithBytes((new FfiConverterMap(FfiConverterTypeJwkId, FfiConverterTypeJwk)).lower(jwks)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_method_zkloginverifier_with_jwks([ + uniffiTypeZkloginVerifierObjectFactory.clonePointer(this), jwksArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeZkloginVerifier.lift(returnValue); + } + + + // UniffiTrait implementations: + + + + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (typeof ptr !== 'undefined') { + const pointer = uniffiTypeZkloginVerifierObjectFactory.pointer(this); + uniffiTypeZkloginVerifierObjectFactory.freePointer(pointer); + uniffiTypeZkloginVerifierObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + [Symbol.dispose] = this.uniffiDestroy + + static instanceOf(obj: any): obj is ZkloginVerifier { + return uniffiTypeZkloginVerifierObjectFactory.isConcreteType(obj); + } + + // FIXME: maybe add `.equal(a, b)` static method like many protobuf libraries have? + // FIXME: maybe add `.clone()` method? +} + +const uniffiTypeZkloginVerifierObjectFactory: UniffiObjectFactory = + (() => { + /// + const registry = + typeof (globalThis as any).FinalizationRegistry !== 'undefined' + ? new (globalThis as any).FinalizationRegistry( + (heldValue: UnsafeMutableRawPointer) => { + uniffiTypeZkloginVerifierObjectFactory.freePointer(heldValue); + } + ) + : null; + + return { + create(pointer: UnsafeMutableRawPointer): ZkloginVerifier { + const instance = Object.create(ZkloginVerifier.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = 'ZkloginVerifier'; + return instance; + }, + + bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr: UniffiRustArcPtr) { + if (registry) { + registry.unregister(ptr); + } + }, + + pointer(obj: ZkloginVerifier): UnsafeMutableRawPointer { + if (typeof (obj as any)[destructorGuardSymbol] === 'undefined') { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj: ZkloginVerifier): UnsafeMutableRawPointer { + const handleArg = this.pointer(obj); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_clone_zkloginverifier([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(handleArg: UnsafeMutableRawPointer): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_free_zkloginverifier([ + handleArg, callStatus + ]); + }, + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj: any): obj is ZkloginVerifier { + return ( + obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === 'ZkloginVerifier' + ); + }, + }; + })(); + +// FfiConverter for TodoListInterface +const FfiConverterTypeZkloginVerifier = new FfiConverterObject( + uniffiTypeZkloginVerifierObjectFactory +); + + + +// ========== +// Function definitions: +// ========== + + + +/** + * Create this type from BCS encoded bytes. + */ +export function activeJwkFromBcs(bcs: ArrayBuffer): ActiveJwk { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_active_jwk_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeActiveJwk.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function activeJwkFromJson(json: string): ActiveJwk { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_active_jwk_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeActiveJwk.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function activeJwkToBcs(data: ActiveJwk): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeActiveJwk.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_active_jwk_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function activeJwkToJson(data: ActiveJwk): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeActiveJwk.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_active_jwk_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function addressFromBcs(bcs: ArrayBuffer): Address { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_address_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeAddress.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function addressFromJson(json: string): Address { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_address_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeAddress.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function addressToBcs(data: Address): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeAddress.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_address_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function addressToJson(data: Address): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeAddress.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_address_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function argumentFromBcs(bcs: ArrayBuffer): Argument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_argument_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeArgument.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function argumentFromJson(json: string): Argument { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_argument_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeArgument.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function argumentToBcs(data: Argument): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeArgument.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_argument_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function argumentToJson(data: Argument): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeArgument.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_argument_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function authenticatorStateExpireFromBcs(bcs: ArrayBuffer): AuthenticatorStateExpire { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_authenticator_state_expire_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeAuthenticatorStateExpire.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function authenticatorStateExpireFromJson(json: string): AuthenticatorStateExpire { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_authenticator_state_expire_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeAuthenticatorStateExpire.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function authenticatorStateExpireToBcs(data: AuthenticatorStateExpire): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeAuthenticatorStateExpire.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_authenticator_state_expire_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function authenticatorStateExpireToJson(data: AuthenticatorStateExpire): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeAuthenticatorStateExpire.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_authenticator_state_expire_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function authenticatorStateUpdateV1FromBcs(bcs: ArrayBuffer): AuthenticatorStateUpdateV1 { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_authenticator_state_update_v1_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeAuthenticatorStateUpdateV1.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function authenticatorStateUpdateV1FromJson(json: string): AuthenticatorStateUpdateV1 { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_authenticator_state_update_v1_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeAuthenticatorStateUpdateV1.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function authenticatorStateUpdateV1ToBcs(data: AuthenticatorStateUpdateV1): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeAuthenticatorStateUpdateV1.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_authenticator_state_update_v1_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function authenticatorStateUpdateV1ToJson(data: AuthenticatorStateUpdateV1): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeAuthenticatorStateUpdateV1.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_authenticator_state_update_v1_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +export function base64Decode(input: string): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(input)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_base64_decode([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +export function base64Encode(input: ArrayBuffer): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let inputArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(input)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_base64_encode([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function bls12381PublicKeyFromBcs(bcs: ArrayBuffer): Bls12381PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_bls12381_public_key_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeBls12381PublicKey.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function bls12381PublicKeyFromJson(json: string): Bls12381PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_bls12381_public_key_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeBls12381PublicKey.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function bls12381PublicKeyToBcs(data: Bls12381PublicKey): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeBls12381PublicKey.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_bls12381_public_key_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function bls12381PublicKeyToJson(data: Bls12381PublicKey): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeBls12381PublicKey.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_bls12381_public_key_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function bls12381SignatureFromBcs(bcs: ArrayBuffer): Bls12381Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_bls12381_signature_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeBls12381Signature.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function bls12381SignatureFromJson(json: string): Bls12381Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_bls12381_signature_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeBls12381Signature.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function bls12381SignatureToBcs(data: Bls12381Signature): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeBls12381Signature.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_bls12381_signature_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function bls12381SignatureToJson(data: Bls12381Signature): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeBls12381Signature.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_bls12381_signature_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function bn254FieldElementFromBcs(bcs: ArrayBuffer): Bn254FieldElement { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_bn254_field_element_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeBn254FieldElement.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function bn254FieldElementFromJson(json: string): Bn254FieldElement { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_bn254_field_element_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeBn254FieldElement.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function bn254FieldElementToBcs(data: Bn254FieldElement): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeBn254FieldElement.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_bn254_field_element_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function bn254FieldElementToJson(data: Bn254FieldElement): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeBn254FieldElement.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_bn254_field_element_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create a bool from BCS encoded bytes. + */ +export function boolFromBcs(input: ArrayBuffer): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(input)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_bool_from_bcs([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + + +/** + * Create a bool from JSON encoded string. + */ +export function boolFromJson(input: string): boolean { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(input)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_bool_from_json([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterBool.lift(returnValue); + } + + + +/** + * Convert this bool to BCS encoded bytes. + */ +export function boolToBcs(input: boolean): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = FfiConverterBool.lower(input); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_bool_to_bcs([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this bool to JSON encoded string. + */ +export function boolToJson(input: boolean): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = FfiConverterBool.lower(input); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_bool_to_json([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function cancelledTransactionFromBcs(bcs: ArrayBuffer): CancelledTransaction { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_cancelled_transaction_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCancelledTransaction.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function cancelledTransactionFromJson(json: string): CancelledTransaction { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_cancelled_transaction_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCancelledTransaction.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function cancelledTransactionToBcs(data: CancelledTransaction): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeCancelledTransaction.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_cancelled_transaction_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function cancelledTransactionToJson(data: CancelledTransaction): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeCancelledTransaction.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_cancelled_transaction_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function changeEpochFromBcs(bcs: ArrayBuffer): ChangeEpoch { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_change_epoch_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeChangeEpoch.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function changeEpochFromJson(json: string): ChangeEpoch { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_change_epoch_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeChangeEpoch.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function changeEpochToBcs(data: ChangeEpoch): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeChangeEpoch.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_change_epoch_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function changeEpochToJson(data: ChangeEpoch): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeChangeEpoch.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_change_epoch_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function changeEpochV2FromBcs(bcs: ArrayBuffer): ChangeEpochV2 { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_change_epoch_v2_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeChangeEpochV2.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function changeEpochV2FromJson(json: string): ChangeEpochV2 { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_change_epoch_v2_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeChangeEpochV2.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function changeEpochV2ToBcs(data: ChangeEpochV2): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeChangeEpochV2.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_change_epoch_v2_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function changeEpochV2ToJson(data: ChangeEpochV2): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeChangeEpochV2.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_change_epoch_v2_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function changedObjectFromBcs(bcs: ArrayBuffer): ChangedObject { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_changed_object_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeChangedObject.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function changedObjectFromJson(json: string): ChangedObject { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_changed_object_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeChangedObject.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function changedObjectToBcs(data: ChangedObject): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeChangedObject.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_changed_object_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function changedObjectToJson(data: ChangedObject): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeChangedObject.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_changed_object_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function checkpointCommitmentFromBcs(bcs: ArrayBuffer): CheckpointCommitment { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_checkpoint_commitment_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCheckpointCommitment.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function checkpointCommitmentFromJson(json: string): CheckpointCommitment { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_checkpoint_commitment_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCheckpointCommitment.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function checkpointCommitmentToBcs(data: CheckpointCommitment): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeCheckpointCommitment.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_checkpoint_commitment_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function checkpointCommitmentToJson(data: CheckpointCommitment): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeCheckpointCommitment.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_checkpoint_commitment_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function checkpointContentsFromBcs(bcs: ArrayBuffer): CheckpointContents { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_checkpoint_contents_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCheckpointContents.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function checkpointContentsFromJson(json: string): CheckpointContents { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_checkpoint_contents_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCheckpointContents.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function checkpointContentsToBcs(data: CheckpointContents): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeCheckpointContents.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_checkpoint_contents_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function checkpointContentsToJson(data: CheckpointContents): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeCheckpointContents.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_checkpoint_contents_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function checkpointSummaryFromBcs(bcs: ArrayBuffer): CheckpointSummary { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_checkpoint_summary_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCheckpointSummary.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function checkpointSummaryFromJson(json: string): CheckpointSummary { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_checkpoint_summary_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCheckpointSummary.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function checkpointSummaryToBcs(data: CheckpointSummary): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeCheckpointSummary.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_checkpoint_summary_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function checkpointSummaryToJson(data: CheckpointSummary): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeCheckpointSummary.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_checkpoint_summary_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function checkpointTransactionInfoFromBcs(bcs: ArrayBuffer): CheckpointTransactionInfo { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_checkpoint_transaction_info_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCheckpointTransactionInfo.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function checkpointTransactionInfoFromJson(json: string): CheckpointTransactionInfo { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_checkpoint_transaction_info_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCheckpointTransactionInfo.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function checkpointTransactionInfoToBcs(data: CheckpointTransactionInfo): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeCheckpointTransactionInfo.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_checkpoint_transaction_info_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function checkpointTransactionInfoToJson(data: CheckpointTransactionInfo): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeCheckpointTransactionInfo.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_checkpoint_transaction_info_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function circomG1FromBcs(bcs: ArrayBuffer): CircomG1 { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_circom_g1_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCircomG1.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function circomG1FromJson(json: string): CircomG1 { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_circom_g1_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCircomG1.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function circomG1ToBcs(data: CircomG1): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeCircomG1.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_circom_g1_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function circomG1ToJson(data: CircomG1): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeCircomG1.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_circom_g1_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function circomG2FromBcs(bcs: ArrayBuffer): CircomG2 { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_circom_g2_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCircomG2.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function circomG2FromJson(json: string): CircomG2 { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_circom_g2_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCircomG2.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function circomG2ToBcs(data: CircomG2): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeCircomG2.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_circom_g2_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function circomG2ToJson(data: CircomG2): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeCircomG2.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_circom_g2_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function commandArgumentErrorFromBcs(bcs: ArrayBuffer): CommandArgumentError { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_command_argument_error_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCommandArgumentError.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function commandArgumentErrorFromJson(json: string): CommandArgumentError { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_command_argument_error_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCommandArgumentError.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function commandArgumentErrorToBcs(data: CommandArgumentError): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeCommandArgumentError.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_command_argument_error_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function commandArgumentErrorToJson(data: CommandArgumentError): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeCommandArgumentError.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_command_argument_error_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function commandFromBcs(bcs: ArrayBuffer): Command { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_command_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCommand.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function commandFromJson(json: string): Command { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_command_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeCommand.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function commandToBcs(data: Command): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeCommand.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_command_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function commandToJson(data: Command): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeCommand.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_command_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function consensusCommitPrologueV1FromBcs(bcs: ArrayBuffer): ConsensusCommitPrologueV1 { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_consensus_commit_prologue_v1_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeConsensusCommitPrologueV1.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function consensusCommitPrologueV1FromJson(json: string): ConsensusCommitPrologueV1 { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_consensus_commit_prologue_v1_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeConsensusCommitPrologueV1.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function consensusCommitPrologueV1ToBcs(data: ConsensusCommitPrologueV1): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeConsensusCommitPrologueV1.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_consensus_commit_prologue_v1_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function consensusCommitPrologueV1ToJson(data: ConsensusCommitPrologueV1): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeConsensusCommitPrologueV1.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_consensus_commit_prologue_v1_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function consensusDeterminedVersionAssignmentsFromBcs(bcs: ArrayBuffer): ConsensusDeterminedVersionAssignments { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_consensus_determined_version_assignments_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeConsensusDeterminedVersionAssignments.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function consensusDeterminedVersionAssignmentsFromJson(json: string): ConsensusDeterminedVersionAssignments { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_consensus_determined_version_assignments_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeConsensusDeterminedVersionAssignments.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function consensusDeterminedVersionAssignmentsToBcs(data: ConsensusDeterminedVersionAssignments): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeConsensusDeterminedVersionAssignments.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_consensus_determined_version_assignments_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function consensusDeterminedVersionAssignmentsToJson(data: ConsensusDeterminedVersionAssignments): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeConsensusDeterminedVersionAssignments.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_consensus_determined_version_assignments_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function digestFromBcs(bcs: ArrayBuffer): Digest { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_digest_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeDigest.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function digestFromJson(json: string): Digest { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_digest_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeDigest.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function digestToBcs(data: Digest): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeDigest.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_digest_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function digestToJson(data: Digest): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeDigest.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_digest_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function ed25519PublicKeyFromBcs(bcs: ArrayBuffer): Ed25519PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_ed25519_public_key_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEd25519PublicKey.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function ed25519PublicKeyFromJson(json: string): Ed25519PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_ed25519_public_key_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEd25519PublicKey.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function ed25519PublicKeyToBcs(data: Ed25519PublicKey): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeEd25519PublicKey.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_ed25519_public_key_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function ed25519PublicKeyToJson(data: Ed25519PublicKey): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeEd25519PublicKey.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_ed25519_public_key_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function ed25519SignatureFromBcs(bcs: ArrayBuffer): Ed25519Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_ed25519_signature_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEd25519Signature.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function ed25519SignatureFromJson(json: string): Ed25519Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_ed25519_signature_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEd25519Signature.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function ed25519SignatureToBcs(data: Ed25519Signature): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeEd25519Signature.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_ed25519_signature_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function ed25519SignatureToJson(data: Ed25519Signature): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeEd25519Signature.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_ed25519_signature_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function endOfEpochDataFromBcs(bcs: ArrayBuffer): EndOfEpochData { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_end_of_epoch_data_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEndOfEpochData.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function endOfEpochDataFromJson(json: string): EndOfEpochData { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_end_of_epoch_data_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEndOfEpochData.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function endOfEpochDataToBcs(data: EndOfEpochData): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeEndOfEpochData.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_end_of_epoch_data_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function endOfEpochDataToJson(data: EndOfEpochData): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeEndOfEpochData.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_end_of_epoch_data_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function eventFromBcs(bcs: ArrayBuffer): Event { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_event_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEvent.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function eventFromJson(json: string): Event { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_event_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeEvent.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function eventToBcs(data: Event): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeEvent.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_event_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function eventToJson(data: Event): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeEvent.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_event_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function executionErrorFromBcs(bcs: ArrayBuffer): ExecutionError { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_execution_error_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeExecutionError.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function executionErrorFromJson(json: string): ExecutionError { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_execution_error_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeExecutionError.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function executionErrorToBcs(data: ExecutionError): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeExecutionError.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_execution_error_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function executionErrorToJson(data: ExecutionError): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeExecutionError.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_execution_error_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function executionStatusFromBcs(bcs: ArrayBuffer): ExecutionStatus { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_execution_status_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeExecutionStatus.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function executionStatusFromJson(json: string): ExecutionStatus { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_execution_status_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeExecutionStatus.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function executionStatusToBcs(data: ExecutionStatus): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeExecutionStatus.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_execution_status_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function executionStatusToJson(data: ExecutionStatus): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeExecutionStatus.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_execution_status_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function executionTimeObservationFromBcs(bcs: ArrayBuffer): ExecutionTimeObservation { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_execution_time_observation_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeExecutionTimeObservation.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function executionTimeObservationFromJson(json: string): ExecutionTimeObservation { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_execution_time_observation_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeExecutionTimeObservation.lift(returnValue); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function executionTimeObservationKeyFromBcs(bcs: ArrayBuffer): ExecutionTimeObservationKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_execution_time_observation_key_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeExecutionTimeObservationKey.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function executionTimeObservationKeyFromJson(json: string): ExecutionTimeObservationKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_execution_time_observation_key_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeExecutionTimeObservationKey.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function executionTimeObservationKeyToBcs(data: ExecutionTimeObservationKey): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeExecutionTimeObservationKey.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_execution_time_observation_key_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function executionTimeObservationKeyToJson(data: ExecutionTimeObservationKey): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeExecutionTimeObservationKey.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_execution_time_observation_key_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function executionTimeObservationToBcs(data: ExecutionTimeObservation): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeExecutionTimeObservation.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_execution_time_observation_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function executionTimeObservationToJson(data: ExecutionTimeObservation): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeExecutionTimeObservation.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_execution_time_observation_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function executionTimeObservationsFromBcs(bcs: ArrayBuffer): ExecutionTimeObservations { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_execution_time_observations_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeExecutionTimeObservations.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function executionTimeObservationsFromJson(json: string): ExecutionTimeObservations { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_execution_time_observations_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeExecutionTimeObservations.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function executionTimeObservationsToBcs(data: ExecutionTimeObservations): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeExecutionTimeObservations.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_execution_time_observations_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function executionTimeObservationsToJson(data: ExecutionTimeObservations): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeExecutionTimeObservations.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_execution_time_observations_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function gasCostSummaryFromBcs(bcs: ArrayBuffer): GasCostSummary { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_gas_cost_summary_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeGasCostSummary.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function gasCostSummaryFromJson(json: string): GasCostSummary { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_gas_cost_summary_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeGasCostSummary.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function gasCostSummaryToBcs(data: GasCostSummary): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeGasCostSummary.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_gas_cost_summary_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function gasCostSummaryToJson(data: GasCostSummary): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeGasCostSummary.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_gas_cost_summary_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function gasPaymentFromBcs(bcs: ArrayBuffer): GasPayment { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_gas_payment_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeGasPayment.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function gasPaymentFromJson(json: string): GasPayment { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_gas_payment_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeGasPayment.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function gasPaymentToBcs(data: GasPayment): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeGasPayment.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_gas_payment_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function gasPaymentToJson(data: GasPayment): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeGasPayment.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_gas_payment_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Generate a new BIP-39 mnemonic in English. + * Supported word counts are 12 and 24 (default). + */ +export function generateMnemonic(wordCount: MnemonicLength | undefined): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let wordCountArg = UniffiRustBufferValue.allocateWithBytes(new FfiConverterOptional(FfiConverterTypeMnemonicLength).lower(wordCount)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_generate_mnemonic([ + wordCountArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function genesisObjectFromBcs(bcs: ArrayBuffer): GenesisObject { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_genesis_object_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeGenesisObject.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function genesisObjectFromJson(json: string): GenesisObject { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_genesis_object_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeGenesisObject.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function genesisObjectToBcs(data: GenesisObject): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeGenesisObject.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_genesis_object_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function genesisObjectToJson(data: GenesisObject): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeGenesisObject.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_genesis_object_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function genesisTransactionFromBcs(bcs: ArrayBuffer): GenesisTransaction { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_genesis_transaction_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeGenesisTransaction.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function genesisTransactionFromJson(json: string): GenesisTransaction { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_genesis_transaction_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeGenesisTransaction.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function genesisTransactionToBcs(data: GenesisTransaction): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeGenesisTransaction.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_genesis_transaction_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function genesisTransactionToJson(data: GenesisTransaction): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeGenesisTransaction.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_genesis_transaction_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +export function hexDecode(input: string): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(input)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_hex_decode([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +export function hexEncode(input: ArrayBuffer): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + let inputArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(input)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_hex_encode([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create a i16 from BCS encoded bytes. + */ +export function i16FromBcs(input: ArrayBuffer): /*i16*/number { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(input)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_i16_from_bcs([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterInt16.lift(returnValue); + } + + + +/** + * Create a i16 from JSON encoded string. + */ +export function i16FromJson(input: string): /*i16*/number { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(input)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_i16_from_json([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterInt16.lift(returnValue); + } + + + +/** + * Convert this i16 to BCS encoded bytes. + */ +export function i16ToBcs(input: /*i16*/number): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = FfiConverterInt16.lower(input); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_i16_to_bcs([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this i16 to JSON encoded string. + */ +export function i16ToJson(input: /*i16*/number): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = FfiConverterInt16.lower(input); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_i16_to_json([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create a i32 from BCS encoded bytes. + */ +export function i32FromBcs(input: ArrayBuffer): /*i32*/number { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(input)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_i32_from_bcs([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterInt32.lift(returnValue); + } + + + +/** + * Create a i32 from JSON encoded string. + */ +export function i32FromJson(input: string): /*i32*/number { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(input)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_i32_from_json([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterInt32.lift(returnValue); + } + + + +/** + * Convert this i32 to BCS encoded bytes. + */ +export function i32ToBcs(input: /*i32*/number): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = FfiConverterInt32.lower(input); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_i32_to_bcs([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this i32 to JSON encoded string. + */ +export function i32ToJson(input: /*i32*/number): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = FfiConverterInt32.lower(input); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_i32_to_json([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create a i64 from BCS encoded bytes. + */ +export function i64FromBcs(input: ArrayBuffer): /*i64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(input)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_i64_from_bcs([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterInt64.lift(returnValue); + } + + + +/** + * Create a i64 from JSON encoded string. + */ +export function i64FromJson(input: string): /*i64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(input)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_i64_from_json([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterInt64.lift(returnValue); + } + + + +/** + * Convert this i64 to BCS encoded bytes. + */ +export function i64ToBcs(input: /*i64*/bigint): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = FfiConverterInt64.lower(input); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_i64_to_bcs([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this i64 to JSON encoded string. + */ +export function i64ToJson(input: /*i64*/bigint): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = FfiConverterInt64.lower(input); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_i64_to_json([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create a i8 from BCS encoded bytes. + */ +export function i8FromBcs(input: ArrayBuffer): /*i8*/number { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(input)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_i8_from_bcs([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterInt8.lift(returnValue); + } + + + +/** + * Create a i8 from JSON encoded string. + */ +export function i8FromJson(input: string): /*i8*/number { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(input)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_i8_from_json([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterInt8.lift(returnValue); + } + + + +/** + * Convert this i8 to BCS encoded bytes. + */ +export function i8ToBcs(input: /*i8*/number): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = FfiConverterInt8.lower(input); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_i8_to_bcs([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this i8 to JSON encoded string. + */ +export function i8ToJson(input: /*i8*/number): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = FfiConverterInt8.lower(input); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_i8_to_json([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function idOperationFromBcs(bcs: ArrayBuffer): IdOperation { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_id_operation_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeIdOperation.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function idOperationFromJson(json: string): IdOperation { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_id_operation_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeIdOperation.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function idOperationToBcs(data: IdOperation): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeIdOperation.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_id_operation_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function idOperationToJson(data: IdOperation): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeIdOperation.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_id_operation_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function identifierFromBcs(bcs: ArrayBuffer): Identifier { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_identifier_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeIdentifier.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function identifierFromJson(json: string): Identifier { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_identifier_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeIdentifier.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function identifierToBcs(data: Identifier): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeIdentifier.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_identifier_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function identifierToJson(data: Identifier): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeIdentifier.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_identifier_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function inputFromBcs(bcs: ArrayBuffer): Input { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_input_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeInput.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function inputFromJson(json: string): Input { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_input_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeInput.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function inputToBcs(data: Input): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeInput.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_input_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function inputToJson(data: Input): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeInput.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_input_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function jwkFromBcs(bcs: ArrayBuffer): Jwk { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_jwk_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeJwk.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function jwkFromJson(json: string): Jwk { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_jwk_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeJwk.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function jwkIdFromBcs(bcs: ArrayBuffer): JwkId { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_jwk_id_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeJwkId.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function jwkIdFromJson(json: string): JwkId { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_jwk_id_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeJwkId.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function jwkIdToBcs(data: JwkId): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeJwkId.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_jwk_id_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function jwkIdToJson(data: JwkId): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeJwkId.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_jwk_id_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function jwkToBcs(data: Jwk): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeJwk.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_jwk_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function jwkToJson(data: Jwk): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeJwk.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_jwk_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function makeMoveVectorFromBcs(bcs: ArrayBuffer): MakeMoveVector { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_make_move_vector_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMakeMoveVector.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function makeMoveVectorFromJson(json: string): MakeMoveVector { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_make_move_vector_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMakeMoveVector.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function makeMoveVectorToBcs(data: MakeMoveVector): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeMakeMoveVector.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_make_move_vector_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function makeMoveVectorToJson(data: MakeMoveVector): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeMakeMoveVector.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_make_move_vector_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function mergeCoinsFromBcs(bcs: ArrayBuffer): MergeCoins { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_merge_coins_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMergeCoins.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function mergeCoinsFromJson(json: string): MergeCoins { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_merge_coins_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMergeCoins.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function mergeCoinsToBcs(data: MergeCoins): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeMergeCoins.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_merge_coins_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function mergeCoinsToJson(data: MergeCoins): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeMergeCoins.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_merge_coins_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function moveCallFromBcs(bcs: ArrayBuffer): MoveCall { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_move_call_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveCall.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function moveCallFromJson(json: string): MoveCall { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_move_call_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveCall.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function moveCallToBcs(data: MoveCall): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeMoveCall.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_move_call_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function moveCallToJson(data: MoveCall): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeMoveCall.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_move_call_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function moveLocationFromBcs(bcs: ArrayBuffer): MoveLocation { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_move_location_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveLocation.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function moveLocationFromJson(json: string): MoveLocation { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_move_location_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveLocation.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function moveLocationToBcs(data: MoveLocation): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeMoveLocation.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_move_location_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function moveLocationToJson(data: MoveLocation): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeMoveLocation.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_move_location_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function movePackageFromBcs(bcs: ArrayBuffer): MovePackage { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_move_package_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMovePackage.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function movePackageFromJson(json: string): MovePackage { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_move_package_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMovePackage.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function movePackageToBcs(data: MovePackage): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeMovePackage.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_move_package_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function movePackageToJson(data: MovePackage): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeMovePackage.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_move_package_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function moveStructFromBcs(bcs: ArrayBuffer): MoveStruct { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_move_struct_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveStruct.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function moveStructFromJson(json: string): MoveStruct { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_move_struct_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMoveStruct.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function moveStructToBcs(data: MoveStruct): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeMoveStruct.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_move_struct_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function moveStructToJson(data: MoveStruct): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeMoveStruct.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_move_struct_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function multisigAggregatedSignatureFromBcs(bcs: ArrayBuffer): MultisigAggregatedSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_multisig_aggregated_signature_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMultisigAggregatedSignature.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function multisigAggregatedSignatureFromJson(json: string): MultisigAggregatedSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_multisig_aggregated_signature_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMultisigAggregatedSignature.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function multisigAggregatedSignatureToBcs(data: MultisigAggregatedSignature): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeMultisigAggregatedSignature.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_multisig_aggregated_signature_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function multisigAggregatedSignatureToJson(data: MultisigAggregatedSignature): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeMultisigAggregatedSignature.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_multisig_aggregated_signature_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function multisigCommitteeFromBcs(bcs: ArrayBuffer): MultisigCommittee { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_multisig_committee_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMultisigCommittee.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function multisigCommitteeFromJson(json: string): MultisigCommittee { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_multisig_committee_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMultisigCommittee.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function multisigCommitteeToBcs(data: MultisigCommittee): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeMultisigCommittee.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_multisig_committee_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function multisigCommitteeToJson(data: MultisigCommittee): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeMultisigCommittee.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_multisig_committee_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function multisigMemberFromBcs(bcs: ArrayBuffer): MultisigMember { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_multisig_member_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMultisigMember.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function multisigMemberFromJson(json: string): MultisigMember { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_multisig_member_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMultisigMember.lift(returnValue); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function multisigMemberPublicKeyFromBcs(bcs: ArrayBuffer): MultisigMemberPublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_multisig_member_public_key_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMultisigMemberPublicKey.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function multisigMemberPublicKeyFromJson(json: string): MultisigMemberPublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_multisig_member_public_key_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMultisigMemberPublicKey.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function multisigMemberPublicKeyToBcs(data: MultisigMemberPublicKey): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeMultisigMemberPublicKey.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_multisig_member_public_key_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function multisigMemberPublicKeyToJson(data: MultisigMemberPublicKey): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeMultisigMemberPublicKey.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_multisig_member_public_key_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function multisigMemberSignatureFromBcs(bcs: ArrayBuffer): MultisigMemberSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_multisig_member_signature_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMultisigMemberSignature.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function multisigMemberSignatureFromJson(json: string): MultisigMemberSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_multisig_member_signature_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeMultisigMemberSignature.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function multisigMemberSignatureToBcs(data: MultisigMemberSignature): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeMultisigMemberSignature.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_multisig_member_signature_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function multisigMemberSignatureToJson(data: MultisigMemberSignature): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeMultisigMemberSignature.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_multisig_member_signature_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function multisigMemberToBcs(data: MultisigMember): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeMultisigMember.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_multisig_member_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function multisigMemberToJson(data: MultisigMember): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeMultisigMember.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_multisig_member_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function objectDataFromBcs(bcs: ArrayBuffer): ObjectData { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_object_data_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectData.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function objectDataFromJson(json: string): ObjectData { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_object_data_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectData.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function objectDataToBcs(data: ObjectData): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeObjectData.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_object_data_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function objectDataToJson(data: ObjectData): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeObjectData.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_object_data_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function objectFromBcs(bcs: ArrayBuffer): Object_ { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_object_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObject.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function objectFromJson(json: string): Object_ { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_object_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObject.lift(returnValue); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function objectIdFromBcs(bcs: ArrayBuffer): ObjectId { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_object_id_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectId.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function objectIdFromJson(json: string): ObjectId { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_object_id_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectId.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function objectIdToBcs(data: ObjectId): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeObjectId.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_object_id_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function objectIdToJson(data: ObjectId): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeObjectId.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_object_id_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function objectInFromBcs(bcs: ArrayBuffer): ObjectIn { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_object_in_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectIn.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function objectInFromJson(json: string): ObjectIn { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_object_in_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectIn.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function objectInToBcs(data: ObjectIn): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeObjectIn.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_object_in_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function objectInToJson(data: ObjectIn): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeObjectIn.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_object_in_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function objectOutFromBcs(bcs: ArrayBuffer): ObjectOut { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_object_out_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectOut.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function objectOutFromJson(json: string): ObjectOut { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_object_out_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectOut.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function objectOutToBcs(data: ObjectOut): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeObjectOut.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_object_out_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function objectOutToJson(data: ObjectOut): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeObjectOut.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_object_out_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function objectReferenceFromBcs(bcs: ArrayBuffer): ObjectReference { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_object_reference_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectReference.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function objectReferenceFromJson(json: string): ObjectReference { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_object_reference_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeObjectReference.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function objectReferenceToBcs(data: ObjectReference): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeObjectReference.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_object_reference_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function objectReferenceToJson(data: ObjectReference): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeObjectReference.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_object_reference_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function objectToBcs(data: Object_): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeObject.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_object_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function objectToJson(data: Object_): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeObject.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_object_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function ownerFromBcs(bcs: ArrayBuffer): Owner { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_owner_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeOwner.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function ownerFromJson(json: string): Owner { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_owner_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeOwner.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function ownerToBcs(data: Owner): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeOwner.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_owner_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function ownerToJson(data: Owner): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeOwner.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_owner_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function packageUpgradeErrorFromBcs(bcs: ArrayBuffer): PackageUpgradeError { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_package_upgrade_error_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePackageUpgradeError.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function packageUpgradeErrorFromJson(json: string): PackageUpgradeError { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_package_upgrade_error_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePackageUpgradeError.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function packageUpgradeErrorToBcs(data: PackageUpgradeError): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypePackageUpgradeError.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_package_upgrade_error_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function packageUpgradeErrorToJson(data: PackageUpgradeError): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypePackageUpgradeError.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_package_upgrade_error_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function passkeyAuthenticatorFromBcs(bcs: ArrayBuffer): PasskeyAuthenticator { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_passkey_authenticator_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePasskeyAuthenticator.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function passkeyAuthenticatorFromJson(json: string): PasskeyAuthenticator { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_passkey_authenticator_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePasskeyAuthenticator.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function passkeyAuthenticatorToBcs(data: PasskeyAuthenticator): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypePasskeyAuthenticator.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_passkey_authenticator_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function passkeyAuthenticatorToJson(data: PasskeyAuthenticator): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypePasskeyAuthenticator.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_passkey_authenticator_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function programmableTransactionFromBcs(bcs: ArrayBuffer): ProgrammableTransaction { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_programmable_transaction_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeProgrammableTransaction.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function programmableTransactionFromJson(json: string): ProgrammableTransaction { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_programmable_transaction_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeProgrammableTransaction.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function programmableTransactionToBcs(data: ProgrammableTransaction): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeProgrammableTransaction.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_programmable_transaction_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function programmableTransactionToJson(data: ProgrammableTransaction): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeProgrammableTransaction.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_programmable_transaction_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function publishFromBcs(bcs: ArrayBuffer): Publish { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_publish_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePublish.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function publishFromJson(json: string): Publish { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_publish_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypePublish.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function publishToBcs(data: Publish): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypePublish.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_publish_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function publishToJson(data: Publish): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypePublish.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_publish_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function randomnessStateUpdateFromBcs(bcs: ArrayBuffer): RandomnessStateUpdate { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_randomness_state_update_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeRandomnessStateUpdate.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function randomnessStateUpdateFromJson(json: string): RandomnessStateUpdate { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_randomness_state_update_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeRandomnessStateUpdate.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function randomnessStateUpdateToBcs(data: RandomnessStateUpdate): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeRandomnessStateUpdate.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_randomness_state_update_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function randomnessStateUpdateToJson(data: RandomnessStateUpdate): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeRandomnessStateUpdate.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_randomness_state_update_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function secp256k1PublicKeyFromBcs(bcs: ArrayBuffer): Secp256k1PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_secp256k1_public_key_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256k1PublicKey.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function secp256k1PublicKeyFromJson(json: string): Secp256k1PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_secp256k1_public_key_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256k1PublicKey.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function secp256k1PublicKeyToBcs(data: Secp256k1PublicKey): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeSecp256k1PublicKey.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_secp256k1_public_key_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function secp256k1PublicKeyToJson(data: Secp256k1PublicKey): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeSecp256k1PublicKey.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_secp256k1_public_key_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function secp256k1SignatureFromBcs(bcs: ArrayBuffer): Secp256k1Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_secp256k1_signature_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256k1Signature.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function secp256k1SignatureFromJson(json: string): Secp256k1Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_secp256k1_signature_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256k1Signature.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function secp256k1SignatureToBcs(data: Secp256k1Signature): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeSecp256k1Signature.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_secp256k1_signature_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function secp256k1SignatureToJson(data: Secp256k1Signature): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeSecp256k1Signature.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_secp256k1_signature_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function secp256r1PublicKeyFromBcs(bcs: ArrayBuffer): Secp256r1PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_secp256r1_public_key_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1PublicKey.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function secp256r1PublicKeyFromJson(json: string): Secp256r1PublicKey { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_secp256r1_public_key_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1PublicKey.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function secp256r1PublicKeyToBcs(data: Secp256r1PublicKey): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeSecp256r1PublicKey.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_secp256r1_public_key_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function secp256r1PublicKeyToJson(data: Secp256r1PublicKey): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeSecp256r1PublicKey.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_secp256r1_public_key_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function secp256r1SignatureFromBcs(bcs: ArrayBuffer): Secp256r1Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_secp256r1_signature_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1Signature.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function secp256r1SignatureFromJson(json: string): Secp256r1Signature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_secp256r1_signature_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSecp256r1Signature.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function secp256r1SignatureToBcs(data: Secp256r1Signature): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeSecp256r1Signature.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_secp256r1_signature_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function secp256r1SignatureToJson(data: Secp256r1Signature): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeSecp256r1Signature.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_secp256r1_signature_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function signedTransactionFromBcs(bcs: ArrayBuffer): SignedTransaction { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_signed_transaction_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSignedTransaction.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function signedTransactionFromJson(json: string): SignedTransaction { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_signed_transaction_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSignedTransaction.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function signedTransactionToBcs(data: SignedTransaction): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeSignedTransaction.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_signed_transaction_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function signedTransactionToJson(data: SignedTransaction): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeSignedTransaction.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_signed_transaction_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function simpleSignatureFromBcs(bcs: ArrayBuffer): SimpleSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_simple_signature_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSimpleSignature.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function simpleSignatureFromJson(json: string): SimpleSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_simple_signature_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSimpleSignature.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function simpleSignatureToBcs(data: SimpleSignature): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeSimpleSignature.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_simple_signature_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function simpleSignatureToJson(data: SimpleSignature): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeSimpleSignature.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_simple_signature_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function splitCoinsFromBcs(bcs: ArrayBuffer): SplitCoins { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_split_coins_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSplitCoins.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function splitCoinsFromJson(json: string): SplitCoins { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_split_coins_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSplitCoins.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function splitCoinsToBcs(data: SplitCoins): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeSplitCoins.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_split_coins_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function splitCoinsToJson(data: SplitCoins): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeSplitCoins.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_split_coins_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create a String from BCS encoded bytes. + */ +export function stringFromBcs(input: ArrayBuffer): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(input)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_string_from_bcs([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create a String from JSON encoded string. + */ +export function stringFromJson(input: string): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(input)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_string_from_json([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this String to BCS encoded bytes. + */ +export function stringToBcs(input: string): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(input)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_string_to_bcs([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this String to JSON encoded string. + */ +export function stringToJson(input: string): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(input)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_string_to_json([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function structTagFromBcs(bcs: ArrayBuffer): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_struct_tag_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function structTagFromJson(json: string): StructTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_struct_tag_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeStructTag.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function structTagToBcs(data: StructTag): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeStructTag.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_struct_tag_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function structTagToJson(data: StructTag): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeStructTag.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_struct_tag_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function systemPackageFromBcs(bcs: ArrayBuffer): SystemPackage { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_system_package_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSystemPackage.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function systemPackageFromJson(json: string): SystemPackage { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_system_package_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeSystemPackage.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function systemPackageToBcs(data: SystemPackage): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeSystemPackage.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_system_package_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function systemPackageToJson(data: SystemPackage): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeSystemPackage.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_system_package_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function transactionEffectsFromBcs(bcs: ArrayBuffer): TransactionEffects { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_effects_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionEffects.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function transactionEffectsFromJson(json: string): TransactionEffects { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_effects_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionEffects.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function transactionEffectsToBcs(data: TransactionEffects): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeTransactionEffects.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_effects_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function transactionEffectsToJson(data: TransactionEffects): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeTransactionEffects.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_effects_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function transactionEffectsV1FromBcs(bcs: ArrayBuffer): TransactionEffectsV1 { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_effects_v1_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionEffectsV1.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function transactionEffectsV1FromJson(json: string): TransactionEffectsV1 { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_effects_v1_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionEffectsV1.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function transactionEffectsV1ToBcs(data: TransactionEffectsV1): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeTransactionEffectsV1.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_effects_v1_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function transactionEffectsV1ToJson(data: TransactionEffectsV1): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeTransactionEffectsV1.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_effects_v1_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function transactionEventsFromBcs(bcs: ArrayBuffer): TransactionEvents { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_events_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionEvents.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function transactionEventsFromJson(json: string): TransactionEvents { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_events_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionEvents.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function transactionEventsToBcs(data: TransactionEvents): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeTransactionEvents.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_events_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function transactionEventsToJson(data: TransactionEvents): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeTransactionEvents.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_events_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function transactionExpirationFromBcs(bcs: ArrayBuffer): TransactionExpiration { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_expiration_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionExpiration.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function transactionExpirationFromJson(json: string): TransactionExpiration { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_expiration_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionExpiration.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function transactionExpirationToBcs(data: TransactionExpiration): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeTransactionExpiration.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_expiration_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function transactionExpirationToJson(data: TransactionExpiration): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeTransactionExpiration.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_expiration_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function transactionFromBcs(bcs: ArrayBuffer): Transaction { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransaction.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function transactionFromJson(json: string): Transaction { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransaction.lift(returnValue); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function transactionKindFromBcs(bcs: ArrayBuffer): TransactionKind { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_kind_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionKind.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function transactionKindFromJson(json: string): TransactionKind { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_kind_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionKind.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function transactionKindToBcs(data: TransactionKind): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeTransactionKind.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_kind_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function transactionKindToJson(data: TransactionKind): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeTransactionKind.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_kind_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function transactionToBcs(data: Transaction): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeTransaction.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function transactionToJson(data: Transaction): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeTransaction.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function transactionV1FromBcs(bcs: ArrayBuffer): TransactionV1 { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_v1_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionV1.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function transactionV1FromJson(json: string): TransactionV1 { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_v1_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransactionV1.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function transactionV1ToBcs(data: TransactionV1): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeTransactionV1.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_v1_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function transactionV1ToJson(data: TransactionV1): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeTransactionV1.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transaction_v1_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function transferObjectsFromBcs(bcs: ArrayBuffer): TransferObjects { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transfer_objects_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransferObjects.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function transferObjectsFromJson(json: string): TransferObjects { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transfer_objects_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTransferObjects.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function transferObjectsToBcs(data: TransferObjects): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeTransferObjects.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transfer_objects_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function transferObjectsToJson(data: TransferObjects): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeTransferObjects.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_transfer_objects_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function typeArgumentErrorFromBcs(bcs: ArrayBuffer): TypeArgumentError { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_type_argument_error_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTypeArgumentError.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function typeArgumentErrorFromJson(json: string): TypeArgumentError { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_type_argument_error_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTypeArgumentError.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function typeArgumentErrorToBcs(data: TypeArgumentError): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeTypeArgumentError.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_type_argument_error_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function typeArgumentErrorToJson(data: TypeArgumentError): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeTypeArgumentError.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_type_argument_error_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function typeOriginFromBcs(bcs: ArrayBuffer): TypeOrigin { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_type_origin_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTypeOrigin.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function typeOriginFromJson(json: string): TypeOrigin { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_type_origin_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTypeOrigin.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function typeOriginToBcs(data: TypeOrigin): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeTypeOrigin.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_type_origin_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function typeOriginToJson(data: TypeOrigin): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeTypeOrigin.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_type_origin_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function typeTagFromBcs(bcs: ArrayBuffer): TypeTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_type_tag_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTypeTag.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function typeTagFromJson(json: string): TypeTag { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_type_tag_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeTypeTag.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function typeTagToBcs(data: TypeTag): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeTypeTag.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_type_tag_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function typeTagToJson(data: TypeTag): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeTypeTag.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_type_tag_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create a u16 from BCS encoded bytes. + */ +export function u16FromBcs(input: ArrayBuffer): /*u16*/number { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(input)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_u16_from_bcs([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt16.lift(returnValue); + } + + + +/** + * Create a u16 from JSON encoded string. + */ +export function u16FromJson(input: string): /*u16*/number { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(input)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_u16_from_json([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt16.lift(returnValue); + } + + + +/** + * Convert this u16 to BCS encoded bytes. + */ +export function u16ToBcs(input: /*u16*/number): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = FfiConverterUInt16.lower(input); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_u16_to_bcs([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this u16 to JSON encoded string. + */ +export function u16ToJson(input: /*u16*/number): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = FfiConverterUInt16.lower(input); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_u16_to_json([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create a u32 from BCS encoded bytes. + */ +export function u32FromBcs(input: ArrayBuffer): /*u32*/number { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(input)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_u32_from_bcs([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt32.lift(returnValue); + } + + + +/** + * Create a u32 from JSON encoded string. + */ +export function u32FromJson(input: string): /*u32*/number { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(input)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_u32_from_json([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt32.lift(returnValue); + } + + + +/** + * Convert this u32 to BCS encoded bytes. + */ +export function u32ToBcs(input: /*u32*/number): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = FfiConverterUInt32.lower(input); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_u32_to_bcs([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this u32 to JSON encoded string. + */ +export function u32ToJson(input: /*u32*/number): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = FfiConverterUInt32.lower(input); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_u32_to_json([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create a u64 from BCS encoded bytes. + */ +export function u64FromBcs(input: ArrayBuffer): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(input)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_u64_from_bcs([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + + +/** + * Create a u64 from JSON encoded string. + */ +export function u64FromJson(input: string): /*u64*/bigint { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(input)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_u64_from_json([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt64.lift(returnValue); + } + + + +/** + * Convert this u64 to BCS encoded bytes. + */ +export function u64ToBcs(input: /*u64*/bigint): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = FfiConverterUInt64.lower(input); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_u64_to_bcs([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this u64 to JSON encoded string. + */ +export function u64ToJson(input: /*u64*/bigint): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = FfiConverterUInt64.lower(input); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_u64_to_json([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create a u8 from BCS encoded bytes. + */ +export function u8FromBcs(input: ArrayBuffer): /*u8*/number { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(input)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_u8_from_bcs([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt8.lift(returnValue); + } + + + +/** + * Create a u8 from JSON encoded string. + */ +export function u8FromJson(input: string): /*u8*/number { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(input)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_u8_from_json([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterUInt8.lift(returnValue); + } + + + +/** + * Convert this u8 to BCS encoded bytes. + */ +export function u8ToBcs(input: /*u8*/number): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = FfiConverterUInt8.lower(input); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_u8_to_bcs([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this u8 to JSON encoded string. + */ +export function u8ToJson(input: /*u8*/number): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let inputArg = FfiConverterUInt8.lower(input); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_u8_to_json([ + inputArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function unchangedSharedKindFromBcs(bcs: ArrayBuffer): UnchangedSharedKind { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_unchanged_shared_kind_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUnchangedSharedKind.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function unchangedSharedKindFromJson(json: string): UnchangedSharedKind { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_unchanged_shared_kind_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUnchangedSharedKind.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function unchangedSharedKindToBcs(data: UnchangedSharedKind): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeUnchangedSharedKind.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_unchanged_shared_kind_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function unchangedSharedKindToJson(data: UnchangedSharedKind): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeUnchangedSharedKind.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_unchanged_shared_kind_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function unchangedSharedObjectFromBcs(bcs: ArrayBuffer): UnchangedSharedObject { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_unchanged_shared_object_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUnchangedSharedObject.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function unchangedSharedObjectFromJson(json: string): UnchangedSharedObject { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_unchanged_shared_object_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUnchangedSharedObject.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function unchangedSharedObjectToBcs(data: UnchangedSharedObject): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeUnchangedSharedObject.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_unchanged_shared_object_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function unchangedSharedObjectToJson(data: UnchangedSharedObject): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeUnchangedSharedObject.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_unchanged_shared_object_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function upgradeFromBcs(bcs: ArrayBuffer): Upgrade { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_upgrade_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUpgrade.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function upgradeFromJson(json: string): Upgrade { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_upgrade_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUpgrade.lift(returnValue); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function upgradeInfoFromBcs(bcs: ArrayBuffer): UpgradeInfo { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_upgrade_info_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUpgradeInfo.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function upgradeInfoFromJson(json: string): UpgradeInfo { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_upgrade_info_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUpgradeInfo.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function upgradeInfoToBcs(data: UpgradeInfo): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeUpgradeInfo.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_upgrade_info_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function upgradeInfoToJson(data: UpgradeInfo): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeUpgradeInfo.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_upgrade_info_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function upgradeToBcs(data: Upgrade): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeUpgrade.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_upgrade_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function upgradeToJson(data: Upgrade): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeUpgrade.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_upgrade_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function userSignatureFromBcs(bcs: ArrayBuffer): UserSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_user_signature_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUserSignature.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function userSignatureFromJson(json: string): UserSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_user_signature_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeUserSignature.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function userSignatureToBcs(data: UserSignature): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeUserSignature.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_user_signature_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function userSignatureToJson(data: UserSignature): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeUserSignature.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_user_signature_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function validatorAggregatedSignatureFromBcs(bcs: ArrayBuffer): ValidatorAggregatedSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_validator_aggregated_signature_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeValidatorAggregatedSignature.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function validatorAggregatedSignatureFromJson(json: string): ValidatorAggregatedSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_validator_aggregated_signature_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeValidatorAggregatedSignature.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function validatorAggregatedSignatureToBcs(data: ValidatorAggregatedSignature): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeValidatorAggregatedSignature.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_validator_aggregated_signature_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function validatorAggregatedSignatureToJson(data: ValidatorAggregatedSignature): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeValidatorAggregatedSignature.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_validator_aggregated_signature_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function validatorCommitteeFromBcs(bcs: ArrayBuffer): ValidatorCommittee { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_validator_committee_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeValidatorCommittee.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function validatorCommitteeFromJson(json: string): ValidatorCommittee { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_validator_committee_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeValidatorCommittee.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function validatorCommitteeMemberFromBcs(bcs: ArrayBuffer): ValidatorCommitteeMember { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_validator_committee_member_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeValidatorCommitteeMember.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function validatorCommitteeMemberFromJson(json: string): ValidatorCommitteeMember { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_validator_committee_member_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeValidatorCommitteeMember.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function validatorCommitteeMemberToBcs(data: ValidatorCommitteeMember): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeValidatorCommitteeMember.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_validator_committee_member_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function validatorCommitteeMemberToJson(data: ValidatorCommitteeMember): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeValidatorCommitteeMember.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_validator_committee_member_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function validatorCommitteeToBcs(data: ValidatorCommittee): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeValidatorCommittee.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_validator_committee_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function validatorCommitteeToJson(data: ValidatorCommittee): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeValidatorCommittee.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_validator_committee_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function validatorExecutionTimeObservationFromBcs(bcs: ArrayBuffer): ValidatorExecutionTimeObservation { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_validator_execution_time_observation_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeValidatorExecutionTimeObservation.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function validatorExecutionTimeObservationFromJson(json: string): ValidatorExecutionTimeObservation { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_validator_execution_time_observation_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeValidatorExecutionTimeObservation.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function validatorExecutionTimeObservationToBcs(data: ValidatorExecutionTimeObservation): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeValidatorExecutionTimeObservation.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_validator_execution_time_observation_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function validatorExecutionTimeObservationToJson(data: ValidatorExecutionTimeObservation): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeValidatorExecutionTimeObservation.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_validator_execution_time_observation_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function validatorSignatureFromBcs(bcs: ArrayBuffer): ValidatorSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_validator_signature_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeValidatorSignature.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function validatorSignatureFromJson(json: string): ValidatorSignature { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_validator_signature_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeValidatorSignature.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function validatorSignatureToBcs(data: ValidatorSignature): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeValidatorSignature.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_validator_signature_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function validatorSignatureToJson(data: ValidatorSignature): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeValidatorSignature.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_validator_signature_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function versionAssignmentFromBcs(bcs: ArrayBuffer): VersionAssignment { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_version_assignment_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeVersionAssignment.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function versionAssignmentFromJson(json: string): VersionAssignment { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_version_assignment_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeVersionAssignment.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function versionAssignmentToBcs(data: VersionAssignment): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeVersionAssignment.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_version_assignment_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function versionAssignmentToJson(data: VersionAssignment): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeVersionAssignment.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_version_assignment_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function zkLoginAuthenticatorFromBcs(bcs: ArrayBuffer): ZkLoginAuthenticator { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_zk_login_authenticator_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeZkLoginAuthenticator.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function zkLoginAuthenticatorFromJson(json: string): ZkLoginAuthenticator { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_zk_login_authenticator_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeZkLoginAuthenticator.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function zkLoginAuthenticatorToBcs(data: ZkLoginAuthenticator): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeZkLoginAuthenticator.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_zk_login_authenticator_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function zkLoginAuthenticatorToJson(data: ZkLoginAuthenticator): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeZkLoginAuthenticator.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_zk_login_authenticator_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function zkLoginClaimFromBcs(bcs: ArrayBuffer): ZkLoginClaim { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_zk_login_claim_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeZkLoginClaim.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function zkLoginClaimFromJson(json: string): ZkLoginClaim { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_zk_login_claim_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeZkLoginClaim.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function zkLoginClaimToBcs(data: ZkLoginClaim): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeZkLoginClaim.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_zk_login_claim_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function zkLoginClaimToJson(data: ZkLoginClaim): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterTypeZkLoginClaim.lower(data)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_zk_login_claim_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function zkLoginProofFromBcs(bcs: ArrayBuffer): ZkLoginProof { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_zk_login_proof_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeZkLoginProof.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function zkLoginProofFromJson(json: string): ZkLoginProof { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_zk_login_proof_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeZkLoginProof.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function zkLoginProofToBcs(data: ZkLoginProof): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeZkLoginProof.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_zk_login_proof_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function zkLoginProofToJson(data: ZkLoginProof): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeZkLoginProof.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_zk_login_proof_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Create this type from BCS encoded bytes. + */ +export function zkLoginPublicIdentifierFromBcs(bcs: ArrayBuffer): ZkLoginPublicIdentifier { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let bcsArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterArrayBuffer.lower(bcs)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_zk_login_public_identifier_from_bcs([ + bcsArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeZkLoginPublicIdentifier.lift(returnValue); + } + + + +/** + * Create this type from JSON encoded string. + */ +export function zkLoginPublicIdentifierFromJson(json: string): ZkLoginPublicIdentifier { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let jsonArg = UniffiRustBufferValue.allocateWithBytes(FfiConverterString.lower(json)).toStruct(); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_zk_login_public_identifier_from_json([ + jsonArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterTypeZkLoginPublicIdentifier.lift(returnValue); + } + + + +/** + * Convert this type to BCS encoded bytes. + */ +export function zkLoginPublicIdentifierToBcs(data: ZkLoginPublicIdentifier): ArrayBuffer { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeZkLoginPublicIdentifier.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_zk_login_public_identifier_to_bcs([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterArrayBuffer.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + + + +/** + * Convert this type to JSON encoded string. + */ +export function zkLoginPublicIdentifierToJson(data: ZkLoginPublicIdentifier): string { + /* Regular function call: */ + const returnValue = uniffiCaller.rustCallWithError( + /*liftError:*/ (buffer) => ["SdkFfiError", FfiConverterTypeSdkFfiError.lift(buffer)], + /*caller:*/ (callStatus) => { + let dataArg = FfiConverterTypeZkLoginPublicIdentifier.lower(data); + + const returnValue = FFI_DYNAMIC_LIB.uniffi_iota_sdk_ffi_fn_func_zk_login_public_identifier_to_json([ + dataArg, callStatus + ]); + + + return returnValue; + }, + /*liftString:*/ FfiConverterString.lift + ); + + return FfiConverterString.lift(new UniffiRustBufferValue(returnValue).consumeIntoUint8Array()); + } + diff --git a/bindings/typescript/lib/iota-sdk-ffi-sys.ts b/bindings/typescript/lib/iota-sdk-ffi-sys.ts new file mode 100644 index 0000000000..5bc25126e6 --- /dev/null +++ b/bindings/typescript/lib/iota-sdk-ffi-sys.ts @@ -0,0 +1,32352 @@ +import { join, dirname } from "path"; + + +import { + DataType, + JsExternal, + open, + close, + define, + arrayConstructor, + restorePointer, + wrapPointer, + unwrapPointer, + createPointer, + freePointer, + isNullPointer, + PointerType, +} from 'ffi-rs'; +import { + type UniffiByteArray, + UniffiInternalError, + uniffiCreateFfiConverterString, + UniffiError, +} from 'uniffi-bindgen-react-native'; + + +const CALL_SUCCESS = 0, CALL_ERROR = 1, CALL_UNEXPECTED_ERROR = 2, CALL_CANCELLED = 3; + + +let libraryLoaded = false; +/** + * Loads the dynamic library from disk into memory. + * + */ +function _uniffiLoad() { + const library = "libiota_sdk_ffi"; + const { platform } = process; + let ext = { darwin: "dylib", win32: "dll", linux: "so" }[platform as string]; + if (!ext) { + console.warn("Unsupported platform:", platform); + ext = "so"; + } + + const filePath = __filename; + const libraryDirectory = __dirname; + + // Get the path to the lib to load + const libraryPath = join(libraryDirectory, `${library}.${ext}`); + + + + open({ library, path: libraryPath }); + libraryLoaded = true; +} + +/** + * Unloads the dynamic library from disk from memory. This can be used to clean up the library early + * before program execution completes. + */ +function _uniffiUnload() { + close('libiota_sdk_ffi'); + libraryLoaded = false; +} + +function _checkUniffiLoaded() { + if (!libraryLoaded) { + throw new Error('Uniffi function call was issued, but the native dependency was not loaded. Ensure you are calling uniffiLoad() before interacting with any uniffi backed functionality.'); + } +} + + +_uniffiLoad(); + + +// Release library memory before process terminates +// TODO: is this even really required? +process.on('beforeExit', () => { + if (libraryLoaded) { + _uniffiUnload(); + } +}); + + +const [nullPointer] = unwrapPointer(createPointer({ + paramsType: [DataType.Void], + paramsValue: [undefined] +})); + +class UniffiFfiRsRustCaller { + rustCall( + caller: (status: JsExternal) => T, + liftString: (bytes: UniffiByteArray) => string, + ): T { + return this.makeRustCall(caller, liftString); + } + + rustCallWithError( + liftError: (buffer: UniffiByteArray) => ErrorEnumAndVariant, + caller: (status: JsExternal) => T, + liftString: (bytes: UniffiByteArray) => string, + ): T { + return this.makeRustCall(caller, liftString, liftError); + } + + createCallStatus(): [JsExternal] { + const $callStatus = createPointer({ + paramsType: [DataType_UniffiRustCallStatus], + paramsValue: [{ + code: CALL_SUCCESS, + error_buf: { capacity: 0, len: 0, data: nullPointer }, + }], + }); + + return $callStatus as [JsExternal]; + } + + createErrorStatus(_code: number, _errorBuf: UniffiByteArray): JsExternal { + // FIXME: what is this supposed to do and how does it not allocate `errorBuf` when making the + // call status struct? + throw new Error('UniffiRustCaller.createErrorStatus is unimplemented.'); + + // const status = this.statusConstructor(); + // status.code = code; + // status.errorBuf = errorBuf; + // return status; + } + + makeRustCall( + caller: (status: JsExternal) => T, + liftString: (bytes: UniffiByteArray) => string, + liftError?: (buffer: UniffiByteArray) => ErrorEnumAndVariant, + ): T { + _checkUniffiLoaded(); + + const $callStatus = this.createCallStatus(); + let returnedVal = caller(unwrapPointer($callStatus)[0]); + + const [callStatus] = restorePointer({ + retType: [DataType_UniffiRustCallStatus], + paramsValue: $callStatus, + }); + uniffiCheckCallStatus(callStatus, liftString, liftError); + + return returnedVal; + } +} + +function uniffiCheckCallStatus( + callStatus: UniffiRustCallStatusStruct, + liftString: (bytes: UniffiByteArray) => string, + liftError?: (buffer: UniffiByteArray) => ErrorEnumAndVariant, +) { + switch (callStatus.code) { + case CALL_SUCCESS: + return; + + case CALL_ERROR: { + // - Rust will not set the data pointer for a sucessful return. + // - If unsuccesful, lift the error from the RustBuf and free. + if (!isNullPointer(callStatus.error_buf.data)) { + const struct = new UniffiRustBufferValue(callStatus.error_buf); + const errorBufBytes = struct.consumeIntoUint8Array(); + + if (liftError) { + const [enumName, errorVariant] = liftError(errorBufBytes); + throw new UniffiError(enumName, errorVariant); + } + } + throw new UniffiInternalError.UnexpectedRustCallError(); + } + + case CALL_UNEXPECTED_ERROR: { + // 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 (!isNullPointer(callStatus.error_buf.data)) { + const struct = new UniffiRustBufferValue(callStatus.error_buf); + const errorBufBytes = struct.consumeIntoUint8Array(); + + if (errorBufBytes.byteLength > 0) { + const liftedErrorBuf = liftString(errorBufBytes); + throw new UniffiInternalError.RustPanic(liftedErrorBuf); + } + } + + throw new UniffiInternalError.RustPanic("Rust panic"); + } + + case CALL_CANCELLED: + // #RUST_TASK_CANCELLATION: + // + // This error code is expected when a Rust Future is cancelled or aborted, either + // from the foreign side, or from within Rust itself. + // + // As of uniffi-rs v0.28.0, call cancellation is only checked for in the Swift bindings, + // and uses an Unimplemeneted error. + throw new UniffiInternalError.AbortError(); + + default: + throw new UniffiInternalError.UnexpectedRustCallStatusCode(); + } +} + +export const uniffiCaller = new UniffiFfiRsRustCaller(); + +export const stringConverter = (() => { + const encoder = new TextEncoder(); + const decoder = new TextDecoder(); + return { + stringToBytes: (s: string) => encoder.encode(s), + bytesToString: (ab: UniffiByteArray) => decoder.decode(ab), + stringByteLength: (s: string) => encoder.encode(s).byteLength, + }; +})(); +export const FfiConverterString = uniffiCreateFfiConverterString(stringConverter); + +// Struct + Callback type definitions +export type UniffiRustBufferStruct = { capacity: bigint, len: bigint, data: JsExternal }; +const DataType_UniffiRustBufferStruct = { + capacity: DataType.U64, + len: DataType.U64, + data: DataType.External, + + ffiTypeTag: DataType.StackStruct, +}; + +export type UniffiForeignBytes = { len: number, data: JsExternal }; +const DataType_UniffiForeignBytes = { + len: DataType.I32, + data: DataType.External, + + ffiTypeTag: DataType.StackStruct, +}; + +/** A UniffiRustBufferValue represents stack allocated structure containing pointer to series of + * bytes most likely on the heap, along with the size of that data in bytes. + * + * It is often used to encode more complex function parameters / return values like structs, + * optionals, etc. + * + * `RustBufferValue`s are behind the scenes backed by manually managed memory on the rust end, and + * must be explictly destroyed when no longer used to ensure no memory is leaked. + * */ +export class UniffiRustBufferValue { + private struct: UniffiRustBufferStruct | null; + + constructor(struct: UniffiRustBufferStruct) { + this.struct = struct; + } + + static allocateWithBytes(bytes: Uint8Array) { + const [ dataPointer ] = createPointer({ + paramsType: [arrayConstructor({ type: DataType.U8Array, length: bytes.length })], + paramsValue: [bytes], + }); + + const rustBuffer = uniffiCaller.rustCall( + (callStatus) => { + return FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rustbuffer_from_bytes([ + // TODO: figure out why this is necessary. + { data: unwrapPointer([dataPointer])[0], len: bytes.byteLength }, + callStatus, + ]); + }, + /*liftString:*/ FfiConverterString.lift, + ); + + freePointer({ + paramsType: [arrayConstructor({ type: DataType.U8Array, length: bytes.byteLength })], + paramsValue: [dataPointer], + pointerType: PointerType.RsPointer + }); + + return new UniffiRustBufferValue(rustBuffer); + } + + static allocateEmpty() { + return UniffiRustBufferValue.allocateWithBytes(new Uint8Array()); + } + + toStruct() { + if (!this.struct) { + throw new Error('Error getting struct data for UniffiRustBufferValue - struct.data has been freed! This is not allowed.'); + } + return this.struct; + } + + toUint8Array() { + if (!this.struct) { + throw new Error('Error converting rust buffer to uint8array - struct.data has been freed! This is not allowed.'); + } + if (this.struct.len > Number.MAX_VALUE) { + throw new Error(`Error converting rust buffer to uint8array - rust buffer length is ${this.struct.len}, which cannot be represented as a Number safely.`) + } + + const [contents] = restorePointer({ + retType: [arrayConstructor({ type: DataType.U8Array, length: Number(this.struct.len) })], + paramsValue: wrapPointer([this.struct.data]), + }); + + return new Uint8Array(contents); + } + + consumeIntoUint8Array() { + const result = this.toUint8Array(); + this.destroy(); + return result; + } + + destroy() { + + if (!this.struct) { + throw new Error('Error destroying UniffiRustBufferValue - already previously destroyed! Double freeing is not allowed.'); + } + + uniffiCaller.rustCall( + (callStatus) => { + FFI_DYNAMIC_LIB.ffi_iota_sdk_ffi_rustbuffer_free([this.struct!, callStatus]); + }, + /*liftString:*/ FfiConverterString.lift, + ); + // freePointer({ + // paramsType: [arrayConstructor({ type: DataType.U8Array, length: this.struct.len })], + // paramsValue: wrapPointer([this.struct.data]), + // pointerType: PointerType.RsPointer, + // }); + + // console.log('DONE'); + this.struct = null; + } +} + +export type UniffiRustCallStatusStruct = { code: number, error_buf: UniffiRustBufferStruct }; +const DataType_UniffiRustCallStatus = { + code: DataType.U8, + error_buf: DataType_UniffiRustBufferStruct, +}; + export type UniffiCallbackRustFutureContinuationCallback = ( + data: bigint, + poll_result: number + ) => void; + export type UniffiCallbackForeignFutureFree = ( + handle: bigint + ) => void; + export type UniffiCallbackCallbackInterfaceFree = ( + handle: bigint + ) => void;export type UniffiForeignFuture = {handle: bigint;free: /* callback UniffiCallbackForeignFutureFree */ JsExternal; + }; + + const DataType_UniffiForeignFuture = { + handle: /* u64 */ DataType.BigInt, + free: /* callback */ DataType.External, + + + // Ensure that the struct is stack defined, without this ffi-rs isn't able to decode the + // struct properly + ffiTypeTag: DataType.StackStruct, + };export type UniffiForeignFutureStructU8 = {returnValue: number;callStatus: /* RustCallStatus */ JsExternal; + }; + + const DataType_UniffiForeignFutureStructU8 = { + returnValue: DataType.U8, + callStatus: /* RustCallStatus */ DataType.External, + + + // Ensure that the struct is stack defined, without this ffi-rs isn't able to decode the + // struct properly + ffiTypeTag: DataType.StackStruct, + }; + export type UniffiCallbackForeignFutureCompleteU8 = ( + callback_data: bigint, + result: UniffiForeignFutureStructU8 + ) => void;export type UniffiForeignFutureStructI8 = {returnValue: number;callStatus: /* RustCallStatus */ JsExternal; + }; + + const DataType_UniffiForeignFutureStructI8 = { + returnValue: /* i8 */ DataType.U8, + callStatus: /* RustCallStatus */ DataType.External, + + + // Ensure that the struct is stack defined, without this ffi-rs isn't able to decode the + // struct properly + ffiTypeTag: DataType.StackStruct, + }; + export type UniffiCallbackForeignFutureCompleteI8 = ( + callback_data: bigint, + result: UniffiForeignFutureStructI8 + ) => void;export type UniffiForeignFutureStructU16 = {returnValue: number;callStatus: /* RustCallStatus */ JsExternal; + }; + + const DataType_UniffiForeignFutureStructU16 = { + returnValue: /* u16 */ DataType.I32, + callStatus: /* RustCallStatus */ DataType.External, + + + // Ensure that the struct is stack defined, without this ffi-rs isn't able to decode the + // struct properly + ffiTypeTag: DataType.StackStruct, + }; + export type UniffiCallbackForeignFutureCompleteU16 = ( + callback_data: bigint, + result: UniffiForeignFutureStructU16 + ) => void;export type UniffiForeignFutureStructI16 = {returnValue: number;callStatus: /* RustCallStatus */ JsExternal; + }; + + const DataType_UniffiForeignFutureStructI16 = { + returnValue: DataType.I16, + callStatus: /* RustCallStatus */ DataType.External, + + + // Ensure that the struct is stack defined, without this ffi-rs isn't able to decode the + // struct properly + ffiTypeTag: DataType.StackStruct, + }; + export type UniffiCallbackForeignFutureCompleteI16 = ( + callback_data: bigint, + result: UniffiForeignFutureStructI16 + ) => void;export type UniffiForeignFutureStructU32 = {returnValue: number;callStatus: /* RustCallStatus */ JsExternal; + }; + + const DataType_UniffiForeignFutureStructU32 = { + returnValue: /* u32 */ DataType.I32, + callStatus: /* RustCallStatus */ DataType.External, + + + // Ensure that the struct is stack defined, without this ffi-rs isn't able to decode the + // struct properly + ffiTypeTag: DataType.StackStruct, + }; + export type UniffiCallbackForeignFutureCompleteU32 = ( + callback_data: bigint, + result: UniffiForeignFutureStructU32 + ) => void;export type UniffiForeignFutureStructI32 = {returnValue: number;callStatus: /* RustCallStatus */ JsExternal; + }; + + const DataType_UniffiForeignFutureStructI32 = { + returnValue: DataType.I32, + callStatus: /* RustCallStatus */ DataType.External, + + + // Ensure that the struct is stack defined, without this ffi-rs isn't able to decode the + // struct properly + ffiTypeTag: DataType.StackStruct, + }; + export type UniffiCallbackForeignFutureCompleteI32 = ( + callback_data: bigint, + result: UniffiForeignFutureStructI32 + ) => void;export type UniffiForeignFutureStructU64 = {returnValue: bigint;callStatus: /* RustCallStatus */ JsExternal; + }; + + const DataType_UniffiForeignFutureStructU64 = { + returnValue: /* u64 */ DataType.BigInt, + callStatus: /* RustCallStatus */ DataType.External, + + + // Ensure that the struct is stack defined, without this ffi-rs isn't able to decode the + // struct properly + ffiTypeTag: DataType.StackStruct, + }; + export type UniffiCallbackForeignFutureCompleteU64 = ( + callback_data: bigint, + result: UniffiForeignFutureStructU64 + ) => void;export type UniffiForeignFutureStructI64 = {returnValue: bigint;callStatus: /* RustCallStatus */ JsExternal; + }; + + const DataType_UniffiForeignFutureStructI64 = { + returnValue: /* i64 */ DataType.BigInt, + callStatus: /* RustCallStatus */ DataType.External, + + + // Ensure that the struct is stack defined, without this ffi-rs isn't able to decode the + // struct properly + ffiTypeTag: DataType.StackStruct, + }; + export type UniffiCallbackForeignFutureCompleteI64 = ( + callback_data: bigint, + result: UniffiForeignFutureStructI64 + ) => void;export type UniffiForeignFutureStructF32 = {returnValue: number;callStatus: /* RustCallStatus */ JsExternal; + }; + + const DataType_UniffiForeignFutureStructF32 = { + returnValue: /* f32 */ DataType.Float, + callStatus: /* RustCallStatus */ DataType.External, + + + // Ensure that the struct is stack defined, without this ffi-rs isn't able to decode the + // struct properly + ffiTypeTag: DataType.StackStruct, + }; + export type UniffiCallbackForeignFutureCompleteF32 = ( + callback_data: bigint, + result: UniffiForeignFutureStructF32 + ) => void;export type UniffiForeignFutureStructF64 = {returnValue: number;callStatus: /* RustCallStatus */ JsExternal; + }; + + const DataType_UniffiForeignFutureStructF64 = { + returnValue: /* f64 */ DataType.Double, + callStatus: /* RustCallStatus */ DataType.External, + + + // Ensure that the struct is stack defined, without this ffi-rs isn't able to decode the + // struct properly + ffiTypeTag: DataType.StackStruct, + }; + export type UniffiCallbackForeignFutureCompleteF64 = ( + callback_data: bigint, + result: UniffiForeignFutureStructF64 + ) => void;export type UniffiForeignFutureStructPointer = {returnValue: /* RustArcPtr */ bigint;callStatus: /* RustCallStatus */ JsExternal; + }; + + const DataType_UniffiForeignFutureStructPointer = { + returnValue: /* RustArcPtr */ DataType.BigInt, + callStatus: /* RustCallStatus */ DataType.External, + + + // Ensure that the struct is stack defined, without this ffi-rs isn't able to decode the + // struct properly + ffiTypeTag: DataType.StackStruct, + }; + export type UniffiCallbackForeignFutureCompletePointer = ( + callback_data: bigint, + result: UniffiForeignFutureStructPointer + ) => void;export type UniffiForeignFutureStructRustBuffer = {returnValue: /* RustBuffer */ UniffiRustBufferStruct;callStatus: /* RustCallStatus */ JsExternal; + }; + + const DataType_UniffiForeignFutureStructRustBuffer = { + returnValue: DataType_UniffiRustBufferStruct, + callStatus: /* RustCallStatus */ DataType.External, + + + // Ensure that the struct is stack defined, without this ffi-rs isn't able to decode the + // struct properly + ffiTypeTag: DataType.StackStruct, + }; + export type UniffiCallbackForeignFutureCompleteRustBuffer = ( + callback_data: bigint, + result: UniffiForeignFutureStructRustBuffer + ) => void;export type UniffiForeignFutureStructVoid = {callStatus: /* RustCallStatus */ JsExternal; + }; + + const DataType_UniffiForeignFutureStructVoid = { + callStatus: /* RustCallStatus */ DataType.External, + + + // Ensure that the struct is stack defined, without this ffi-rs isn't able to decode the + // struct properly + ffiTypeTag: DataType.StackStruct, + }; + export type UniffiCallbackForeignFutureCompleteVoid = ( + callback_data: bigint, + result: UniffiForeignFutureStructVoid + ) => void; + export type UniffiCallbackCallbackInterfaceTransactionSignerFnMethod0 = ( + uniffi_handle: bigint, + transaction: /* RustArcPtr */ bigint, + uniffi_future_callback: /* callback UniffiCallbackForeignFutureCompleteRustBuffer */ JsExternal, + uniffi_callback_data: bigint, + uniffi_out_return: /* MutReference to UniffiForeignFuture */ JsExternal + ) => void;export type UniffiVTableCallbackInterfaceTransactionSignerFn = {sign: /* callback UniffiCallbackCallbackInterfaceTransactionSignerFnMethod0 */ JsExternal;uniffiFree: /* callback UniffiCallbackCallbackInterfaceFree */ JsExternal; + }; + + const DataType_UniffiVTableCallbackInterfaceTransactionSignerFn = { + sign: /* callback */ DataType.External, + uniffiFree: /* callback */ DataType.External, + + + // Ensure that the struct is stack defined, without this ffi-rs isn't able to decode the + // struct properly + ffiTypeTag: DataType.StackStruct, + }; + + +// Actual FFI functions from dynamic library +/** This direct / "extern C" type FFI interface is bound directly to the functions exposed by the + * dynamic library. Using this manually from end-user javascript code is unsafe and this is not + * recommended. */ +const FFI_DYNAMIC_LIB = define({ + RustFutureContinuationCallback: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* u64 */ DataType.BigInt, + /* i8 */ DataType.U8 + ], + }, + ForeignFutureFree: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* u64 */ DataType.BigInt + ], + }, + CallbackInterfaceFree: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* u64 */ DataType.BigInt + ], + }, + ForeignFutureCompleteU8: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* u64 */ DataType.BigInt, + /* UniffiForeignFutureStructU8 */ DataType.U8Array + ], + }, + ForeignFutureCompleteI8: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* u64 */ DataType.BigInt, + /* UniffiForeignFutureStructI8 */ DataType.U8Array + ], + }, + ForeignFutureCompleteU16: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* u64 */ DataType.BigInt, + /* UniffiForeignFutureStructU16 */ DataType.U8Array + ], + }, + ForeignFutureCompleteI16: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* u64 */ DataType.BigInt, + /* UniffiForeignFutureStructI16 */ DataType.U8Array + ], + }, + ForeignFutureCompleteU32: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* u64 */ DataType.BigInt, + /* UniffiForeignFutureStructU32 */ DataType.U8Array + ], + }, + ForeignFutureCompleteI32: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* u64 */ DataType.BigInt, + /* UniffiForeignFutureStructI32 */ DataType.U8Array + ], + }, + ForeignFutureCompleteU64: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* u64 */ DataType.BigInt, + /* UniffiForeignFutureStructU64 */ DataType.U8Array + ], + }, + ForeignFutureCompleteI64: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* u64 */ DataType.BigInt, + /* UniffiForeignFutureStructI64 */ DataType.U8Array + ], + }, + ForeignFutureCompleteF32: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* u64 */ DataType.BigInt, + /* UniffiForeignFutureStructF32 */ DataType.U8Array + ], + }, + ForeignFutureCompleteF64: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* u64 */ DataType.BigInt, + /* UniffiForeignFutureStructF64 */ DataType.U8Array + ], + }, + ForeignFutureCompletePointer: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* u64 */ DataType.BigInt, + /* UniffiForeignFutureStructPointer */ DataType.U8Array + ], + }, + ForeignFutureCompleteRustBuffer: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* u64 */ DataType.BigInt, + /* UniffiForeignFutureStructRustBuffer */ DataType.U8Array + ], + }, + ForeignFutureCompleteVoid: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* u64 */ DataType.BigInt, + /* UniffiForeignFutureStructVoid */ DataType.U8Array + ], + }, + CallbackInterfaceTransactionSignerFnMethod0: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* u64 */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* callback */ DataType.External, + /* u64 */ DataType.BigInt, + /* MutReference to UniffiForeignFuture */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_address: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_address: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_address_framework: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_address_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_address_from_hex: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_address_generate: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_address_std: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_address_system: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_address_zero: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_address_to_bytes: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_address_to_canonical_string: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* i8 */ DataType.U8, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_address_to_hex: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_address_to_short_string: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* i8 */ DataType.U8, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_address_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_address_uniffi_trait_display: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_address_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_address_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_address_uniffi_trait_hash: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_argument: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_argument: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_argument_new_gas: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_argument_new_input: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* u16 */ DataType.I32, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_argument_new_nested_result: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* u16 */ DataType.I32, + /* u16 */ DataType.I32, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_argument_new_result: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* u16 */ DataType.I32, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_argument_get_nested_result: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* u16 */ DataType.I32, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_argument_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_argument_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_argument_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_bls12381privatekey: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_bls12381privatekey: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_bls12381privatekey_generate: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_bls12381privatekey_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_bls12381privatekey_public_key: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_bls12381privatekey_scheme: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_bls12381privatekey_sign_checkpoint_summary: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_bls12381privatekey_try_sign: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_bls12381privatekey_verifying_key: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_bls12381publickey: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_bls12381publickey: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_bls12381publickey_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_bls12381publickey_from_str: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_bls12381publickey_generate: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_bls12381publickey_to_bytes: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_bls12381publickey_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_bls12381publickey_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_bls12381publickey_uniffi_trait_hash: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_bls12381signature: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_bls12381signature: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_bls12381signature_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_bls12381signature_from_str: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_bls12381signature_generate: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_bls12381signature_to_bytes: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_bls12381signature_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_bls12381signature_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_bls12381signature_uniffi_trait_hash: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_bls12381verifyingkey: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_bls12381verifyingkey: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_bls12381verifyingkey_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_bls12381verifyingkey_public_key: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_bls12381verifyingkey_verify: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_bls12381verifyingkey_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_bn254fieldelement: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_bn254fieldelement: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_bn254fieldelement_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_bn254fieldelement_from_str: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_bn254fieldelement_from_str_radix_10: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_bn254fieldelement_padded: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_bn254fieldelement_unpadded: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_bn254fieldelement_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_bn254fieldelement_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_bn254fieldelement_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_cancelledtransaction: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_cancelledtransaction: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_cancelledtransaction_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_cancelledtransaction_digest: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_cancelledtransaction_version_assignments: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_cancelledtransaction_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_cancelledtransaction_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_cancelledtransaction_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_changeepoch: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_changeepoch: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_changeepoch_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepoch_computation_charge: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepoch_epoch: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepoch_epoch_start_timestamp_ms: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepoch_non_refundable_storage_fee: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepoch_protocol_version: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepoch_storage_charge: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepoch_storage_rebate: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepoch_system_packages: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepoch_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepoch_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepoch_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_changeepochv2: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_changeepochv2: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_changeepochv2_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv2_computation_charge: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv2_computation_charge_burned: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv2_epoch: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv2_epoch_start_timestamp_ms: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv2_non_refundable_storage_fee: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv2_protocol_version: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv2_storage_charge: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv2_storage_rebate: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv2_system_packages: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv2_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv2_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv2_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_changeepochv3: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_changeepochv3: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_changeepochv3_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv3_computation_charge: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv3_computation_charge_burned: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv3_eligible_active_validators: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv3_epoch: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv3_epoch_start_timestamp_ms: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv3_non_refundable_storage_fee: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv3_protocol_version: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv3_storage_charge: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv3_storage_rebate: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv3_system_packages: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv3_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv3_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv3_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_changeepochv4: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_changeepochv4: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_changeepochv4_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + /* i8 */ DataType.U8, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv4_adjust_rewards_by_score: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv4_computation_charge: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv4_computation_charge_burned: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv4_eligible_active_validators: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv4_epoch: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv4_epoch_start_timestamp_ms: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv4_non_refundable_storage_fee: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv4_protocol_version: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv4_scores: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv4_storage_charge: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv4_storage_rebate: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_changeepochv4_system_packages: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_checkpointcommitment: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_checkpointcommitment: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_checkpointcommitment_as_ecmh_live_object_set_digest: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_checkpointcommitment_is_ecmh_live_object_set: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_checkpointcontents: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_checkpointcontents: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_checkpointcontents_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_checkpointcontents_digest: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_checkpointcontents_transaction_info: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_checkpointsummary: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_checkpointsummary: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_checkpointsummary_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + /* u64 */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_checkpointsummary_checkpoint_commitments: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_checkpointsummary_content_digest: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_checkpointsummary_digest: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_checkpointsummary_end_of_epoch_data: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_checkpointsummary_epoch: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_checkpointsummary_epoch_rolling_gas_cost_summary: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_checkpointsummary_network_total_transactions: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_checkpointsummary_previous_digest: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_checkpointsummary_sequence_number: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_checkpointsummary_signing_message: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_checkpointsummary_signing_message_hex: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_checkpointsummary_timestamp_ms: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_checkpointsummary_version_specific_data: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_checkpointtransactioninfo: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_checkpointtransactioninfo: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_checkpointtransactioninfo_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_checkpointtransactioninfo_effects: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_checkpointtransactioninfo_signatures: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_checkpointtransactioninfo_transaction: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_circomg1: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_circomg1: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_circomg1_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_circomg1_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_circomg1_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_circomg1_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_circomg2: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_circomg2: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_circomg2_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_circomg2_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_circomg2_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_circomg2_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_clienttransactionbuilder: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_clienttransactionbuilder: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_dry_run: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* i8 */ DataType.U8 + ], + }, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_execute: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_execute_with_sponsor: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_expiration: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* u64 */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_finish: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt + ], + }, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_gas: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_gas_budget: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* u64 */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_gas_price: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* u64 */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_gas_station_sponsor: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_make_move_vec: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_merge_coins: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_move_call: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_publish: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_send_coins: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_send_iota: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_set_sender: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_split_coins: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_sponsor: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_stake: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_transfer_objects: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_unstake: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_upgrade: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_coin: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_coin: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_coin_try_from_object: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_coin_balance: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_coin_coin_type: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_coin_id: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_coin_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_command: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_command: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_command_new_make_move_vector: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_command_new_merge_coins: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_command_new_move_call: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_command_new_publish: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_command_new_split_coins: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_command_new_transfer_objects: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_command_new_upgrade: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_command_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_command_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_command_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_consensuscommitprologuev1: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_consensuscommitprologuev1: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_consensuscommitprologuev1_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* u64 */ DataType.BigInt, + /* u64 */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* u64 */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_commit_timestamp_ms: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_consensus_commit_digest: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_consensus_determined_version_assignments: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_epoch: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_round: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_sub_dag_index: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_consensusdeterminedversionassignments: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_consensusdeterminedversionassignments: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_consensusdeterminedversionassignments_new_cancelled_transactions: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_consensusdeterminedversionassignments_as_cancelled_transactions: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_consensusdeterminedversionassignments_is_cancelled_transactions: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_consensusdeterminedversionassignments_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_consensusdeterminedversionassignments_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_consensusdeterminedversionassignments_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_digest: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_digest: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_digest_from_base58: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_digest_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_digest_generate: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_digest_next_lexicographical: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_digest_to_base58: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_digest_to_bytes: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_digest_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_digest_uniffi_trait_display: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_digest_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_digest_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_digest_uniffi_trait_hash: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_ed25519privatekey: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_ed25519privatekey: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ed25519privatekey_from_bech32: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ed25519privatekey_from_der: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ed25519privatekey_from_mnemonic: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, + /* u64 */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ed25519privatekey_from_mnemonic_with_path: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ed25519privatekey_from_pem: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ed25519privatekey_generate: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ed25519privatekey_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_public_key: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_scheme: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_sign_personal_message: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_sign_transaction: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_to_bech32: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_to_bytes: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_to_der: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_to_pem: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_try_sign: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_try_sign_simple: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_try_sign_user: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_verifying_key: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_ed25519publickey: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_ed25519publickey: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ed25519publickey_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ed25519publickey_from_str: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ed25519publickey_generate: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519publickey_derive_address: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519publickey_scheme: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519publickey_to_bytes: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519publickey_to_flagged_bytes: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519publickey_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519publickey_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519publickey_uniffi_trait_hash: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_ed25519signature: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_ed25519signature: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ed25519signature_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ed25519signature_from_str: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ed25519signature_generate: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519signature_to_bytes: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519signature_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519signature_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519signature_uniffi_trait_hash: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_ed25519verifier: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_ed25519verifier: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ed25519verifier_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519verifier_verify_simple: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519verifier_verify_user: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519verifier_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_ed25519verifyingkey: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_ed25519verifyingkey: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ed25519verifyingkey_from_der: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ed25519verifyingkey_from_pem: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ed25519verifyingkey_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519verifyingkey_public_key: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519verifyingkey_to_der: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519verifyingkey_to_pem: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519verifyingkey_verify: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519verifyingkey_verify_simple: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519verifyingkey_verify_user: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519verifyingkey_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519verifyingkey_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_ed25519verifyingkey_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_endofepochtransactionkind: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_endofepochtransactionkind: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_endofepochtransactionkind_new_authenticator_state_create: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_endofepochtransactionkind_new_authenticator_state_expire: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_endofepochtransactionkind_new_change_epoch: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_endofepochtransactionkind_new_change_epoch_v2: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_endofepochtransactionkind_new_change_epoch_v3: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_endofepochtransactionkind_new_change_epoch_v4: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_endofepochtransactionkind_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_endofepochtransactionkind_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_endofepochtransactionkind_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_executiontimeobservation: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_executiontimeobservation: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservation_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservation_key: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservation_observations: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservation_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservation_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservation_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservation_uniffi_trait_hash: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_executiontimeobservationkey: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_executiontimeobservationkey: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_make_move_vec: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_merge_coins: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_move_entry_point: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_publish: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_split_coins: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_transfer_objects: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_upgrade: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservationkey_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservationkey_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservationkey_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservationkey_uniffi_trait_hash: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_executiontimeobservations: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_executiontimeobservations: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservations_new_v1: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservations_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservations_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservations_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservations_uniffi_trait_hash: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_faucetclient: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_faucetclient: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_faucetclient_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_faucetclient_new_devnet: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_faucetclient_new_localnet: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_faucetclient_new_testnet: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_faucetclient_request: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt + ], + }, + uniffi_iota_sdk_ffi_fn_method_faucetclient_request_and_wait: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt + ], + }, + uniffi_iota_sdk_ffi_fn_method_faucetclient_request_and_wait_for_finalized: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt + ], + }, + uniffi_iota_sdk_ffi_fn_method_faucetclient_request_status: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_clone_genesisobject: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_genesisobject: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_genesisobject_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_genesisobject_data: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_genesisobject_object_id: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_genesisobject_object_type: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_genesisobject_owner: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_genesisobject_version: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_genesisobject_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_genesisobject_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_genesisobject_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_genesistransaction: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_genesistransaction: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_genesistransaction_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_genesistransaction_events: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_genesistransaction_objects: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_genesistransaction_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_genesistransaction_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_genesistransaction_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_graphqlclient: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_graphqlclient: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_graphqlclient_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_graphqlclient_new_devnet: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_graphqlclient_new_localnet: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_graphqlclient_new_mainnet: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_graphqlclient_new_testnet: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_active_validators: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_balance: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_chain_id: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_checkpoint: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_checkpoints: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_coin_metadata: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_coins: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_dry_run_tx: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* i8 */ DataType.U8 + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_dry_run_tx_kind: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* i8 */ DataType.U8 + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_dynamic_field: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_dynamic_fields: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_dynamic_object_field: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_epoch: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_epoch_total_checkpoints: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_epoch_total_transaction_blocks: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_events: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_execute_tx: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_gas_coins: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_iota_names_default_name: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_iota_names_lookup: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_iota_names_registrations: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_is_tx_finalized: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_is_tx_indexed_on_node: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_latest_checkpoint_sequence_number: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_max_page_size: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_move_object_contents: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_move_object_contents_bcs: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_move_view_call: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_move_view_call_json: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_normalized_move_function: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_normalized_move_module: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_object: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_object_bcs: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_objects: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_package: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_package_latest: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_package_versions: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_packages: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_protocol_config: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_reference_gas_price: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_run_query: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_service_config: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_set_rpc_server: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_total_supply: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_total_transaction_blocks: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_total_transaction_blocks_by_digest: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_total_transaction_blocks_by_seq_num: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* u64 */ DataType.BigInt + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_transaction: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_transaction_data_effects: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_transaction_effects: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_transactions: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_transactions_data_effects: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_transactions_effects: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_wait_for_tx: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct + ], + }, + uniffi_iota_sdk_ffi_fn_clone_identifier: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_identifier: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_identifier_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_identifier_as_str: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_identifier_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_identifier_uniffi_trait_display: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_identifier_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_identifier_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_identifier_uniffi_trait_hash: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_input: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_input: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_input_new_immutable_or_owned: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_input_new_pure: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_input_new_receiving: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_input_new_shared: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* i8 */ DataType.U8, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_input_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_input_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_input_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_intent: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_intent: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_intent_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_intent_from_hex: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_intent_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_intent_new_consensus_app: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_intent_new_iota_app: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_intent_new_iota_transaction: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_intent_new_personal_message: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_intent_app_id: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_intent_scope: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_intent_to_bytes: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_intent_version: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_intent_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_intent_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_intent_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_intent_uniffi_trait_hash: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_makemovevector: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_makemovevector: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_makemovevector_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_makemovevector_elements: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_makemovevector_type_tag: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_makemovevector_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_makemovevector_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_makemovevector_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_mergecoins: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_mergecoins: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_mergecoins_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_mergecoins_coin: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_mergecoins_coins_to_merge: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_mergecoins_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_mergecoins_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_mergecoins_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_movearg: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_movearg: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movearg_address: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movearg_address_from_hex: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movearg_address_vec: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movearg_address_vec_from_hex: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movearg_bool: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* i8 */ DataType.U8, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movearg_bool_vec: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movearg_digest: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movearg_digest_from_base58: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movearg_digest_vec: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movearg_digest_vec_from_base58: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movearg_option: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movearg_string: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movearg_string_vec: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movearg_u128: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movearg_u128_vec: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movearg_u16: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* u16 */ DataType.I32, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movearg_u16_vec: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movearg_u256: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movearg_u256_vec: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movearg_u32: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* u32 */ DataType.I32, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movearg_u32_vec: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movearg_u64: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* u64 */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movearg_u64_vec: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movearg_u8: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType.U8, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movearg_u8_vec: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_moveauthenticator: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_moveauthenticator: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_moveauthenticator_new_immutable: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_moveauthenticator_new_shared: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, + /* u64 */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_moveauthenticator_address: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_moveauthenticator_call_args: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_moveauthenticator_object_to_authenticate: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_moveauthenticator_type_args: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_moveauthenticatorbuilder: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_moveauthenticatorbuilder: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_moveauthenticatorbuilder_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_moveauthenticatorbuilder_finish: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt + ], + }, + uniffi_iota_sdk_ffi_fn_clone_movecall: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_movecall: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movecall_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movecall_arguments: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movecall_function: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movecall_module: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movecall_package: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movecall_type_arguments: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movecall_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movecall_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movecall_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_movefunction: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_movefunction: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movefunction_is_entry: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movefunction_name: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movefunction_parameters: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movefunction_return_type: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movefunction_type_parameters: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movefunction_visibility: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movefunction_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movefunction_uniffi_trait_display: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_movepackage: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_movepackage: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movepackage_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* u64 */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movepackage_id: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movepackage_linkage_table: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movepackage_modules: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movepackage_type_origin_table: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movepackage_version: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movepackage_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movepackage_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movepackage_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movepackage_uniffi_trait_hash: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_movepackagedata: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_movepackagedata: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movepackagedata_from_base64: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movepackagedata_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_movepackagedata_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movepackagedata_dependencies: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movepackagedata_digest: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movepackagedata_modules: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movepackagedata_to_base64: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movepackagedata_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_movepackagedata_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_moveviewarg: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_moveviewarg: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_address: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_bool: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* i8 */ DataType.U8, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_null: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_object_id: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_option: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_string: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_string_vec: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_u128: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_u16: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* u16 */ DataType.I32, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_u32: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* u32 */ DataType.I32, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_u64: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* u64 */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_u8: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType.U8, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_u8_vec: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_multisigaggregatedsignature: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_multisigaggregatedsignature: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_multisigaggregatedsignature_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* u16 */ DataType.I32, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigaggregatedsignature_bitmap: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigaggregatedsignature_committee: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigaggregatedsignature_signatures: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigaggregatedsignature_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigaggregatedsignature_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigaggregatedsignature_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_multisigaggregator: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_multisigaggregator: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_multisigaggregator_new_with_message: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_multisigaggregator_new_with_transaction: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigaggregator_finish: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigaggregator_verifier: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigaggregator_with_signature: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigaggregator_with_verifier: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigaggregator_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_multisigcommittee: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_multisigcommittee: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_multisigcommittee_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, + /* u16 */ DataType.I32, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigcommittee_derive_address: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigcommittee_is_valid: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigcommittee_members: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigcommittee_scheme: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigcommittee_threshold: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigcommittee_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigcommittee_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigcommittee_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_multisigmember: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_multisigmember: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_multisigmember_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType.U8, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmember_public_key: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmember_weight: { + library: "libiota_sdk_ffi", + retType:DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmember_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmember_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmember_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_multisigmemberpublickey: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_multisigmemberpublickey: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_ed25519: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_ed25519_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_secp256k1: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_secp256k1_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_secp256r1: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_secp256r1_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_zklogin: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_zklogin_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_is_ed25519: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_is_secp256k1: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_is_secp256r1: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_is_zklogin: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_scheme: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_multisigmembersignature: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_multisigmembersignature: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_ed25519: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_ed25519_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_secp256k1: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_secp256k1_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_secp256r1: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_secp256r1_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_zklogin: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_zklogin_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_is_ed25519: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_is_secp256k1: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_is_secp256r1: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_is_zklogin: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_multisigverifier: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_multisigverifier: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_multisigverifier_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigverifier_verify: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigverifier_with_zklogin_verifier: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigverifier_zklogin_verifier: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_multisigverifier_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_name: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_name: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_name_from_str: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_name_format: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_name_is_sln: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_name_is_subname: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_name_label: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* u32 */ DataType.I32, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_name_labels: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_name_num_labels: { + library: "libiota_sdk_ffi", + retType:/* u32 */ DataType.I32, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_name_parent: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_name_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_name_uniffi_trait_display: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_name_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_name_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_name_uniffi_trait_hash: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_nameregistration: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_nameregistration: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_nameregistration_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* u64 */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_nameregistration_expiration_timestamp_ms: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_nameregistration_id: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_nameregistration_name: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_nameregistration_name_str: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_nameregistration_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_nameregistration_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_nameregistration_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_object: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_object: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_object_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* u64 */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_object_as_package: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_object_as_package_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_object_as_struct: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_object_as_struct_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_object_data: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_object_digest: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_object_object_id: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_object_object_ref: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_object_object_type: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_object_owner: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_object_previous_transaction: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_object_storage_rebate: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_object_version: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_object_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_object_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_object_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_objectdata: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_objectdata: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_objectdata_new_move_package: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_objectdata_new_move_struct: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objectdata_as_package_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objectdata_as_struct_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objectdata_is_package: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objectdata_is_struct: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objectdata_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objectdata_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objectdata_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objectdata_uniffi_trait_hash: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_objectid: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_objectid: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_objectid_clock: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_objectid_derive_id: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* u64 */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_objectid_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_objectid_from_hex: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_objectid_system: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_objectid_zero: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objectid_derive_dynamic_child_id: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objectid_to_address: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objectid_to_bytes: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objectid_to_canonical_string: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* i8 */ DataType.U8, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objectid_to_hex: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objectid_to_short_string: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* i8 */ DataType.U8, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objectid_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objectid_uniffi_trait_display: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objectid_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objectid_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objectid_uniffi_trait_hash: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_objecttype: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_objecttype: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_objecttype_new_package: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_objecttype_new_struct: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objecttype_as_struct: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objecttype_as_struct_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objecttype_is_package: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objecttype_is_struct: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objecttype_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objecttype_uniffi_trait_display: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objecttype_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_objecttype_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_owner: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_owner: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_owner_new_address: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_owner_new_immutable: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_owner_new_object: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_owner_new_shared: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* u64 */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_owner_as_address: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_owner_as_address_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_owner_as_object: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_owner_as_object_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_owner_as_shared: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_owner_as_shared_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_owner_is_address: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_owner_is_immutable: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_owner_is_object: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_owner_is_shared: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_owner_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_owner_uniffi_trait_display: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_owner_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_owner_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_owner_uniffi_trait_hash: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_ptbargument: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_ptbargument: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_address: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_address_from_hex: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_address_vec: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_address_vec_from_hex: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_assigned: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_bool: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* i8 */ DataType.U8, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_bool_vec: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_digest: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_digest_from_base58: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_digest_vec: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_digest_vec_from_base58: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_gas: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_move_arg: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_object_id: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_object_id_from_hex: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_object_ref: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_option: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_receiving: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_receiving_from_hex: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_shared: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_shared_from_hex: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_shared_mut: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_shared_mut_from_hex: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_string: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u128: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u128_vec: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u16: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* u16 */ DataType.I32, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u16_vec: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u256: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u256_vec: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u32: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* u32 */ DataType.I32, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u32_vec: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u64: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* u64 */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u64_vec: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u8: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType.U8, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u8_vec: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_passkeyauthenticator: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_passkeyauthenticator: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_authenticator_data: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_challenge: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_client_data_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_public_key: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_signature: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_passkeypublickey: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_passkeypublickey: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_passkeypublickey_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_passkeypublickey_derive_address: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_passkeypublickey_inner: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_passkeypublickey_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_passkeypublickey_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_passkeypublickey_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_passkeyverifier: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_passkeyverifier: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_passkeyverifier_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_passkeyverifier_verify: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_passkeyverifier_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_personalmessage: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_personalmessage: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_personalmessage_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_personalmessage_message_bytes: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_personalmessage_signing_digest: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_personalmessage_signing_digest_hex: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_personalmessage_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_personalmessage_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_personalmessage_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_programmabletransaction: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_programmabletransaction: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_programmabletransaction_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_programmabletransaction_commands: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_programmabletransaction_inputs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_programmabletransaction_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_programmabletransaction_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_programmabletransaction_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_publish: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_publish: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_publish_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_publish_dependencies: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_publish_modules: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_publish_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_publish_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_publish_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_secp256k1privatekey: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_secp256k1privatekey: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1privatekey_from_bech32: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1privatekey_from_der: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1privatekey_from_mnemonic: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, + /* u64 */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1privatekey_from_mnemonic_with_path: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1privatekey_from_pem: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1privatekey_generate: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1privatekey_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_public_key: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_scheme: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_sign_personal_message: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_sign_transaction: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_to_bech32: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_to_bytes: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_to_der: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_to_pem: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_try_sign: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_try_sign_simple: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_try_sign_user: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_verifying_key: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_secp256k1publickey: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_secp256k1publickey: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1publickey_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1publickey_from_str: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1publickey_generate: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1publickey_derive_address: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1publickey_scheme: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1publickey_to_bytes: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1publickey_to_flagged_bytes: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1publickey_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1publickey_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1publickey_uniffi_trait_hash: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_secp256k1signature: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_secp256k1signature: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1signature_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1signature_from_str: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1signature_generate: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1signature_to_bytes: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1signature_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1signature_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1signature_uniffi_trait_hash: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_secp256k1verifier: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_secp256k1verifier: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1verifier_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1verifier_verify_simple: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1verifier_verify_user: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1verifier_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_secp256k1verifyingkey: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_secp256k1verifyingkey: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1verifyingkey_from_der: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1verifyingkey_from_pem: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1verifyingkey_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1verifyingkey_public_key: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1verifyingkey_to_der: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1verifyingkey_to_pem: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1verifyingkey_verify: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1verifyingkey_verify_simple: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1verifyingkey_verify_user: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1verifyingkey_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1verifyingkey_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256k1verifyingkey_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_secp256r1privatekey: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_secp256r1privatekey: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1privatekey_from_bech32: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1privatekey_from_der: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1privatekey_from_mnemonic: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, + /* u64 */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1privatekey_from_mnemonic_with_path: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1privatekey_from_pem: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1privatekey_generate: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1privatekey_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_public_key: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_scheme: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_sign_personal_message: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_sign_transaction: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_to_bech32: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_to_bytes: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_to_der: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_to_pem: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_try_sign: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_try_sign_simple: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_try_sign_user: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_verifying_key: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_secp256r1publickey: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_secp256r1publickey: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1publickey_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1publickey_from_str: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1publickey_generate: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1publickey_derive_address: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1publickey_scheme: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1publickey_to_bytes: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1publickey_to_flagged_bytes: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1publickey_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1publickey_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1publickey_uniffi_trait_hash: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_secp256r1signature: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_secp256r1signature: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1signature_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1signature_from_str: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1signature_generate: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1signature_to_bytes: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1signature_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1signature_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1signature_uniffi_trait_hash: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_secp256r1verifier: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_secp256r1verifier: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1verifier_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1verifier_verify_simple: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1verifier_verify_user: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1verifier_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_secp256r1verifyingkey: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_secp256r1verifyingkey: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1verifyingkey_from_der: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1verifyingkey_from_pem: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1verifyingkey_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1verifyingkey_public_key: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1verifyingkey_to_der: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1verifyingkey_to_pem: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1verifyingkey_verify: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1verifyingkey_verify_simple: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1verifyingkey_verify_user: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1verifyingkey_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1verifyingkey_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_secp256r1verifyingkey_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_simplekeypair: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_simplekeypair: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_simplekeypair_from_bech32: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_simplekeypair_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_simplekeypair_from_der: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_simplekeypair_from_ed25519: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_simplekeypair_from_pem: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_simplekeypair_from_secp256k1: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_simplekeypair_from_secp256r1: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplekeypair_public_key: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplekeypair_scheme: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplekeypair_sign_personal_message: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplekeypair_sign_transaction: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplekeypair_to_bech32: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplekeypair_to_bytes: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplekeypair_to_der: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplekeypair_to_pem: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplekeypair_try_sign: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplekeypair_try_sign_user: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplekeypair_verifying_key: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplekeypair_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_simplesignature: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_simplesignature: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_simplesignature_new_ed25519: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_simplesignature_new_secp256k1: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_simplesignature_new_secp256r1: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplesignature_ed25519_pub_key: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplesignature_ed25519_pub_key_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplesignature_ed25519_sig: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplesignature_ed25519_sig_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplesignature_is_ed25519: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplesignature_is_secp256k1: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplesignature_is_secp256r1: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplesignature_scheme: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256k1_pub_key: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256k1_pub_key_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256k1_sig: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256k1_sig_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256r1_pub_key: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256r1_pub_key_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256r1_sig: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256r1_sig_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplesignature_to_bytes: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplesignature_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplesignature_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplesignature_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simplesignature_uniffi_trait_hash: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_simpleverifier: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_simpleverifier: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_simpleverifier_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simpleverifier_verify: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_simpleverifyingkey: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_simpleverifyingkey: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_simpleverifyingkey_from_der: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_simpleverifyingkey_from_pem: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simpleverifyingkey_public_key: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simpleverifyingkey_scheme: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simpleverifyingkey_to_der: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simpleverifyingkey_to_pem: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simpleverifyingkey_verify: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simpleverifyingkey_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simpleverifyingkey_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_simpleverifyingkey_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_splitcoins: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_splitcoins: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_splitcoins_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_splitcoins_amounts: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_splitcoins_coin: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_splitcoins_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_splitcoins_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_splitcoins_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_structtag: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_structtag: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_ascii_string: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_balance: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_clock: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_coin: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_coin_manager: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_coin_metadata: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_config: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_config_setting: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_deny_list_address_key: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_deny_list_config_key: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_deny_list_global_pause_key: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_display_created: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_dynamic_object_field_wrapper: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_field: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_gas_coin: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_id: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_iota_coin_type: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_iota_system_admin_cap: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_iota_system_state: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_iota_treasury_cap: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_name: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_staked_iota: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_string: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_system_epoch_info_event: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_time_lock: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_timelocked_staked_iota: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_transfer_receiving: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_treasury_cap: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_uid: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_upgrade_cap: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_upgrade_receipt: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_upgrade_ticket: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_version_updated: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_structtag_address: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_structtag_coin_type: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_structtag_coin_type_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_structtag_module: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_structtag_name: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_structtag_to_canonical_string: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* i8 */ DataType.U8, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_structtag_type_args: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_structtag_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_structtag_uniffi_trait_display: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_structtag_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_structtag_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_structtag_uniffi_trait_hash: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_systempackage: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_systempackage: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_systempackage_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* u64 */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_systempackage_dependencies: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_systempackage_modules: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_systempackage_version: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_systempackage_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_systempackage_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_systempackage_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_transaction: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_transaction: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_transaction_from_base64: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_transaction_new_v1: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transaction_as_v1: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transaction_digest: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transaction_expiration: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transaction_gas_payment: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transaction_kind: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transaction_sender: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transaction_signing_digest: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transaction_signing_digest_hex: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transaction_to_base64: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transaction_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transaction_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transaction_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_transactionbuilder: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_transactionbuilder: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_transactionbuilder_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_execute_with_gas_station: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_expiration: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* u64 */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_finish: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_gas: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_gas_budget: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* u64 */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_gas_price: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* u64 */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_gas_station_sponsor: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_make_move_vec: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_merge_coins: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_move_call: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_publish: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_send_coins: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_send_iota: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_set_sender: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_split_coins: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_sponsor: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_stake: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_transfer_objects: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_unstake: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_upgrade: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_with_client: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_transactioneffects: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_transactioneffects: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_transactioneffects_new_v1: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactioneffects_as_v1: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactioneffects_digest: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactioneffects_is_v1: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactioneffects_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactioneffects_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactioneffects_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_transactionevents: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_transactionevents: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_transactionevents_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionevents_digest: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionevents_events: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_transactionkind: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_transactionkind: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_transactionkind_new_authenticator_state_update_v1: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_transactionkind_new_consensus_commit_prologue_v1: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_transactionkind_new_end_of_epoch: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_transactionkind_new_genesis: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_transactionkind_new_programmable_transaction: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_transactionkind_new_randomness_state_update: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionkind_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionkind_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionkind_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_transactionsigner: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_transactionsigner: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_transactionsigner_from_ed25519: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_transactionsigner_from_keypair: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_transactionsigner_from_move_authenticator: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_transactionsigner_from_secp256k1: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_transactionsigner_from_secp256r1: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_transactionsigner_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionsigner_sign: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt + ], + }, + uniffi_iota_sdk_ffi_fn_clone_transactionsignerfn: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_transactionsignerfn: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_init_callback_vtable_transactionsignerfn: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* Reference to UniffiVTableCallbackInterfaceTransactionSignerFn */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionsignerfn_sign: { + library: "libiota_sdk_ffi", + retType:/* handle */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt + ], + }, + uniffi_iota_sdk_ffi_fn_clone_transactionv1: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_transactionv1: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_transactionv1_from_base64: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_transactionv1_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionv1_digest: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionv1_expiration: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionv1_gas_payment: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionv1_kind: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionv1_sender: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionv1_signing_digest: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionv1_signing_digest_hex: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionv1_to_base64: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionv1_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionv1_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transactionv1_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_transferobjects: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_transferobjects: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_transferobjects_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transferobjects_address: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transferobjects_objects: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transferobjects_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transferobjects_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_transferobjects_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_typetag: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_typetag: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_typetag_new_address: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_typetag_new_bool: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_typetag_new_signer: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_typetag_new_struct: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_typetag_new_u128: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_typetag_new_u16: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_typetag_new_u256: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_typetag_new_u32: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_typetag_new_u64: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_typetag_new_u8: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_typetag_new_vector: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_typetag_as_struct_tag: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_typetag_as_struct_tag_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_typetag_as_vector_type_tag: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_typetag_as_vector_type_tag_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_typetag_is_address: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_typetag_is_bool: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_typetag_is_signer: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_typetag_is_struct: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_typetag_is_u128: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_typetag_is_u16: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_typetag_is_u256: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_typetag_is_u32: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_typetag_is_u64: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_typetag_is_u8: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_typetag_is_vector: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_typetag_to_canonical_string: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* i8 */ DataType.U8, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_typetag_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_typetag_uniffi_trait_display: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_typetag_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_typetag_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_typetag_uniffi_trait_hash: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_upgrade: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_upgrade: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_upgrade_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_upgrade_dependencies: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_upgrade_modules: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_upgrade_package: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_upgrade_ticket: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_upgrade_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_upgrade_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_upgrade_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_upgradepolicy: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_upgradepolicy: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_upgradepolicy_additive: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_upgradepolicy_compatible: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_upgradepolicy_dep_only: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_upgradepolicy_as_u8: { + library: "libiota_sdk_ffi", + retType:DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_upgradepolicy_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_upgradepolicy_uniffi_trait_display: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_upgradepolicy_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_upgradepolicy_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_usersignature: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_usersignature: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_usersignature_from_base64: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_usersignature_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_usersignature_new_move_authenticator: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_usersignature_new_multisig: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_usersignature_new_passkey_authenticator: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_usersignature_new_simple: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_usersignature_new_zklogin_authenticator: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_usersignature_as_move_authenticator: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_usersignature_as_move_authenticator_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_usersignature_as_multisig: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_usersignature_as_multisig_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_usersignature_as_passkey_authenticator: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_usersignature_as_passkey_authenticator_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_usersignature_as_simple: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_usersignature_as_simple_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_usersignature_as_zklogin_authenticator: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_usersignature_as_zklogin_authenticator_opt: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_usersignature_is_move_authenticator: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_usersignature_is_multisig: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_usersignature_is_passkey_authenticator: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_usersignature_is_simple: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_usersignature_is_zklogin_authenticator: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_usersignature_scheme: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_usersignature_to_base64: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_usersignature_to_bytes: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_usersignature_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_usersignature_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_usersignature_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_usersignatureverifier: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_usersignatureverifier: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_usersignatureverifier_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_usersignatureverifier_verify: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_usersignatureverifier_with_zklogin_verifier: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_usersignatureverifier_zklogin_verifier: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_usersignatureverifier_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_validatoraggregatedsignature: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_validatoraggregatedsignature: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_validatoraggregatedsignature_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* u64 */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_validatoraggregatedsignature_bitmap_bytes: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_validatoraggregatedsignature_epoch: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_validatoraggregatedsignature_signature: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_validatoraggregatedsignature_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_validatorcommitteesignatureaggregator: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_validatorcommitteesignatureaggregator: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_validatorcommitteesignatureaggregator_new_checkpoint_summary: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_validatorcommitteesignatureaggregator_add_signature: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_validatorcommitteesignatureaggregator_committee: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_validatorcommitteesignatureaggregator_finish: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_validatorcommitteesignatureaggregator_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_validatorcommitteesignatureverifier: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_validatorcommitteesignatureverifier: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_validatorcommitteesignatureverifier_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_validatorcommitteesignatureverifier_committee: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_validatorcommitteesignatureverifier_verify: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_validatorcommitteesignatureverifier_verify_aggregated: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_validatorcommitteesignatureverifier_verify_checkpoint_summary: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_validatorcommitteesignatureverifier_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_validatorexecutiontimeobservation: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_validatorexecutiontimeobservation: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_validatorexecutiontimeobservation_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_validatorexecutiontimeobservation_duration: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_validatorexecutiontimeobservation_validator: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_validatorexecutiontimeobservation_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_validatorexecutiontimeobservation_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_validatorexecutiontimeobservation_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_validatorexecutiontimeobservation_uniffi_trait_hash: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_validatorsignature: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_validatorsignature: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_validatorsignature_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* u64 */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_validatorsignature_epoch: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_validatorsignature_public_key: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_validatorsignature_signature: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_validatorsignature_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_validatorsignature_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_validatorsignature_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_versionassignment: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_versionassignment: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_versionassignment_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* u64 */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_versionassignment_object_id: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_versionassignment_version: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_versionassignment_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_versionassignment_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_versionassignment_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_zkloginauthenticator: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_zkloginauthenticator: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_zkloginauthenticator_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* u64 */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zkloginauthenticator_inputs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zkloginauthenticator_max_epoch: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zkloginauthenticator_signature: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zkloginauthenticator_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zkloginauthenticator_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zkloginauthenticator_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_zklogininputs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_zklogininputs: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_zklogininputs_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zklogininputs_address_seed: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zklogininputs_header_base64: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zklogininputs_iss: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zklogininputs_iss_base64_details: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zklogininputs_jwk_id: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zklogininputs_proof_points: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zklogininputs_public_identifier: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zklogininputs_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zklogininputs_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zklogininputs_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_zkloginproof: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_zkloginproof: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_zkloginproof_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zkloginproof_a: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zkloginproof_b: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zkloginproof_c: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zkloginproof_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zkloginproof_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zkloginproof_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_zkloginpublicidentifier: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_zkloginpublicidentifier: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_zkloginpublicidentifier_new: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zkloginpublicidentifier_address_seed: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zkloginpublicidentifier_derive_address: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zkloginpublicidentifier_derive_address_padded: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zkloginpublicidentifier_derive_address_unpadded: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zkloginpublicidentifier_iss: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zkloginpublicidentifier_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zkloginpublicidentifier_uniffi_trait_eq_eq: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zkloginpublicidentifier_uniffi_trait_eq_ne: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_clone_zkloginverifier: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_free_zkloginverifier: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_zkloginverifier_new_dev: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_constructor_zkloginverifier_new_mainnet: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [/* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zkloginverifier_jwks: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zkloginverifier_verify: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zkloginverifier_with_jwks: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_method_zkloginverifier_uniffi_trait_debug: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_active_jwk_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_active_jwk_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_active_jwk_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_active_jwk_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_address_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_address_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_address_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_address_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_argument_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_argument_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_argument_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_argument_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_authenticator_state_expire_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_authenticator_state_expire_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_authenticator_state_expire_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_authenticator_state_expire_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_authenticator_state_update_v1_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_authenticator_state_update_v1_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_authenticator_state_update_v1_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_authenticator_state_update_v1_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_base64_decode: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_base64_encode: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_bls12381_public_key_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_bls12381_public_key_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_bls12381_public_key_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_bls12381_public_key_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_bls12381_signature_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_bls12381_signature_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_bls12381_signature_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_bls12381_signature_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_bn254_field_element_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_bn254_field_element_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_bn254_field_element_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_bn254_field_element_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_bool_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_bool_from_json: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_bool_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* i8 */ DataType.U8, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_bool_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* i8 */ DataType.U8, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_cancelled_transaction_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_cancelled_transaction_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_cancelled_transaction_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_cancelled_transaction_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_change_epoch_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_change_epoch_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_change_epoch_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_change_epoch_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_change_epoch_v2_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_change_epoch_v2_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_change_epoch_v2_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_change_epoch_v2_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_changed_object_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_changed_object_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_changed_object_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_changed_object_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_checkpoint_commitment_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_checkpoint_commitment_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_checkpoint_commitment_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_checkpoint_commitment_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_checkpoint_contents_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_checkpoint_contents_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_checkpoint_contents_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_checkpoint_contents_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_checkpoint_summary_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_checkpoint_summary_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_checkpoint_summary_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_checkpoint_summary_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_checkpoint_transaction_info_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_checkpoint_transaction_info_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_checkpoint_transaction_info_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_checkpoint_transaction_info_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_circom_g1_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_circom_g1_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_circom_g1_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_circom_g1_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_circom_g2_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_circom_g2_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_circom_g2_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_circom_g2_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_command_argument_error_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_command_argument_error_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_command_argument_error_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_command_argument_error_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_command_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_command_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_command_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_command_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_consensus_commit_prologue_v1_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_consensus_commit_prologue_v1_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_consensus_commit_prologue_v1_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_consensus_commit_prologue_v1_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_consensus_determined_version_assignments_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_consensus_determined_version_assignments_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_consensus_determined_version_assignments_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_consensus_determined_version_assignments_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_digest_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_digest_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_digest_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_digest_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_ed25519_public_key_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_ed25519_public_key_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_ed25519_public_key_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_ed25519_public_key_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_ed25519_signature_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_ed25519_signature_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_ed25519_signature_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_ed25519_signature_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_end_of_epoch_data_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_end_of_epoch_data_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_end_of_epoch_data_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_end_of_epoch_data_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_event_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_event_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_event_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_event_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_execution_error_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_execution_error_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_execution_error_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_execution_error_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_execution_status_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_execution_status_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_execution_status_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_execution_status_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_execution_time_observation_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_execution_time_observation_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_execution_time_observation_key_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_execution_time_observation_key_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_execution_time_observation_key_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_execution_time_observation_key_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_execution_time_observation_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_execution_time_observation_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_execution_time_observations_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_execution_time_observations_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_execution_time_observations_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_execution_time_observations_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_gas_cost_summary_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_gas_cost_summary_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_gas_cost_summary_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_gas_cost_summary_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_gas_payment_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_gas_payment_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_gas_payment_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_gas_payment_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_generate_mnemonic: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_genesis_object_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_genesis_object_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_genesis_object_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_genesis_object_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_genesis_transaction_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_genesis_transaction_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_genesis_transaction_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_genesis_transaction_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_hex_decode: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_hex_encode: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_i16_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType.I16, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_i16_from_json: { + library: "libiota_sdk_ffi", + retType:DataType.I16, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_i16_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType.I16, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_i16_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType.I16, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_i32_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType.I32, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_i32_from_json: { + library: "libiota_sdk_ffi", + retType:DataType.I32, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_i32_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType.I32, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_i32_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType.I32, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_i64_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* i64 */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_i64_from_json: { + library: "libiota_sdk_ffi", + retType:/* i64 */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_i64_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* i64 */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_i64_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* i64 */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_i8_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_i8_from_json: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_i8_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* i8 */ DataType.U8, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_i8_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* i8 */ DataType.U8, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_id_operation_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_id_operation_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_id_operation_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_id_operation_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_identifier_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_identifier_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_identifier_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_identifier_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_input_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_input_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_input_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_input_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_jwk_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_jwk_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_jwk_id_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_jwk_id_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_jwk_id_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_jwk_id_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_jwk_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_jwk_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_make_move_vector_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_make_move_vector_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_make_move_vector_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_make_move_vector_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_merge_coins_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_merge_coins_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_merge_coins_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_merge_coins_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_move_call_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_move_call_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_move_call_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_move_call_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_move_location_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_move_location_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_move_location_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_move_location_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_move_package_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_move_package_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_move_package_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_move_package_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_move_struct_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_move_struct_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_move_struct_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_move_struct_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_multisig_aggregated_signature_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_multisig_aggregated_signature_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_multisig_aggregated_signature_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_multisig_aggregated_signature_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_multisig_committee_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_multisig_committee_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_multisig_committee_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_multisig_committee_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_multisig_member_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_multisig_member_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_multisig_member_public_key_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_multisig_member_public_key_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_multisig_member_public_key_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_multisig_member_public_key_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_multisig_member_signature_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_multisig_member_signature_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_multisig_member_signature_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_multisig_member_signature_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_multisig_member_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_multisig_member_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_object_data_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_object_data_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_object_data_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_object_data_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_object_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_object_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_object_id_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_object_id_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_object_id_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_object_id_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_object_in_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_object_in_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_object_in_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_object_in_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_object_out_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_object_out_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_object_out_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_object_out_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_object_reference_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_object_reference_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_object_reference_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_object_reference_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_object_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_object_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_owner_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_owner_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_owner_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_owner_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_package_upgrade_error_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_package_upgrade_error_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_package_upgrade_error_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_package_upgrade_error_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_passkey_authenticator_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_passkey_authenticator_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_passkey_authenticator_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_passkey_authenticator_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_programmable_transaction_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_programmable_transaction_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_programmable_transaction_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_programmable_transaction_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_publish_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_publish_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_publish_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_publish_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_randomness_state_update_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_randomness_state_update_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_randomness_state_update_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_randomness_state_update_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_secp256k1_public_key_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_secp256k1_public_key_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_secp256k1_public_key_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_secp256k1_public_key_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_secp256k1_signature_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_secp256k1_signature_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_secp256k1_signature_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_secp256k1_signature_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_secp256r1_public_key_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_secp256r1_public_key_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_secp256r1_public_key_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_secp256r1_public_key_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_secp256r1_signature_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_secp256r1_signature_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_secp256r1_signature_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_secp256r1_signature_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_signed_transaction_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_signed_transaction_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_signed_transaction_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_signed_transaction_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_simple_signature_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_simple_signature_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_simple_signature_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_simple_signature_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_split_coins_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_split_coins_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_split_coins_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_split_coins_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_string_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_string_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_string_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_string_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_struct_tag_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_struct_tag_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_struct_tag_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_struct_tag_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_system_package_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_system_package_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_system_package_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_system_package_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_effects_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_effects_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_effects_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_effects_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_effects_v1_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_effects_v1_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_effects_v1_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_effects_v1_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_events_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_events_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_events_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_events_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_expiration_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_expiration_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_expiration_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_expiration_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_kind_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_kind_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_kind_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_kind_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_v1_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_v1_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_v1_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transaction_v1_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transfer_objects_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transfer_objects_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transfer_objects_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_transfer_objects_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_type_argument_error_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_type_argument_error_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_type_argument_error_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_type_argument_error_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_type_origin_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_type_origin_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_type_origin_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_type_origin_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_type_tag_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_type_tag_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_type_tag_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_type_tag_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_u16_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_u16_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_u16_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* u16 */ DataType.I32, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_u16_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* u16 */ DataType.I32, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_u32_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u32 */ DataType.I32, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_u32_from_json: { + library: "libiota_sdk_ffi", + retType:/* u32 */ DataType.I32, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_u32_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* u32 */ DataType.I32, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_u32_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* u32 */ DataType.I32, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_u64_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_u64_from_json: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_u64_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* u64 */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_u64_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* u64 */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_u8_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType.U8, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_u8_from_json: { + library: "libiota_sdk_ffi", + retType:DataType.U8, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_u8_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType.U8, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_u8_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType.U8, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_unchanged_shared_kind_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_unchanged_shared_kind_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_unchanged_shared_kind_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_unchanged_shared_kind_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_unchanged_shared_object_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_unchanged_shared_object_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_unchanged_shared_object_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_unchanged_shared_object_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_upgrade_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_upgrade_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_upgrade_info_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_upgrade_info_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_upgrade_info_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_upgrade_info_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_upgrade_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_upgrade_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_user_signature_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_user_signature_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_user_signature_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_user_signature_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_validator_aggregated_signature_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_validator_aggregated_signature_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_validator_aggregated_signature_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_validator_aggregated_signature_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_validator_committee_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_validator_committee_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_validator_committee_member_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_validator_committee_member_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_validator_committee_member_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_validator_committee_member_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_validator_committee_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_validator_committee_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_validator_execution_time_observation_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_validator_execution_time_observation_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_validator_execution_time_observation_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_validator_execution_time_observation_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_validator_signature_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_validator_signature_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_validator_signature_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_validator_signature_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_version_assignment_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_version_assignment_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_version_assignment_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_version_assignment_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_zk_login_authenticator_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_zk_login_authenticator_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_zk_login_authenticator_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_zk_login_authenticator_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_zk_login_claim_from_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_zk_login_claim_from_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_zk_login_claim_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_zk_login_claim_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_zk_login_proof_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_zk_login_proof_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_zk_login_proof_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_zk_login_proof_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_zk_login_public_identifier_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_zk_login_public_identifier_from_json: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_zk_login_public_identifier_to_bcs: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_fn_func_zk_login_public_identifier_to_json: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* RustArcPtr */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + ffi_iota_sdk_ffi_rustbuffer_alloc: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* u64 */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + ffi_iota_sdk_ffi_rustbuffer_from_bytes: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiForeignBytes, /* RustCallStatus */ DataType.External + ], + }, + ffi_iota_sdk_ffi_rustbuffer_free: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + DataType_UniffiRustBufferStruct, /* RustCallStatus */ DataType.External + ], + }, + ffi_iota_sdk_ffi_rustbuffer_reserve: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + DataType_UniffiRustBufferStruct, + /* u64 */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + ffi_iota_sdk_ffi_rust_future_poll_u8: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt, + /* callback */ DataType.External, + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_cancel_u8: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_free_u8: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_complete_u8: { + library: "libiota_sdk_ffi", + retType:DataType.U8, + paramsType: [ + /* handle */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + ffi_iota_sdk_ffi_rust_future_poll_i8: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt, + /* callback */ DataType.External, + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_cancel_i8: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_free_i8: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_complete_i8: { + library: "libiota_sdk_ffi", + retType:/* i8 */ DataType.U8, + paramsType: [ + /* handle */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + ffi_iota_sdk_ffi_rust_future_poll_u16: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt, + /* callback */ DataType.External, + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_cancel_u16: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_free_u16: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_complete_u16: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + /* handle */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + ffi_iota_sdk_ffi_rust_future_poll_i16: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt, + /* callback */ DataType.External, + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_cancel_i16: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_free_i16: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_complete_i16: { + library: "libiota_sdk_ffi", + retType:DataType.I16, + paramsType: [ + /* handle */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + ffi_iota_sdk_ffi_rust_future_poll_u32: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt, + /* callback */ DataType.External, + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_cancel_u32: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_free_u32: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_complete_u32: { + library: "libiota_sdk_ffi", + retType:/* u32 */ DataType.I32, + paramsType: [ + /* handle */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + ffi_iota_sdk_ffi_rust_future_poll_i32: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt, + /* callback */ DataType.External, + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_cancel_i32: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_free_i32: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_complete_i32: { + library: "libiota_sdk_ffi", + retType:DataType.I32, + paramsType: [ + /* handle */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + ffi_iota_sdk_ffi_rust_future_poll_u64: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt, + /* callback */ DataType.External, + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_cancel_u64: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_free_u64: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_complete_u64: { + library: "libiota_sdk_ffi", + retType:/* u64 */ DataType.BigInt, + paramsType: [ + /* handle */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + ffi_iota_sdk_ffi_rust_future_poll_i64: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt, + /* callback */ DataType.External, + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_cancel_i64: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_free_i64: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_complete_i64: { + library: "libiota_sdk_ffi", + retType:/* i64 */ DataType.BigInt, + paramsType: [ + /* handle */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + ffi_iota_sdk_ffi_rust_future_poll_f32: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt, + /* callback */ DataType.External, + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_cancel_f32: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_free_f32: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_complete_f32: { + library: "libiota_sdk_ffi", + retType:/* f32 */ DataType.Float, + paramsType: [ + /* handle */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + ffi_iota_sdk_ffi_rust_future_poll_f64: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt, + /* callback */ DataType.External, + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_cancel_f64: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_free_f64: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_complete_f64: { + library: "libiota_sdk_ffi", + retType:/* f64 */ DataType.Double, + paramsType: [ + /* handle */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + ffi_iota_sdk_ffi_rust_future_poll_pointer: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt, + /* callback */ DataType.External, + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_cancel_pointer: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_free_pointer: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_complete_pointer: { + library: "libiota_sdk_ffi", + retType:/* RustArcPtr */ DataType.BigInt, + paramsType: [ + /* handle */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + ffi_iota_sdk_ffi_rust_future_poll_rust_buffer: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt, + /* callback */ DataType.External, + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_free_rust_buffer: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_complete_rust_buffer: { + library: "libiota_sdk_ffi", + retType:DataType_UniffiRustBufferStruct, + paramsType: [ + /* handle */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + ffi_iota_sdk_ffi_rust_future_poll_void: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt, + /* callback */ DataType.External, + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_cancel_void: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_free_void: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt + ], + }, + ffi_iota_sdk_ffi_rust_future_complete_void: { + library: "libiota_sdk_ffi", + retType: + DataType.Void, + paramsType: [ + /* handle */ DataType.BigInt, /* RustCallStatus */ DataType.External + ], + }, + uniffi_iota_sdk_ffi_checksum_func_active_jwk_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_active_jwk_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_active_jwk_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_active_jwk_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_address_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_address_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_address_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_address_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_argument_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_argument_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_argument_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_argument_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_authenticator_state_expire_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_authenticator_state_expire_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_authenticator_state_expire_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_authenticator_state_expire_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_authenticator_state_update_v1_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_authenticator_state_update_v1_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_authenticator_state_update_v1_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_authenticator_state_update_v1_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_base64_decode: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_base64_encode: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_bls12381_public_key_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_bls12381_public_key_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_bls12381_public_key_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_bls12381_public_key_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_bls12381_signature_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_bls12381_signature_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_bls12381_signature_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_bls12381_signature_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_bn254_field_element_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_bn254_field_element_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_bn254_field_element_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_bn254_field_element_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_bool_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_bool_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_bool_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_bool_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_cancelled_transaction_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_cancelled_transaction_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_cancelled_transaction_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_cancelled_transaction_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_change_epoch_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_change_epoch_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_change_epoch_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_change_epoch_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_change_epoch_v2_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_change_epoch_v2_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_change_epoch_v2_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_change_epoch_v2_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_changed_object_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_changed_object_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_changed_object_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_changed_object_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_commitment_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_commitment_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_commitment_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_commitment_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_contents_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_contents_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_contents_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_contents_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_summary_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_summary_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_summary_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_summary_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_transaction_info_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_transaction_info_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_transaction_info_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_transaction_info_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_circom_g1_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_circom_g1_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_circom_g1_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_circom_g1_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_circom_g2_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_circom_g2_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_circom_g2_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_circom_g2_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_command_argument_error_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_command_argument_error_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_command_argument_error_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_command_argument_error_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_command_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_command_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_command_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_command_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_consensus_commit_prologue_v1_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_consensus_commit_prologue_v1_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_consensus_commit_prologue_v1_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_consensus_commit_prologue_v1_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_consensus_determined_version_assignments_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_consensus_determined_version_assignments_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_consensus_determined_version_assignments_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_consensus_determined_version_assignments_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_digest_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_digest_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_digest_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_digest_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_ed25519_public_key_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_ed25519_public_key_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_ed25519_public_key_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_ed25519_public_key_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_ed25519_signature_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_ed25519_signature_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_ed25519_signature_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_ed25519_signature_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_end_of_epoch_data_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_end_of_epoch_data_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_end_of_epoch_data_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_end_of_epoch_data_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_event_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_event_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_event_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_event_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_execution_error_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_execution_error_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_execution_error_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_execution_error_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_execution_status_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_execution_status_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_execution_status_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_execution_status_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_execution_time_observation_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_execution_time_observation_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_execution_time_observation_key_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_execution_time_observation_key_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_execution_time_observation_key_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_execution_time_observation_key_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_execution_time_observation_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_execution_time_observation_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_execution_time_observations_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_execution_time_observations_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_execution_time_observations_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_execution_time_observations_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_gas_cost_summary_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_gas_cost_summary_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_gas_cost_summary_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_gas_cost_summary_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_gas_payment_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_gas_payment_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_gas_payment_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_gas_payment_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_generate_mnemonic: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_genesis_object_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_genesis_object_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_genesis_object_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_genesis_object_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_genesis_transaction_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_genesis_transaction_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_genesis_transaction_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_genesis_transaction_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_hex_decode: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_hex_encode: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_i16_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_i16_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_i16_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_i16_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_i32_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_i32_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_i32_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_i32_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_i64_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_i64_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_i64_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_i64_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_i8_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_i8_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_i8_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_i8_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_id_operation_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_id_operation_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_id_operation_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_id_operation_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_identifier_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_identifier_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_identifier_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_identifier_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_input_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_input_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_input_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_input_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_jwk_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_jwk_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_jwk_id_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_jwk_id_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_jwk_id_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_jwk_id_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_jwk_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_jwk_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_make_move_vector_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_make_move_vector_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_make_move_vector_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_make_move_vector_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_merge_coins_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_merge_coins_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_merge_coins_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_merge_coins_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_move_call_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_move_call_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_move_call_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_move_call_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_move_location_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_move_location_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_move_location_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_move_location_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_move_package_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_move_package_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_move_package_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_move_package_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_move_struct_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_move_struct_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_move_struct_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_move_struct_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_multisig_aggregated_signature_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_multisig_aggregated_signature_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_multisig_aggregated_signature_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_multisig_aggregated_signature_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_multisig_committee_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_multisig_committee_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_multisig_committee_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_multisig_committee_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_multisig_member_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_multisig_member_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_multisig_member_public_key_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_multisig_member_public_key_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_multisig_member_public_key_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_multisig_member_public_key_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_multisig_member_signature_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_multisig_member_signature_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_multisig_member_signature_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_multisig_member_signature_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_multisig_member_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_multisig_member_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_object_data_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_object_data_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_object_data_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_object_data_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_object_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_object_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_object_id_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_object_id_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_object_id_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_object_id_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_object_in_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_object_in_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_object_in_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_object_in_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_object_out_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_object_out_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_object_out_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_object_out_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_object_reference_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_object_reference_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_object_reference_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_object_reference_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_object_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_object_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_owner_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_owner_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_owner_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_owner_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_package_upgrade_error_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_package_upgrade_error_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_package_upgrade_error_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_package_upgrade_error_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_passkey_authenticator_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_passkey_authenticator_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_passkey_authenticator_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_passkey_authenticator_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_programmable_transaction_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_programmable_transaction_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_programmable_transaction_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_programmable_transaction_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_publish_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_publish_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_publish_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_publish_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_randomness_state_update_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_randomness_state_update_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_randomness_state_update_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_randomness_state_update_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_secp256k1_public_key_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_secp256k1_public_key_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_secp256k1_public_key_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_secp256k1_public_key_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_secp256k1_signature_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_secp256k1_signature_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_secp256k1_signature_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_secp256k1_signature_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_secp256r1_public_key_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_secp256r1_public_key_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_secp256r1_public_key_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_secp256r1_public_key_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_secp256r1_signature_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_secp256r1_signature_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_secp256r1_signature_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_secp256r1_signature_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_signed_transaction_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_signed_transaction_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_signed_transaction_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_signed_transaction_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_simple_signature_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_simple_signature_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_simple_signature_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_simple_signature_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_split_coins_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_split_coins_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_split_coins_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_split_coins_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_string_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_string_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_string_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_string_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_struct_tag_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_struct_tag_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_struct_tag_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_struct_tag_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_system_package_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_system_package_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_system_package_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_system_package_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_effects_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_effects_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_effects_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_effects_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_effects_v1_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_effects_v1_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_effects_v1_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_effects_v1_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_events_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_events_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_events_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_events_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_expiration_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_expiration_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_expiration_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_expiration_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_kind_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_kind_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_kind_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_kind_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_v1_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_v1_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_v1_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transaction_v1_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transfer_objects_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transfer_objects_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transfer_objects_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_transfer_objects_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_type_argument_error_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_type_argument_error_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_type_argument_error_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_type_argument_error_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_type_origin_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_type_origin_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_type_origin_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_type_origin_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_type_tag_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_type_tag_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_type_tag_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_type_tag_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_u16_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_u16_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_u16_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_u16_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_u32_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_u32_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_u32_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_u32_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_u64_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_u64_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_u64_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_u64_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_u8_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_u8_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_u8_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_u8_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_unchanged_shared_kind_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_unchanged_shared_kind_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_unchanged_shared_kind_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_unchanged_shared_kind_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_unchanged_shared_object_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_unchanged_shared_object_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_unchanged_shared_object_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_unchanged_shared_object_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_upgrade_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_upgrade_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_upgrade_info_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_upgrade_info_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_upgrade_info_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_upgrade_info_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_upgrade_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_upgrade_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_user_signature_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_user_signature_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_user_signature_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_user_signature_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_validator_aggregated_signature_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_validator_aggregated_signature_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_validator_aggregated_signature_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_validator_aggregated_signature_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_validator_committee_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_validator_committee_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_validator_committee_member_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_validator_committee_member_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_validator_committee_member_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_validator_committee_member_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_validator_committee_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_validator_committee_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_validator_execution_time_observation_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_validator_execution_time_observation_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_validator_execution_time_observation_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_validator_execution_time_observation_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_validator_signature_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_validator_signature_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_validator_signature_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_validator_signature_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_version_assignment_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_version_assignment_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_version_assignment_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_version_assignment_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_zk_login_authenticator_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_zk_login_authenticator_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_zk_login_authenticator_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_zk_login_authenticator_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_zk_login_claim_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_zk_login_claim_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_zk_login_claim_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_zk_login_claim_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_zk_login_proof_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_zk_login_proof_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_zk_login_proof_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_zk_login_proof_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_zk_login_public_identifier_from_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_zk_login_public_identifier_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_zk_login_public_identifier_to_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_func_zk_login_public_identifier_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_address_to_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_address_to_canonical_string: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_address_to_hex: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_address_to_short_string: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_argument_get_nested_result: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_bls12381privatekey_public_key: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_bls12381privatekey_scheme: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_bls12381privatekey_sign_checkpoint_summary: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_bls12381privatekey_try_sign: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_bls12381privatekey_verifying_key: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_bls12381publickey_to_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_bls12381signature_to_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_bls12381verifyingkey_public_key: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_bls12381verifyingkey_verify: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_bn254fieldelement_padded: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_bn254fieldelement_unpadded: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_cancelledtransaction_digest: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_cancelledtransaction_version_assignments: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepoch_computation_charge: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepoch_epoch: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepoch_epoch_start_timestamp_ms: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepoch_non_refundable_storage_fee: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepoch_protocol_version: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepoch_storage_charge: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepoch_storage_rebate: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepoch_system_packages: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv2_computation_charge: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv2_computation_charge_burned: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv2_epoch: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv2_epoch_start_timestamp_ms: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv2_non_refundable_storage_fee: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv2_protocol_version: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv2_storage_charge: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv2_storage_rebate: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv2_system_packages: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv3_computation_charge: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv3_computation_charge_burned: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv3_eligible_active_validators: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv3_epoch: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv3_epoch_start_timestamp_ms: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv3_non_refundable_storage_fee: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv3_protocol_version: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv3_storage_charge: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv3_storage_rebate: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv3_system_packages: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv4_adjust_rewards_by_score: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv4_computation_charge: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv4_computation_charge_burned: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv4_eligible_active_validators: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv4_epoch: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv4_epoch_start_timestamp_ms: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv4_non_refundable_storage_fee: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv4_protocol_version: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv4_scores: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv4_storage_charge: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv4_storage_rebate: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_changeepochv4_system_packages: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_checkpointcommitment_as_ecmh_live_object_set_digest: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_checkpointcommitment_is_ecmh_live_object_set: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_checkpointcontents_digest: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_checkpointcontents_transaction_info: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_checkpointsummary_checkpoint_commitments: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_checkpointsummary_content_digest: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_checkpointsummary_digest: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_checkpointsummary_end_of_epoch_data: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_checkpointsummary_epoch: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_checkpointsummary_epoch_rolling_gas_cost_summary: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_checkpointsummary_network_total_transactions: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_checkpointsummary_previous_digest: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_checkpointsummary_sequence_number: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_checkpointsummary_signing_message: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_checkpointsummary_signing_message_hex: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_checkpointsummary_timestamp_ms: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_checkpointsummary_version_specific_data: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_checkpointtransactioninfo_effects: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_checkpointtransactioninfo_signatures: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_checkpointtransactioninfo_transaction: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_dry_run: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_execute: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_execute_with_sponsor: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_expiration: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_finish: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_gas: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_gas_budget: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_gas_price: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_gas_station_sponsor: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_make_move_vec: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_merge_coins: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_move_call: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_publish: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_send_coins: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_send_iota: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_set_sender: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_split_coins: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_sponsor: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_stake: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_transfer_objects: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_unstake: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_upgrade: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_coin_balance: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_coin_coin_type: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_coin_id: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_consensuscommitprologuev1_commit_timestamp_ms: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_consensuscommitprologuev1_consensus_commit_digest: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_consensuscommitprologuev1_consensus_determined_version_assignments: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_consensuscommitprologuev1_epoch: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_consensuscommitprologuev1_round: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_consensuscommitprologuev1_sub_dag_index: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_consensusdeterminedversionassignments_as_cancelled_transactions: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_consensusdeterminedversionassignments_is_cancelled_transactions: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_digest_next_lexicographical: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_digest_to_base58: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_digest_to_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_ed25519privatekey_public_key: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_ed25519privatekey_scheme: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_ed25519privatekey_sign_personal_message: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_ed25519privatekey_sign_transaction: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_ed25519privatekey_to_bech32: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_ed25519privatekey_to_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_ed25519privatekey_to_der: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_ed25519privatekey_to_pem: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_ed25519privatekey_try_sign: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_ed25519privatekey_try_sign_simple: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_ed25519privatekey_try_sign_user: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_ed25519privatekey_verifying_key: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_ed25519publickey_derive_address: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_ed25519publickey_scheme: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_ed25519publickey_to_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_ed25519publickey_to_flagged_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_ed25519signature_to_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_ed25519verifier_verify_simple: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_ed25519verifier_verify_user: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_ed25519verifyingkey_public_key: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_ed25519verifyingkey_to_der: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_ed25519verifyingkey_to_pem: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_ed25519verifyingkey_verify: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_ed25519verifyingkey_verify_simple: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_ed25519verifyingkey_verify_user: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_executiontimeobservation_key: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_executiontimeobservation_observations: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_faucetclient_request: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_faucetclient_request_and_wait: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_faucetclient_request_and_wait_for_finalized: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_faucetclient_request_status: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_genesisobject_data: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_genesisobject_object_id: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_genesisobject_object_type: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_genesisobject_owner: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_genesisobject_version: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_genesistransaction_events: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_genesistransaction_objects: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_active_validators: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_balance: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_chain_id: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_checkpoint: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_checkpoints: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_coin_metadata: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_coins: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_dry_run_tx: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_dry_run_tx_kind: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_dynamic_field: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_dynamic_fields: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_dynamic_object_field: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_epoch: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_epoch_total_checkpoints: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_epoch_total_transaction_blocks: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_events: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_execute_tx: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_gas_coins: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_iota_names_default_name: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_iota_names_lookup: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_iota_names_registrations: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_is_tx_finalized: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_is_tx_indexed_on_node: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_latest_checkpoint_sequence_number: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_max_page_size: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_move_object_contents: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_move_object_contents_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_move_view_call: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_move_view_call_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_normalized_move_function: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_normalized_move_module: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_object: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_object_bcs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_objects: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_package: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_package_latest: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_package_versions: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_packages: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_protocol_config: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_reference_gas_price: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_run_query: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_service_config: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_set_rpc_server: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_total_supply: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_total_transaction_blocks: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_total_transaction_blocks_by_digest: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_total_transaction_blocks_by_seq_num: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_transaction: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_transaction_data_effects: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_transaction_effects: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_transactions: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_transactions_data_effects: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_transactions_effects: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_wait_for_tx: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_identifier_as_str: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_intent_app_id: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_intent_scope: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_intent_to_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_intent_version: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_makemovevector_elements: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_makemovevector_type_tag: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_mergecoins_coin: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_mergecoins_coins_to_merge: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_moveauthenticator_address: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_moveauthenticator_call_args: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_moveauthenticator_object_to_authenticate: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_moveauthenticator_type_args: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_moveauthenticatorbuilder_finish: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_movecall_arguments: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_movecall_function: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_movecall_module: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_movecall_package: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_movecall_type_arguments: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_movefunction_is_entry: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_movefunction_name: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_movefunction_parameters: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_movefunction_return_type: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_movefunction_type_parameters: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_movefunction_visibility: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_movepackage_id: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_movepackage_linkage_table: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_movepackage_modules: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_movepackage_type_origin_table: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_movepackage_version: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_movepackagedata_dependencies: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_movepackagedata_digest: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_movepackagedata_modules: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_movepackagedata_to_base64: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_movepackagedata_to_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigaggregatedsignature_bitmap: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigaggregatedsignature_committee: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigaggregatedsignature_signatures: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigaggregator_finish: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigaggregator_verifier: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigaggregator_with_signature: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigaggregator_with_verifier: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigcommittee_derive_address: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigcommittee_is_valid: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigcommittee_members: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigcommittee_scheme: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigcommittee_threshold: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmember_public_key: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmember_weight: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_ed25519: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_ed25519_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_secp256k1: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_secp256k1_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_secp256r1: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_secp256r1_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_zklogin: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_zklogin_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_is_ed25519: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_is_secp256k1: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_is_secp256r1: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_is_zklogin: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_scheme: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_ed25519: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_ed25519_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_secp256k1: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_secp256k1_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_secp256r1: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_secp256r1_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_zklogin: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_zklogin_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_is_ed25519: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_is_secp256k1: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_is_secp256r1: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_is_zklogin: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigverifier_verify: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigverifier_with_zklogin_verifier: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_multisigverifier_zklogin_verifier: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_name_format: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_name_is_sln: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_name_is_subname: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_name_label: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_name_labels: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_name_num_labels: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_name_parent: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_nameregistration_expiration_timestamp_ms: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_nameregistration_id: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_nameregistration_name: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_nameregistration_name_str: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_object_as_package: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_object_as_package_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_object_as_struct: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_object_as_struct_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_object_data: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_object_digest: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_object_object_id: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_object_object_ref: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_object_object_type: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_object_owner: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_object_previous_transaction: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_object_storage_rebate: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_object_version: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_objectdata_as_package_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_objectdata_as_struct_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_objectdata_is_package: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_objectdata_is_struct: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_objectid_derive_dynamic_child_id: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_objectid_to_address: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_objectid_to_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_objectid_to_canonical_string: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_objectid_to_hex: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_objectid_to_short_string: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_objecttype_as_struct: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_objecttype_as_struct_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_objecttype_is_package: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_objecttype_is_struct: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_owner_as_address: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_owner_as_address_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_owner_as_object: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_owner_as_object_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_owner_as_shared: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_owner_as_shared_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_owner_is_address: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_owner_is_immutable: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_owner_is_object: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_owner_is_shared: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_passkeyauthenticator_authenticator_data: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_passkeyauthenticator_challenge: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_passkeyauthenticator_client_data_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_passkeyauthenticator_public_key: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_passkeyauthenticator_signature: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_passkeypublickey_derive_address: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_passkeypublickey_inner: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_passkeyverifier_verify: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_personalmessage_message_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_personalmessage_signing_digest: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_personalmessage_signing_digest_hex: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_programmabletransaction_commands: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_programmabletransaction_inputs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_publish_dependencies: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_publish_modules: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256k1privatekey_public_key: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256k1privatekey_scheme: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256k1privatekey_sign_personal_message: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256k1privatekey_sign_transaction: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256k1privatekey_to_bech32: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256k1privatekey_to_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256k1privatekey_to_der: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256k1privatekey_to_pem: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256k1privatekey_try_sign: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256k1privatekey_try_sign_simple: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256k1privatekey_try_sign_user: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256k1privatekey_verifying_key: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256k1publickey_derive_address: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256k1publickey_scheme: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256k1publickey_to_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256k1publickey_to_flagged_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256k1signature_to_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256k1verifier_verify_simple: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256k1verifier_verify_user: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256k1verifyingkey_public_key: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256k1verifyingkey_to_der: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256k1verifyingkey_to_pem: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256k1verifyingkey_verify: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256k1verifyingkey_verify_simple: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256k1verifyingkey_verify_user: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256r1privatekey_public_key: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256r1privatekey_scheme: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256r1privatekey_sign_personal_message: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256r1privatekey_sign_transaction: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256r1privatekey_to_bech32: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256r1privatekey_to_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256r1privatekey_to_der: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256r1privatekey_to_pem: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256r1privatekey_try_sign: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256r1privatekey_try_sign_simple: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256r1privatekey_try_sign_user: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256r1privatekey_verifying_key: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256r1publickey_derive_address: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256r1publickey_scheme: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256r1publickey_to_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256r1publickey_to_flagged_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256r1signature_to_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256r1verifier_verify_simple: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256r1verifier_verify_user: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256r1verifyingkey_public_key: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256r1verifyingkey_to_der: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256r1verifyingkey_to_pem: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256r1verifyingkey_verify: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256r1verifyingkey_verify_simple: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_secp256r1verifyingkey_verify_user: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplekeypair_public_key: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplekeypair_scheme: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplekeypair_sign_personal_message: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplekeypair_sign_transaction: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplekeypair_to_bech32: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplekeypair_to_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplekeypair_to_der: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplekeypair_to_pem: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplekeypair_try_sign: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplekeypair_try_sign_user: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplekeypair_verifying_key: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_ed25519_pub_key: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_ed25519_pub_key_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_ed25519_sig: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_ed25519_sig_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_is_ed25519: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_is_secp256k1: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_is_secp256r1: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_scheme: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256k1_pub_key: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256k1_pub_key_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256k1_sig: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256k1_sig_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256r1_pub_key: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256r1_pub_key_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256r1_sig: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256r1_sig_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_to_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simpleverifier_verify: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simpleverifyingkey_public_key: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simpleverifyingkey_scheme: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simpleverifyingkey_to_der: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simpleverifyingkey_to_pem: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_simpleverifyingkey_verify: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_splitcoins_amounts: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_splitcoins_coin: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_structtag_address: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_structtag_coin_type: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_structtag_coin_type_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_structtag_module: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_structtag_name: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_structtag_to_canonical_string: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_structtag_type_args: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_systempackage_dependencies: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_systempackage_modules: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_systempackage_version: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transaction_as_v1: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transaction_digest: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transaction_expiration: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transaction_gas_payment: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transaction_kind: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transaction_sender: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transaction_signing_digest: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transaction_signing_digest_hex: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transaction_to_base64: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_execute_with_gas_station: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_expiration: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_finish: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_gas: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_gas_budget: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_gas_price: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_gas_station_sponsor: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_make_move_vec: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_merge_coins: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_move_call: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_publish: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_send_coins: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_send_iota: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_set_sender: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_split_coins: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_sponsor: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_stake: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_transfer_objects: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_unstake: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_upgrade: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_with_client: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactioneffects_as_v1: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactioneffects_digest: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactioneffects_is_v1: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionevents_digest: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionevents_events: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionsigner_sign: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionsignerfn_sign: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionv1_digest: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionv1_expiration: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionv1_gas_payment: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionv1_kind: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionv1_sender: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionv1_signing_digest: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionv1_signing_digest_hex: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transactionv1_to_base64: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transferobjects_address: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_transferobjects_objects: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_typetag_as_struct_tag: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_typetag_as_struct_tag_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_typetag_as_vector_type_tag: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_typetag_as_vector_type_tag_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_typetag_is_address: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_typetag_is_bool: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_typetag_is_signer: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_typetag_is_struct: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_typetag_is_u128: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_typetag_is_u16: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_typetag_is_u256: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_typetag_is_u32: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_typetag_is_u64: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_typetag_is_u8: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_typetag_is_vector: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_typetag_to_canonical_string: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_upgrade_dependencies: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_upgrade_modules: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_upgrade_package: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_upgrade_ticket: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_upgradepolicy_as_u8: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_usersignature_as_move_authenticator: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_usersignature_as_move_authenticator_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_usersignature_as_multisig: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_usersignature_as_multisig_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_usersignature_as_passkey_authenticator: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_usersignature_as_passkey_authenticator_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_usersignature_as_simple: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_usersignature_as_simple_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_usersignature_as_zklogin_authenticator: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_usersignature_as_zklogin_authenticator_opt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_usersignature_is_move_authenticator: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_usersignature_is_multisig: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_usersignature_is_passkey_authenticator: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_usersignature_is_simple: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_usersignature_is_zklogin_authenticator: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_usersignature_scheme: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_usersignature_to_base64: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_usersignature_to_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_usersignatureverifier_verify: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_usersignatureverifier_with_zklogin_verifier: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_usersignatureverifier_zklogin_verifier: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_validatoraggregatedsignature_bitmap_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_validatoraggregatedsignature_epoch: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_validatoraggregatedsignature_signature: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_validatorcommitteesignatureaggregator_add_signature: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_validatorcommitteesignatureaggregator_committee: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_validatorcommitteesignatureaggregator_finish: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_validatorcommitteesignatureverifier_committee: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_validatorcommitteesignatureverifier_verify: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_validatorcommitteesignatureverifier_verify_aggregated: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_validatorcommitteesignatureverifier_verify_checkpoint_summary: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_validatorexecutiontimeobservation_duration: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_validatorexecutiontimeobservation_validator: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_validatorsignature_epoch: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_validatorsignature_public_key: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_validatorsignature_signature: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_versionassignment_object_id: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_versionassignment_version: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_zkloginauthenticator_inputs: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_zkloginauthenticator_max_epoch: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_zkloginauthenticator_signature: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_zklogininputs_address_seed: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_zklogininputs_header_base64: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_zklogininputs_iss: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_zklogininputs_iss_base64_details: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_zklogininputs_jwk_id: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_zklogininputs_proof_points: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_zklogininputs_public_identifier: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_zkloginproof_a: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_zkloginproof_b: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_zkloginproof_c: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_zkloginpublicidentifier_address_seed: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_zkloginpublicidentifier_derive_address: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_zkloginpublicidentifier_derive_address_padded: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_zkloginpublicidentifier_derive_address_unpadded: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_zkloginpublicidentifier_iss: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_zkloginverifier_jwks: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_zkloginverifier_verify: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_method_zkloginverifier_with_jwks: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_address_framework: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_address_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_address_from_hex: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_address_generate: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_address_std: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_address_system: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_address_zero: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_argument_new_gas: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_argument_new_input: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_argument_new_nested_result: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_argument_new_result: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_bls12381privatekey_generate: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_bls12381privatekey_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_bls12381publickey_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_bls12381publickey_from_str: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_bls12381publickey_generate: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_bls12381signature_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_bls12381signature_from_str: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_bls12381signature_generate: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_bls12381verifyingkey_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_bn254fieldelement_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_bn254fieldelement_from_str: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_bn254fieldelement_from_str_radix_10: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_cancelledtransaction_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_changeepoch_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_changeepochv2_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_changeepochv3_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_changeepochv4_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_checkpointcontents_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_checkpointsummary_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_checkpointtransactioninfo_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_circomg1_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_circomg2_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_coin_try_from_object: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_command_new_make_move_vector: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_command_new_merge_coins: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_command_new_move_call: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_command_new_publish: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_command_new_split_coins: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_command_new_transfer_objects: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_command_new_upgrade: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_consensuscommitprologuev1_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_consensusdeterminedversionassignments_new_cancelled_transactions: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_digest_from_base58: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_digest_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_digest_generate: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519privatekey_from_bech32: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519privatekey_from_der: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519privatekey_from_mnemonic: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519privatekey_from_mnemonic_with_path: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519privatekey_from_pem: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519privatekey_generate: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519privatekey_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519publickey_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519publickey_from_str: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519publickey_generate: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519signature_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519signature_from_str: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519signature_generate: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519verifier_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519verifyingkey_from_der: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519verifyingkey_from_pem: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519verifyingkey_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_endofepochtransactionkind_new_authenticator_state_create: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_endofepochtransactionkind_new_authenticator_state_expire: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_endofepochtransactionkind_new_change_epoch: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_endofepochtransactionkind_new_change_epoch_v2: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_endofepochtransactionkind_new_change_epoch_v3: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_endofepochtransactionkind_new_change_epoch_v4: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservation_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_make_move_vec: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_merge_coins: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_move_entry_point: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_publish: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_split_coins: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_transfer_objects: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_upgrade: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservations_new_v1: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_faucetclient_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_faucetclient_new_devnet: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_faucetclient_new_localnet: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_faucetclient_new_testnet: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_genesisobject_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_genesistransaction_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_graphqlclient_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_graphqlclient_new_devnet: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_graphqlclient_new_localnet: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_graphqlclient_new_mainnet: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_graphqlclient_new_testnet: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_identifier_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_input_new_immutable_or_owned: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_input_new_pure: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_input_new_receiving: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_input_new_shared: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_intent_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_intent_from_hex: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_intent_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_intent_new_consensus_app: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_intent_new_iota_app: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_intent_new_iota_transaction: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_intent_new_personal_message: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_makemovevector_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_mergecoins_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_address: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_address_from_hex: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_address_vec: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_address_vec_from_hex: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_bool: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_bool_vec: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_digest: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_digest_from_base58: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_digest_vec: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_digest_vec_from_base58: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_option: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_string: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_string_vec: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_u128: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_u128_vec: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_u16: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_u16_vec: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_u256: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_u256_vec: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_u32: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_u32_vec: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_u64: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_u64_vec: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_u8: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_u8_vec: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_moveauthenticator_new_immutable: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_moveauthenticator_new_shared: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_moveauthenticatorbuilder_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movecall_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movepackage_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movepackagedata_from_base64: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movepackagedata_from_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_movepackagedata_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_address: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_bool: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_json: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_null: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_object_id: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_option: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_string: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_string_vec: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_u128: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_u16: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_u32: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_u64: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_u8: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_u8_vec: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_multisigaggregatedsignature_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_multisigaggregator_new_with_message: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_multisigaggregator_new_with_transaction: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_multisigcommittee_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_multisigmember_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_multisigverifier_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_name_from_str: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_nameregistration_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_object_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_objectdata_new_move_package: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_objectdata_new_move_struct: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_objectid_clock: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_objectid_derive_id: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_objectid_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_objectid_from_hex: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_objectid_system: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_objectid_zero: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_objecttype_new_package: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_objecttype_new_struct: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_owner_new_address: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_owner_new_immutable: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_owner_new_object: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_owner_new_shared: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_address: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_address_from_hex: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_address_vec: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_address_vec_from_hex: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_assigned: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_bool: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_bool_vec: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_digest: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_digest_from_base58: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_digest_vec: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_digest_vec_from_base58: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_gas: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_move_arg: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_object_id: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_object_id_from_hex: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_object_ref: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_option: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_receiving: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_receiving_from_hex: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_shared: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_shared_from_hex: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_shared_mut: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_shared_mut_from_hex: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_string: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_u128: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_u128_vec: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_u16: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_u16_vec: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_u256: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_u256_vec: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_u32: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_u32_vec: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_u64: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_u64_vec: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_u8: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_u8_vec: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_passkeypublickey_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_passkeyverifier_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_personalmessage_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_programmabletransaction_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_publish_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1privatekey_from_bech32: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1privatekey_from_der: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1privatekey_from_mnemonic: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1privatekey_from_mnemonic_with_path: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1privatekey_from_pem: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1privatekey_generate: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1privatekey_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1publickey_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1publickey_from_str: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1publickey_generate: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1signature_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1signature_from_str: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1signature_generate: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1verifier_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1verifyingkey_from_der: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1verifyingkey_from_pem: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1verifyingkey_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1privatekey_from_bech32: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1privatekey_from_der: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1privatekey_from_mnemonic: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1privatekey_from_mnemonic_with_path: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1privatekey_from_pem: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1privatekey_generate: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1privatekey_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1publickey_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1publickey_from_str: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1publickey_generate: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1signature_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1signature_from_str: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1signature_generate: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1verifier_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1verifyingkey_from_der: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1verifyingkey_from_pem: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1verifyingkey_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_simplekeypair_from_bech32: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_simplekeypair_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_simplekeypair_from_der: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_simplekeypair_from_ed25519: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_simplekeypair_from_pem: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_simplekeypair_from_secp256k1: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_simplekeypair_from_secp256r1: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_simplesignature_new_ed25519: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_simplesignature_new_secp256k1: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_simplesignature_new_secp256r1: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_simpleverifier_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_simpleverifyingkey_from_der: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_simpleverifyingkey_from_pem: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_splitcoins_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_ascii_string: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_balance: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_clock: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_coin: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_coin_manager: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_coin_metadata: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_config: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_config_setting: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_deny_list_address_key: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_deny_list_config_key: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_deny_list_global_pause_key: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_display_created: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_dynamic_object_field_wrapper: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_field: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_gas_coin: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_id: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_iota_coin_type: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_iota_system_admin_cap: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_iota_system_state: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_iota_treasury_cap: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_name: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_staked_iota: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_string: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_system_epoch_info_event: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_time_lock: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_timelocked_staked_iota: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_transfer_receiving: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_treasury_cap: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_uid: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_upgrade_cap: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_upgrade_receipt: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_upgrade_ticket: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_version_updated: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_systempackage_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_transaction_from_base64: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_transaction_new_v1: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_transactionbuilder_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_transactioneffects_new_v1: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_transactionevents_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_transactionkind_new_authenticator_state_update_v1: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_transactionkind_new_consensus_commit_prologue_v1: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_transactionkind_new_end_of_epoch: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_transactionkind_new_genesis: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_transactionkind_new_programmable_transaction: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_transactionkind_new_randomness_state_update: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_transactionsigner_from_ed25519: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_transactionsigner_from_keypair: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_transactionsigner_from_move_authenticator: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_transactionsigner_from_secp256k1: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_transactionsigner_from_secp256r1: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_transactionsigner_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_transactionv1_from_base64: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_transactionv1_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_transferobjects_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_typetag_new_address: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_typetag_new_bool: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_typetag_new_signer: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_typetag_new_struct: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_typetag_new_u128: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_typetag_new_u16: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_typetag_new_u256: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_typetag_new_u32: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_typetag_new_u64: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_typetag_new_u8: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_typetag_new_vector: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_upgrade_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_upgradepolicy_additive: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_upgradepolicy_compatible: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_upgradepolicy_dep_only: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_usersignature_from_base64: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_usersignature_from_bytes: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_usersignature_new_move_authenticator: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_usersignature_new_multisig: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_usersignature_new_passkey_authenticator: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_usersignature_new_simple: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_usersignature_new_zklogin_authenticator: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_usersignatureverifier_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_validatoraggregatedsignature_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_validatorcommitteesignatureaggregator_new_checkpoint_summary: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_validatorcommitteesignatureverifier_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_validatorexecutiontimeobservation_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_validatorsignature_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_versionassignment_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_zkloginauthenticator_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_zklogininputs_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_zkloginproof_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_zkloginpublicidentifier_new: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_zkloginverifier_new_dev: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + uniffi_iota_sdk_ffi_checksum_constructor_zkloginverifier_new_mainnet: { + library: "libiota_sdk_ffi", + retType:/* u16 */ DataType.I32, + paramsType: [ + ], + }, + ffi_iota_sdk_ffi_uniffi_contract_version: { + library: "libiota_sdk_ffi", + retType:/* u32 */ DataType.I32, + paramsType: [ + ], + }, +}) as unknown as { + RustFutureContinuationCallback: (args: [ + /* data */ bigint, + /* poll_result */ number + ]) => + void, + ForeignFutureFree: (args: [ + /* handle */ bigint + ]) => + void, + CallbackInterfaceFree: (args: [ + /* handle */ bigint + ]) => + void, + ForeignFutureCompleteU8: (args: [ + /* callback_data */ bigint, + /* result */ UniffiForeignFutureStructU8 + ]) => + void, + ForeignFutureCompleteI8: (args: [ + /* callback_data */ bigint, + /* result */ UniffiForeignFutureStructI8 + ]) => + void, + ForeignFutureCompleteU16: (args: [ + /* callback_data */ bigint, + /* result */ UniffiForeignFutureStructU16 + ]) => + void, + ForeignFutureCompleteI16: (args: [ + /* callback_data */ bigint, + /* result */ UniffiForeignFutureStructI16 + ]) => + void, + ForeignFutureCompleteU32: (args: [ + /* callback_data */ bigint, + /* result */ UniffiForeignFutureStructU32 + ]) => + void, + ForeignFutureCompleteI32: (args: [ + /* callback_data */ bigint, + /* result */ UniffiForeignFutureStructI32 + ]) => + void, + ForeignFutureCompleteU64: (args: [ + /* callback_data */ bigint, + /* result */ UniffiForeignFutureStructU64 + ]) => + void, + ForeignFutureCompleteI64: (args: [ + /* callback_data */ bigint, + /* result */ UniffiForeignFutureStructI64 + ]) => + void, + ForeignFutureCompleteF32: (args: [ + /* callback_data */ bigint, + /* result */ UniffiForeignFutureStructF32 + ]) => + void, + ForeignFutureCompleteF64: (args: [ + /* callback_data */ bigint, + /* result */ UniffiForeignFutureStructF64 + ]) => + void, + ForeignFutureCompletePointer: (args: [ + /* callback_data */ bigint, + /* result */ UniffiForeignFutureStructPointer + ]) => + void, + ForeignFutureCompleteRustBuffer: (args: [ + /* callback_data */ bigint, + /* result */ UniffiForeignFutureStructRustBuffer + ]) => + void, + ForeignFutureCompleteVoid: (args: [ + /* callback_data */ bigint, + /* result */ UniffiForeignFutureStructVoid + ]) => + void, + CallbackInterfaceTransactionSignerFnMethod0: (args: [ + /* uniffi_handle */ bigint, + /* transaction */ /* RustArcPtr */ bigint, + /* uniffi_future_callback */ /* callback UniffiCallbackForeignFutureCompleteRustBuffer */ JsExternal, + /* uniffi_callback_data */ bigint, + /* uniffi_out_return */ /* MutReference to UniffiForeignFuture */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_clone_address: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_address: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_address_framework: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_address_from_bytes: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_address_from_hex: (args: [ + /* hex */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_address_generate: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_address_std: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_address_system: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_address_zero: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_address_to_bytes: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_address_to_canonical_string: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* with_prefix */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_address_to_hex: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_address_to_short_string: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* with_prefix */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_address_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_address_uniffi_trait_display: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_address_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_address_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_address_uniffi_trait_hash: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_clone_argument: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_argument: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_argument_new_gas: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_argument_new_input: (args: [ + /* input */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_argument_new_nested_result: (args: [ + /* command_index */ number, + /* subresult_index */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_argument_new_result: (args: [ + /* result */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_argument_get_nested_result: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* ix */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_argument_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_argument_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_argument_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_bls12381privatekey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_bls12381privatekey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_bls12381privatekey_generate: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_bls12381privatekey_new: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_bls12381privatekey_public_key: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_bls12381privatekey_scheme: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_bls12381privatekey_sign_checkpoint_summary: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* summary */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_bls12381privatekey_try_sign: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_bls12381privatekey_verifying_key: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_clone_bls12381publickey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_bls12381publickey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_bls12381publickey_from_bytes: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_bls12381publickey_from_str: (args: [ + /* s */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_bls12381publickey_generate: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_bls12381publickey_to_bytes: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_bls12381publickey_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_bls12381publickey_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_bls12381publickey_uniffi_trait_hash: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_clone_bls12381signature: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_bls12381signature: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_bls12381signature_from_bytes: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_bls12381signature_from_str: (args: [ + /* s */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_bls12381signature_generate: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_bls12381signature_to_bytes: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_bls12381signature_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_bls12381signature_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_bls12381signature_uniffi_trait_hash: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_clone_bls12381verifyingkey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_bls12381verifyingkey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_bls12381verifyingkey_new: (args: [ + /* public_key */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_bls12381verifyingkey_public_key: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_bls12381verifyingkey_verify: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_bls12381verifyingkey_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_clone_bn254fieldelement: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_bn254fieldelement: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_bn254fieldelement_from_bytes: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_bn254fieldelement_from_str: (args: [ + /* s */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_bn254fieldelement_from_str_radix_10: (args: [ + /* s */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_bn254fieldelement_padded: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_bn254fieldelement_unpadded: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_bn254fieldelement_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_bn254fieldelement_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_bn254fieldelement_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_cancelledtransaction: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_cancelledtransaction: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_cancelledtransaction_new: (args: [ + /* digest */ /* RustArcPtr */ bigint, + /* version_assignments */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_cancelledtransaction_digest: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_cancelledtransaction_version_assignments: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_cancelledtransaction_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_cancelledtransaction_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_cancelledtransaction_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_changeepoch: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_changeepoch: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_changeepoch_new: (args: [ + /* epoch */ bigint, + /* protocol_version */ bigint, + /* storage_charge */ bigint, + /* computation_charge */ bigint, + /* storage_rebate */ bigint, + /* non_refundable_storage_fee */ bigint, + /* epoch_start_timestamp_ms */ bigint, + /* system_packages */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_changeepoch_computation_charge: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepoch_epoch: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepoch_epoch_start_timestamp_ms: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepoch_non_refundable_storage_fee: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepoch_protocol_version: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepoch_storage_charge: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepoch_storage_rebate: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepoch_system_packages: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_changeepoch_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_changeepoch_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_changeepoch_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_changeepochv2: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_changeepochv2: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_changeepochv2_new: (args: [ + /* epoch */ bigint, + /* protocol_version */ bigint, + /* storage_charge */ bigint, + /* computation_charge */ bigint, + /* computation_charge_burned */ bigint, + /* storage_rebate */ bigint, + /* non_refundable_storage_fee */ bigint, + /* epoch_start_timestamp_ms */ bigint, + /* system_packages */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv2_computation_charge: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv2_computation_charge_burned: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv2_epoch: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv2_epoch_start_timestamp_ms: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv2_non_refundable_storage_fee: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv2_protocol_version: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv2_storage_charge: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv2_storage_rebate: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv2_system_packages: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_changeepochv2_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_changeepochv2_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_changeepochv2_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_changeepochv3: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_changeepochv3: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_changeepochv3_new: (args: [ + /* epoch */ bigint, + /* protocol_version */ bigint, + /* storage_charge */ bigint, + /* computation_charge */ bigint, + /* computation_charge_burned */ bigint, + /* storage_rebate */ bigint, + /* non_refundable_storage_fee */ bigint, + /* epoch_start_timestamp_ms */ bigint, + /* system_packages */ /* RustBuffer */ UniffiRustBufferStruct, + /* eligible_active_validators */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv3_computation_charge: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv3_computation_charge_burned: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv3_eligible_active_validators: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_changeepochv3_epoch: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv3_epoch_start_timestamp_ms: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv3_non_refundable_storage_fee: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv3_protocol_version: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv3_storage_charge: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv3_storage_rebate: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv3_system_packages: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_changeepochv3_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_changeepochv3_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_changeepochv3_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_changeepochv4: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_changeepochv4: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_changeepochv4_new: (args: [ + /* epoch */ bigint, + /* protocol_version */ bigint, + /* storage_charge */ bigint, + /* computation_charge */ bigint, + /* computation_charge_burned */ bigint, + /* storage_rebate */ bigint, + /* non_refundable_storage_fee */ bigint, + /* epoch_start_timestamp_ms */ bigint, + /* system_packages */ /* RustBuffer */ UniffiRustBufferStruct, + /* eligible_active_validators */ /* RustBuffer */ UniffiRustBufferStruct, + /* scores */ /* RustBuffer */ UniffiRustBufferStruct, + /* adjust_rewards_by_score */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv4_adjust_rewards_by_score: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_changeepochv4_computation_charge: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv4_computation_charge_burned: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv4_eligible_active_validators: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_changeepochv4_epoch: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv4_epoch_start_timestamp_ms: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv4_non_refundable_storage_fee: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv4_protocol_version: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv4_scores: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_changeepochv4_storage_charge: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv4_storage_rebate: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_changeepochv4_system_packages: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_clone_checkpointcommitment: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_checkpointcommitment: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_checkpointcommitment_as_ecmh_live_object_set_digest: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_checkpointcommitment_is_ecmh_live_object_set: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_checkpointcontents: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_checkpointcontents: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_checkpointcontents_new: (args: [ + /* transaction_info */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_checkpointcontents_digest: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_checkpointcontents_transaction_info: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_clone_checkpointsummary: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_checkpointsummary: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_checkpointsummary_new: (args: [ + /* epoch */ bigint, + /* sequence_number */ bigint, + /* network_total_transactions */ bigint, + /* content_digest */ /* RustArcPtr */ bigint, + /* previous_digest */ /* RustBuffer */ UniffiRustBufferStruct, + /* epoch_rolling_gas_cost_summary */ /* RustBuffer */ UniffiRustBufferStruct, + /* timestamp_ms */ bigint, + /* checkpoint_commitments */ /* RustBuffer */ UniffiRustBufferStruct, + /* end_of_epoch_data */ /* RustBuffer */ UniffiRustBufferStruct, + /* version_specific_data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_checkpointsummary_checkpoint_commitments: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_checkpointsummary_content_digest: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_checkpointsummary_digest: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_checkpointsummary_end_of_epoch_data: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_checkpointsummary_epoch: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_checkpointsummary_epoch_rolling_gas_cost_summary: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_checkpointsummary_network_total_transactions: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_checkpointsummary_previous_digest: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_checkpointsummary_sequence_number: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_checkpointsummary_signing_message: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_checkpointsummary_signing_message_hex: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_checkpointsummary_timestamp_ms: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_checkpointsummary_version_specific_data: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_clone_checkpointtransactioninfo: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_checkpointtransactioninfo: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_checkpointtransactioninfo_new: (args: [ + /* transaction */ /* RustArcPtr */ bigint, + /* effects */ /* RustArcPtr */ bigint, + /* signatures */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_checkpointtransactioninfo_effects: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_checkpointtransactioninfo_signatures: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_checkpointtransactioninfo_transaction: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_clone_circomg1: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_circomg1: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_circomg1_new: (args: [ + /* el_0 */ /* RustArcPtr */ bigint, + /* el_1 */ /* RustArcPtr */ bigint, + /* el_2 */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_circomg1_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_circomg1_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_circomg1_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_circomg2: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_circomg2: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_circomg2_new: (args: [ + /* el_0_0 */ /* RustArcPtr */ bigint, + /* el_0_1 */ /* RustArcPtr */ bigint, + /* el_1_0 */ /* RustArcPtr */ bigint, + /* el_1_1 */ /* RustArcPtr */ bigint, + /* el_2_0 */ /* RustArcPtr */ bigint, + /* el_2_1 */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_circomg2_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_circomg2_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_circomg2_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_clienttransactionbuilder: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_clienttransactionbuilder: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_dry_run: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* skip_checks */ number + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_execute: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* signer */ /* RustArcPtr */ bigint, + /* wait_for */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_execute_with_sponsor: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* signer */ /* RustArcPtr */ bigint, + /* sponsor_signer */ /* RustArcPtr */ bigint, + /* wait_for */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_expiration: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* epoch */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_finish: (args: [ + /* ptr */ /* RustArcPtr */ bigint + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_gas: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* object_ids */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_gas_budget: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* budget */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_gas_price: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* price */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_gas_station_sponsor: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* url */ /* RustBuffer */ UniffiRustBufferStruct, + /* duration */ /* RustBuffer */ UniffiRustBufferStruct, + /* headers */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_make_move_vec: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* elements */ /* RustBuffer */ UniffiRustBufferStruct, + /* type_tag */ /* RustArcPtr */ bigint, + /* name */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_merge_coins: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* primary_coin */ /* RustArcPtr */ bigint, + /* consumed_coins */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_move_call: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* package */ /* RustArcPtr */ bigint, + /* module */ /* RustArcPtr */ bigint, + /* function */ /* RustArcPtr */ bigint, + /* arguments */ /* RustBuffer */ UniffiRustBufferStruct, + /* type_args */ /* RustBuffer */ UniffiRustBufferStruct, + /* names */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_publish: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* package_data */ /* RustArcPtr */ bigint, + /* upgrade_cap_name */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_send_coins: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* coins */ /* RustBuffer */ UniffiRustBufferStruct, + /* recipient */ /* RustArcPtr */ bigint, + /* amount */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_send_iota: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* recipient */ /* RustArcPtr */ bigint, + /* amount */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_set_sender: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* sender */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_split_coins: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* coin */ /* RustArcPtr */ bigint, + /* amounts */ /* RustBuffer */ UniffiRustBufferStruct, + /* names */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_sponsor: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* sponsor */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_stake: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* stake */ /* RustArcPtr */ bigint, + /* validator_address */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_transfer_objects: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* recipient */ /* RustArcPtr */ bigint, + /* objects */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_unstake: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* staked_iota */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_clienttransactionbuilder_upgrade: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* package_id */ /* RustArcPtr */ bigint, + /* package_data */ /* RustArcPtr */ bigint, + /* upgrade_ticket */ /* RustArcPtr */ bigint, + /* name */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_clone_coin: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_coin: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_coin_try_from_object: (args: [ + /* object */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_coin_balance: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_coin_coin_type: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_coin_id: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_coin_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_clone_command: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_command: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_command_new_make_move_vector: (args: [ + /* make_move_vector */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_command_new_merge_coins: (args: [ + /* merge_coins */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_command_new_move_call: (args: [ + /* move_call */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_command_new_publish: (args: [ + /* publish */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_command_new_split_coins: (args: [ + /* split_coins */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_command_new_transfer_objects: (args: [ + /* transfer_objects */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_command_new_upgrade: (args: [ + /* upgrade */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_command_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_command_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_command_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_consensuscommitprologuev1: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_consensuscommitprologuev1: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_consensuscommitprologuev1_new: (args: [ + /* epoch */ bigint, + /* round */ bigint, + /* sub_dag_index */ /* RustBuffer */ UniffiRustBufferStruct, + /* commit_timestamp_ms */ bigint, + /* consensus_commit_digest */ /* RustArcPtr */ bigint, + /* consensus_determined_version_assignments */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_commit_timestamp_ms: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_consensus_commit_digest: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_consensus_determined_version_assignments: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_epoch: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_round: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_sub_dag_index: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_consensusdeterminedversionassignments: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_consensusdeterminedversionassignments: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_consensusdeterminedversionassignments_new_cancelled_transactions: (args: [ + /* cancelled_transactions */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_consensusdeterminedversionassignments_as_cancelled_transactions: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_consensusdeterminedversionassignments_is_cancelled_transactions: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_consensusdeterminedversionassignments_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_consensusdeterminedversionassignments_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_consensusdeterminedversionassignments_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_digest: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_digest: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_digest_from_base58: (args: [ + /* base58 */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_digest_from_bytes: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_digest_generate: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_digest_next_lexicographical: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_digest_to_base58: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_digest_to_bytes: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_digest_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_digest_uniffi_trait_display: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_digest_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_digest_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_digest_uniffi_trait_hash: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_clone_ed25519privatekey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_ed25519privatekey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_ed25519privatekey_from_bech32: (args: [ + /* value */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ed25519privatekey_from_der: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ed25519privatekey_from_mnemonic: (args: [ + /* phrase */ /* RustBuffer */ UniffiRustBufferStruct, + /* account_index */ bigint, + /* password */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ed25519privatekey_from_mnemonic_with_path: (args: [ + /* phrase */ /* RustBuffer */ UniffiRustBufferStruct, + /* path */ /* RustBuffer */ UniffiRustBufferStruct, + /* password */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ed25519privatekey_from_pem: (args: [ + /* s */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ed25519privatekey_generate: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ed25519privatekey_new: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_public_key: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_scheme: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_sign_personal_message: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_sign_transaction: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* transaction */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_to_bech32: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_to_bytes: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_to_der: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_to_pem: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_try_sign: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_try_sign_simple: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_try_sign_user: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_verifying_key: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_ed25519privatekey_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_ed25519publickey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_ed25519publickey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_ed25519publickey_from_bytes: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ed25519publickey_from_str: (args: [ + /* s */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ed25519publickey_generate: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_ed25519publickey_derive_address: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_ed25519publickey_scheme: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_ed25519publickey_to_bytes: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_ed25519publickey_to_flagged_bytes: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_ed25519publickey_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_ed25519publickey_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_ed25519publickey_uniffi_trait_hash: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_clone_ed25519signature: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_ed25519signature: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_ed25519signature_from_bytes: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ed25519signature_from_str: (args: [ + /* s */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ed25519signature_generate: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_ed25519signature_to_bytes: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_ed25519signature_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_ed25519signature_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_ed25519signature_uniffi_trait_hash: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_clone_ed25519verifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_ed25519verifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_ed25519verifier_new: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_ed25519verifier_verify_simple: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_ed25519verifier_verify_user: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_ed25519verifier_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_clone_ed25519verifyingkey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_ed25519verifyingkey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_ed25519verifyingkey_from_der: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ed25519verifyingkey_from_pem: (args: [ + /* s */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ed25519verifyingkey_new: (args: [ + /* public_key */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_ed25519verifyingkey_public_key: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_ed25519verifyingkey_to_der: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_ed25519verifyingkey_to_pem: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_ed25519verifyingkey_verify: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_ed25519verifyingkey_verify_simple: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_ed25519verifyingkey_verify_user: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_ed25519verifyingkey_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_ed25519verifyingkey_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_ed25519verifyingkey_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_endofepochtransactionkind: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_endofepochtransactionkind: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_endofepochtransactionkind_new_authenticator_state_create: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_endofepochtransactionkind_new_authenticator_state_expire: (args: [ + /* tx */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_endofepochtransactionkind_new_change_epoch: (args: [ + /* tx */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_endofepochtransactionkind_new_change_epoch_v2: (args: [ + /* tx */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_endofepochtransactionkind_new_change_epoch_v3: (args: [ + /* tx */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_endofepochtransactionkind_new_change_epoch_v4: (args: [ + /* tx */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_endofepochtransactionkind_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_endofepochtransactionkind_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_endofepochtransactionkind_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_executiontimeobservation: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_executiontimeobservation: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservation_new: (args: [ + /* key */ /* RustArcPtr */ bigint, + /* observations */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservation_key: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservation_observations: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservation_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservation_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservation_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservation_uniffi_trait_hash: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_clone_executiontimeobservationkey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_executiontimeobservationkey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_make_move_vec: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_merge_coins: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_move_entry_point: (args: [ + /* package */ /* RustArcPtr */ bigint, + /* module */ /* RustBuffer */ UniffiRustBufferStruct, + /* function */ /* RustBuffer */ UniffiRustBufferStruct, + /* type_arguments */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_publish: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_split_coins: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_transfer_objects: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_upgrade: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservationkey_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservationkey_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservationkey_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservationkey_uniffi_trait_hash: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_clone_executiontimeobservations: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_executiontimeobservations: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservations_new_v1: (args: [ + /* execution_time_observations */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservations_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservations_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservations_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_executiontimeobservations_uniffi_trait_hash: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_clone_faucetclient: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_faucetclient: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_faucetclient_new: (args: [ + /* faucet_url */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_faucetclient_new_devnet: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_faucetclient_new_localnet: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_faucetclient_new_testnet: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_faucetclient_request: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* address */ /* RustArcPtr */ bigint + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_faucetclient_request_and_wait: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* address */ /* RustArcPtr */ bigint + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_faucetclient_request_and_wait_for_finalized: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* address */ /* RustArcPtr */ bigint, + /* client */ /* RustArcPtr */ bigint + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_faucetclient_request_status: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* id */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_clone_genesisobject: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_genesisobject: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_genesisobject_new: (args: [ + /* data */ /* RustArcPtr */ bigint, + /* owner */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_genesisobject_data: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_genesisobject_object_id: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_genesisobject_object_type: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_genesisobject_owner: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_genesisobject_version: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_genesisobject_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_genesisobject_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_genesisobject_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_genesistransaction: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_genesistransaction: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_genesistransaction_new: (args: [ + /* objects */ /* RustBuffer */ UniffiRustBufferStruct, + /* events */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_genesistransaction_events: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_genesistransaction_objects: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_genesistransaction_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_genesistransaction_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_genesistransaction_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_graphqlclient: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_graphqlclient: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_graphqlclient_new: (args: [ + /* server */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_graphqlclient_new_devnet: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_graphqlclient_new_localnet: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_graphqlclient_new_mainnet: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_graphqlclient_new_testnet: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_active_validators: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* epoch */ /* RustBuffer */ UniffiRustBufferStruct, + /* pagination_filter */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_balance: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* address */ /* RustArcPtr */ bigint, + /* coin_type */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_chain_id: (args: [ + /* ptr */ /* RustArcPtr */ bigint + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_checkpoint: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* digest */ /* RustBuffer */ UniffiRustBufferStruct, + /* seq_num */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_checkpoints: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* pagination_filter */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_coin_metadata: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* coin_type */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_coins: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* owner */ /* RustArcPtr */ bigint, + /* pagination_filter */ /* RustBuffer */ UniffiRustBufferStruct, + /* coin_type */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_dry_run_tx: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* tx */ /* RustArcPtr */ bigint, + /* skip_checks */ number + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_dry_run_tx_kind: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* tx_kind */ /* RustArcPtr */ bigint, + /* tx_meta */ /* RustBuffer */ UniffiRustBufferStruct, + /* skip_checks */ number + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_dynamic_field: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* address */ /* RustArcPtr */ bigint, + /* type_tag */ /* RustArcPtr */ bigint, + /* name */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_dynamic_fields: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* address */ /* RustArcPtr */ bigint, + /* pagination_filter */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_dynamic_object_field: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* address */ /* RustArcPtr */ bigint, + /* type_tag */ /* RustArcPtr */ bigint, + /* name */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_epoch: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* epoch */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_epoch_total_checkpoints: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* epoch */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_epoch_total_transaction_blocks: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* epoch */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_events: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* filter */ /* RustBuffer */ UniffiRustBufferStruct, + /* pagination_filter */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_execute_tx: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* signatures */ /* RustBuffer */ UniffiRustBufferStruct, + /* tx */ /* RustArcPtr */ bigint, + /* wait_for */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_gas_coins: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* owner */ /* RustArcPtr */ bigint, + /* pagination_filter */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_iota_names_default_name: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* address */ /* RustArcPtr */ bigint, + /* format */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_iota_names_lookup: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* name */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_iota_names_registrations: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* address */ /* RustArcPtr */ bigint, + /* pagination_filter */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_is_tx_finalized: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* digest */ /* RustArcPtr */ bigint + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_is_tx_indexed_on_node: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* digest */ /* RustArcPtr */ bigint + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_latest_checkpoint_sequence_number: (args: [ + /* ptr */ /* RustArcPtr */ bigint + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_max_page_size: (args: [ + /* ptr */ /* RustArcPtr */ bigint + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_move_object_contents: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* object_id */ /* RustArcPtr */ bigint, + /* version */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_move_object_contents_bcs: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* object_id */ /* RustArcPtr */ bigint, + /* version */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_move_view_call: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* function_name */ /* RustBuffer */ UniffiRustBufferStruct, + /* type_arguments */ /* RustBuffer */ UniffiRustBufferStruct, + /* arguments */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_move_view_call_json: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* function_name */ /* RustBuffer */ UniffiRustBufferStruct, + /* type_arguments */ /* RustBuffer */ UniffiRustBufferStruct, + /* arguments */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_normalized_move_function: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* package */ /* RustArcPtr */ bigint, + /* module */ /* RustBuffer */ UniffiRustBufferStruct, + /* function */ /* RustBuffer */ UniffiRustBufferStruct, + /* version */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_normalized_move_module: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* package */ /* RustArcPtr */ bigint, + /* module */ /* RustBuffer */ UniffiRustBufferStruct, + /* version */ /* RustBuffer */ UniffiRustBufferStruct, + /* pagination_filter_enums */ /* RustBuffer */ UniffiRustBufferStruct, + /* pagination_filter_friends */ /* RustBuffer */ UniffiRustBufferStruct, + /* pagination_filter_functions */ /* RustBuffer */ UniffiRustBufferStruct, + /* pagination_filter_structs */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_object: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* object_id */ /* RustArcPtr */ bigint, + /* version */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_object_bcs: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* object_id */ /* RustArcPtr */ bigint + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_objects: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* filter */ /* RustBuffer */ UniffiRustBufferStruct, + /* pagination_filter */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_package: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* address */ /* RustArcPtr */ bigint, + /* version */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_package_latest: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* address */ /* RustArcPtr */ bigint + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_package_versions: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* address */ /* RustArcPtr */ bigint, + /* after_version */ /* RustBuffer */ UniffiRustBufferStruct, + /* before_version */ /* RustBuffer */ UniffiRustBufferStruct, + /* pagination_filter */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_packages: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* after_checkpoint */ /* RustBuffer */ UniffiRustBufferStruct, + /* before_checkpoint */ /* RustBuffer */ UniffiRustBufferStruct, + /* pagination_filter */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_protocol_config: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* version */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_reference_gas_price: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* epoch */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_run_query: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* query */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_service_config: (args: [ + /* ptr */ /* RustArcPtr */ bigint + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_set_rpc_server: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* server */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_total_supply: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* coin_type */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_total_transaction_blocks: (args: [ + /* ptr */ /* RustArcPtr */ bigint + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_total_transaction_blocks_by_digest: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* digest */ /* RustArcPtr */ bigint + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_total_transaction_blocks_by_seq_num: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* seq_num */ bigint + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_transaction: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* digest */ /* RustArcPtr */ bigint + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_transaction_data_effects: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* digest */ /* RustArcPtr */ bigint + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_transaction_effects: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* digest */ /* RustArcPtr */ bigint + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_transactions: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* filter */ /* RustBuffer */ UniffiRustBufferStruct, + /* pagination_filter */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_transactions_data_effects: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* filter */ /* RustBuffer */ UniffiRustBufferStruct, + /* pagination_filter */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_transactions_effects: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* filter */ /* RustBuffer */ UniffiRustBufferStruct, + /* pagination_filter */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_graphqlclient_wait_for_tx: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* digest */ /* RustArcPtr */ bigint, + /* wait_for */ /* RustBuffer */ UniffiRustBufferStruct, + /* timeout */ /* RustBuffer */ UniffiRustBufferStruct + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_clone_identifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_identifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_identifier_new: (args: [ + /* identifier */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_identifier_as_str: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_identifier_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_identifier_uniffi_trait_display: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_identifier_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_identifier_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_identifier_uniffi_trait_hash: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_clone_input: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_input: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_input_new_immutable_or_owned: (args: [ + /* object_ref */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_input_new_pure: (args: [ + /* value */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_input_new_receiving: (args: [ + /* object_ref */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_input_new_shared: (args: [ + /* object_id */ /* RustArcPtr */ bigint, + /* initial_shared_version */ bigint, + /* mutable */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_input_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_input_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_input_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_intent: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_intent: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_intent_from_bytes: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_intent_from_hex: (args: [ + /* hex */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_intent_new: (args: [ + /* scope */ /* RustBuffer */ UniffiRustBufferStruct, + /* version */ /* RustBuffer */ UniffiRustBufferStruct, + /* app_id */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_intent_new_consensus_app: (args: [ + /* scope */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_intent_new_iota_app: (args: [ + /* scope */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_intent_new_iota_transaction: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_intent_new_personal_message: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_intent_app_id: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_intent_scope: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_intent_to_bytes: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_intent_version: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_intent_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_intent_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_intent_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_intent_uniffi_trait_hash: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_clone_makemovevector: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_makemovevector: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_makemovevector_new: (args: [ + /* type_tag */ /* RustBuffer */ UniffiRustBufferStruct, + /* elements */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_makemovevector_elements: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_makemovevector_type_tag: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_makemovevector_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_makemovevector_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_makemovevector_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_mergecoins: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_mergecoins: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_mergecoins_new: (args: [ + /* coin */ /* RustArcPtr */ bigint, + /* coins_to_merge */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_mergecoins_coin: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_mergecoins_coins_to_merge: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_mergecoins_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_mergecoins_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_mergecoins_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_movearg: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_movearg: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_movearg_address: (args: [ + /* address */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_movearg_address_from_hex: (args: [ + /* hex */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_movearg_address_vec: (args: [ + /* addresses */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_movearg_address_vec_from_hex: (args: [ + /* addresses */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_movearg_bool: (args: [ + /* value */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_movearg_bool_vec: (args: [ + /* values */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_movearg_digest: (args: [ + /* digest */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_movearg_digest_from_base58: (args: [ + /* base58 */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_movearg_digest_vec: (args: [ + /* digests */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_movearg_digest_vec_from_base58: (args: [ + /* digests */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_movearg_option: (args: [ + /* value */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_movearg_string: (args: [ + /* string */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_movearg_string_vec: (args: [ + /* addresses */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_movearg_u128: (args: [ + /* value */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_movearg_u128_vec: (args: [ + /* values */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_movearg_u16: (args: [ + /* value */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_movearg_u16_vec: (args: [ + /* values */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_movearg_u256: (args: [ + /* value */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_movearg_u256_vec: (args: [ + /* values */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_movearg_u32: (args: [ + /* value */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_movearg_u32_vec: (args: [ + /* values */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_movearg_u64: (args: [ + /* value */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_movearg_u64_vec: (args: [ + /* values */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_movearg_u8: (args: [ + /* value */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_movearg_u8_vec: (args: [ + /* values */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_clone_moveauthenticator: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_moveauthenticator: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_moveauthenticator_new_immutable: (args: [ + /* call_args */ /* RustBuffer */ UniffiRustBufferStruct, + /* type_args */ /* RustBuffer */ UniffiRustBufferStruct, + /* object_to_authenticate */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_moveauthenticator_new_shared: (args: [ + /* call_args */ /* RustBuffer */ UniffiRustBufferStruct, + /* type_args */ /* RustBuffer */ UniffiRustBufferStruct, + /* object_to_authenticate */ /* RustArcPtr */ bigint, + /* initial_shared_version */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_moveauthenticator_address: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_moveauthenticator_call_args: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_moveauthenticator_object_to_authenticate: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_moveauthenticator_type_args: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_clone_moveauthenticatorbuilder: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_moveauthenticatorbuilder: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_moveauthenticatorbuilder_new: (args: [ + /* account_id */ /* RustArcPtr */ bigint, + /* call_args */ /* RustBuffer */ UniffiRustBufferStruct, + /* type_args */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_moveauthenticatorbuilder_finish: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* client */ /* RustArcPtr */ bigint + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_clone_movecall: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_movecall: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_movecall_new: (args: [ + /* package */ /* RustArcPtr */ bigint, + /* module */ /* RustArcPtr */ bigint, + /* function */ /* RustArcPtr */ bigint, + /* type_arguments */ /* RustBuffer */ UniffiRustBufferStruct, + /* arguments */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_movecall_arguments: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_movecall_function: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_movecall_module: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_movecall_package: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_movecall_type_arguments: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_movecall_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_movecall_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_movecall_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_movefunction: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_movefunction: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_movefunction_is_entry: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_movefunction_name: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_movefunction_parameters: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_movefunction_return_type: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_movefunction_type_parameters: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_movefunction_visibility: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_movefunction_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_movefunction_uniffi_trait_display: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_clone_movepackage: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_movepackage: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_movepackage_new: (args: [ + /* id */ /* RustArcPtr */ bigint, + /* version */ bigint, + /* modules */ /* RustBuffer */ UniffiRustBufferStruct, + /* type_origin_table */ /* RustBuffer */ UniffiRustBufferStruct, + /* linkage_table */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_movepackage_id: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_movepackage_linkage_table: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_movepackage_modules: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_movepackage_type_origin_table: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_movepackage_version: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_movepackage_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_movepackage_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_movepackage_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_movepackage_uniffi_trait_hash: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_clone_movepackagedata: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_movepackagedata: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_movepackagedata_from_base64: (args: [ + /* base64 */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_movepackagedata_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_movepackagedata_new: (args: [ + /* modules */ /* RustBuffer */ UniffiRustBufferStruct, + /* dependencies */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_movepackagedata_dependencies: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_movepackagedata_digest: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_movepackagedata_modules: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_movepackagedata_to_base64: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_movepackagedata_to_json: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_movepackagedata_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_clone_moveviewarg: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_moveviewarg: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_address: (args: [ + /* value */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_bool: (args: [ + /* value */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_json: (args: [ + /* value */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_null: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_object_id: (args: [ + /* value */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_option: (args: [ + /* value */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_string: (args: [ + /* value */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_string_vec: (args: [ + /* values */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_u128: (args: [ + /* value */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_u16: (args: [ + /* value */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_u32: (args: [ + /* value */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_u64: (args: [ + /* value */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_u8: (args: [ + /* value */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_moveviewarg_u8_vec: (args: [ + /* values */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_clone_multisigaggregatedsignature: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_multisigaggregatedsignature: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_multisigaggregatedsignature_new: (args: [ + /* committee */ /* RustArcPtr */ bigint, + /* signatures */ /* RustBuffer */ UniffiRustBufferStruct, + /* bitmap */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_multisigaggregatedsignature_bitmap: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_multisigaggregatedsignature_committee: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_multisigaggregatedsignature_signatures: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_multisigaggregatedsignature_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_multisigaggregatedsignature_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_multisigaggregatedsignature_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_multisigaggregator: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_multisigaggregator: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_multisigaggregator_new_with_message: (args: [ + /* committee */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_multisigaggregator_new_with_transaction: (args: [ + /* committee */ /* RustArcPtr */ bigint, + /* transaction */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_multisigaggregator_finish: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_multisigaggregator_verifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_multisigaggregator_with_signature: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_multisigaggregator_with_verifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* verifier */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_multisigaggregator_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_clone_multisigcommittee: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_multisigcommittee: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_multisigcommittee_new: (args: [ + /* members */ /* RustBuffer */ UniffiRustBufferStruct, + /* threshold */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_multisigcommittee_derive_address: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_multisigcommittee_is_valid: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_multisigcommittee_members: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_multisigcommittee_scheme: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_multisigcommittee_threshold: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_multisigcommittee_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_multisigcommittee_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_multisigcommittee_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_multisigmember: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_multisigmember: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_multisigmember_new: (args: [ + /* public_key */ /* RustArcPtr */ bigint, + /* weight */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_multisigmember_public_key: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_multisigmember_weight: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_multisigmember_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_multisigmember_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_multisigmember_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_multisigmemberpublickey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_multisigmemberpublickey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_ed25519: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_ed25519_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_secp256k1: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_secp256k1_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_secp256r1: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_secp256r1_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_zklogin: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_zklogin_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_is_ed25519: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_is_secp256k1: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_is_secp256r1: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_is_zklogin: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_scheme: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_multisigmembersignature: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_multisigmembersignature: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_ed25519: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_ed25519_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_secp256k1: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_secp256k1_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_secp256r1: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_secp256r1_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_zklogin: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_zklogin_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_is_ed25519: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_is_secp256k1: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_is_secp256r1: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_is_zklogin: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_multisigverifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_multisigverifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_multisigverifier_new: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_multisigverifier_verify: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_multisigverifier_with_zklogin_verifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* zklogin_verifier */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_multisigverifier_zklogin_verifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_multisigverifier_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_clone_name: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_name: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_name_from_str: (args: [ + /* s */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_name_format: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* format */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_name_is_sln: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_name_is_subname: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_name_label: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* index */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_name_labels: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_name_num_labels: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_name_parent: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_name_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_name_uniffi_trait_display: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_name_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_name_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_name_uniffi_trait_hash: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_clone_nameregistration: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_nameregistration: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_nameregistration_new: (args: [ + /* id */ /* RustArcPtr */ bigint, + /* name */ /* RustArcPtr */ bigint, + /* name_str */ /* RustBuffer */ UniffiRustBufferStruct, + /* expiration_timestamp_ms */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_nameregistration_expiration_timestamp_ms: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_nameregistration_id: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_nameregistration_name: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_nameregistration_name_str: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_nameregistration_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_nameregistration_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_nameregistration_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_object: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_object: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_object_new: (args: [ + /* data */ /* RustArcPtr */ bigint, + /* owner */ /* RustArcPtr */ bigint, + /* previous_transaction */ /* RustArcPtr */ bigint, + /* storage_rebate */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_object_as_package: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_object_as_package_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_object_as_struct: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_object_as_struct_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_object_data: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_object_digest: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_object_object_id: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_object_object_ref: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_object_object_type: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_object_owner: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_object_previous_transaction: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_object_storage_rebate: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_object_version: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_object_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_object_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_object_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_objectdata: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_objectdata: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_objectdata_new_move_package: (args: [ + /* move_package */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_objectdata_new_move_struct: (args: [ + /* move_struct */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_objectdata_as_package_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_objectdata_as_struct_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_objectdata_is_package: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_objectdata_is_struct: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_objectdata_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_objectdata_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_objectdata_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_objectdata_uniffi_trait_hash: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_clone_objectid: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_objectid: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_objectid_clock: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_objectid_derive_id: (args: [ + /* digest */ /* RustArcPtr */ bigint, + /* count */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_objectid_from_bytes: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_objectid_from_hex: (args: [ + /* hex */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_objectid_system: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_objectid_zero: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_objectid_derive_dynamic_child_id: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* key_type_tag */ /* RustArcPtr */ bigint, + /* key_bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_objectid_to_address: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_objectid_to_bytes: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_objectid_to_canonical_string: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* with_prefix */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_objectid_to_hex: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_objectid_to_short_string: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* with_prefix */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_objectid_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_objectid_uniffi_trait_display: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_objectid_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_objectid_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_objectid_uniffi_trait_hash: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_clone_objecttype: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_objecttype: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_objecttype_new_package: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_objecttype_new_struct: (args: [ + /* struct_tag */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_objecttype_as_struct: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_objecttype_as_struct_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_objecttype_is_package: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_objecttype_is_struct: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_objecttype_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_objecttype_uniffi_trait_display: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_objecttype_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_objecttype_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_owner: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_owner: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_owner_new_address: (args: [ + /* address */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_owner_new_immutable: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_owner_new_object: (args: [ + /* id */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_owner_new_shared: (args: [ + /* version */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_owner_as_address: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_owner_as_address_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_owner_as_object: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_owner_as_object_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_owner_as_shared: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_owner_as_shared_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_owner_is_address: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_owner_is_immutable: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_owner_is_object: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_owner_is_shared: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_owner_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_owner_uniffi_trait_display: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_owner_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_owner_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_owner_uniffi_trait_hash: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_clone_ptbargument: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_ptbargument: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_address: (args: [ + /* address */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_address_from_hex: (args: [ + /* hex */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_address_vec: (args: [ + /* addresses */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_address_vec_from_hex: (args: [ + /* addresses */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_assigned: (args: [ + /* name */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_bool: (args: [ + /* value */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_bool_vec: (args: [ + /* values */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_digest: (args: [ + /* digest */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_digest_from_base58: (args: [ + /* base58 */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_digest_vec: (args: [ + /* digests */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_digest_vec_from_base58: (args: [ + /* digests */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_gas: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_move_arg: (args: [ + /* arg */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_object_id: (args: [ + /* id */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_object_id_from_hex: (args: [ + /* hex */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_object_ref: (args: [ + /* id */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_option: (args: [ + /* value */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_receiving: (args: [ + /* id */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_receiving_from_hex: (args: [ + /* hex */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_shared: (args: [ + /* id */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_shared_from_hex: (args: [ + /* hex */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_shared_mut: (args: [ + /* id */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_shared_mut_from_hex: (args: [ + /* hex */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_string: (args: [ + /* string */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u128: (args: [ + /* value */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u128_vec: (args: [ + /* values */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u16: (args: [ + /* value */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u16_vec: (args: [ + /* values */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u256: (args: [ + /* value */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u256_vec: (args: [ + /* values */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u32: (args: [ + /* value */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u32_vec: (args: [ + /* values */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u64: (args: [ + /* value */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u64_vec: (args: [ + /* values */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u8: (args: [ + /* value */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_ptbargument_u8_vec: (args: [ + /* values */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_clone_passkeyauthenticator: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_passkeyauthenticator: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_authenticator_data: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_challenge: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_client_data_json: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_public_key: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_signature: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_passkeypublickey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_passkeypublickey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_passkeypublickey_new: (args: [ + /* public_key */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_passkeypublickey_derive_address: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_passkeypublickey_inner: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_passkeypublickey_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_passkeypublickey_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_passkeypublickey_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_passkeyverifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_passkeyverifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_passkeyverifier_new: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_passkeyverifier_verify: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, + /* authenticator */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_passkeyverifier_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_clone_personalmessage: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_personalmessage: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_personalmessage_new: (args: [ + /* message_bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_personalmessage_message_bytes: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_personalmessage_signing_digest: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_personalmessage_signing_digest_hex: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_personalmessage_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_personalmessage_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_personalmessage_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_programmabletransaction: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_programmabletransaction: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_programmabletransaction_new: (args: [ + /* inputs */ /* RustBuffer */ UniffiRustBufferStruct, + /* commands */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_programmabletransaction_commands: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_programmabletransaction_inputs: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_programmabletransaction_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_programmabletransaction_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_programmabletransaction_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_publish: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_publish: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_publish_new: (args: [ + /* modules */ /* RustBuffer */ UniffiRustBufferStruct, + /* dependencies */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_publish_dependencies: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_publish_modules: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_publish_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_publish_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_publish_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_secp256k1privatekey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_secp256k1privatekey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1privatekey_from_bech32: (args: [ + /* value */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1privatekey_from_der: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1privatekey_from_mnemonic: (args: [ + /* phrase */ /* RustBuffer */ UniffiRustBufferStruct, + /* account_index */ bigint, + /* password */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1privatekey_from_mnemonic_with_path: (args: [ + /* phrase */ /* RustBuffer */ UniffiRustBufferStruct, + /* path */ /* RustBuffer */ UniffiRustBufferStruct, + /* password */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1privatekey_from_pem: (args: [ + /* s */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1privatekey_generate: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1privatekey_new: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_public_key: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_scheme: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_sign_personal_message: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_sign_transaction: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* transaction */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_to_bech32: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_to_bytes: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_to_der: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_to_pem: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_try_sign: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_try_sign_simple: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_try_sign_user: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_verifying_key: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_secp256k1privatekey_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_secp256k1publickey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_secp256k1publickey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1publickey_from_bytes: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1publickey_from_str: (args: [ + /* s */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1publickey_generate: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256k1publickey_derive_address: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256k1publickey_scheme: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_secp256k1publickey_to_bytes: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_secp256k1publickey_to_flagged_bytes: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_secp256k1publickey_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_secp256k1publickey_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_secp256k1publickey_uniffi_trait_hash: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_clone_secp256k1signature: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_secp256k1signature: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1signature_from_bytes: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1signature_from_str: (args: [ + /* s */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1signature_generate: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256k1signature_to_bytes: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_secp256k1signature_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_secp256k1signature_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_secp256k1signature_uniffi_trait_hash: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_clone_secp256k1verifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_secp256k1verifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1verifier_new: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256k1verifier_verify_simple: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_secp256k1verifier_verify_user: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_secp256k1verifier_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_clone_secp256k1verifyingkey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_secp256k1verifyingkey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1verifyingkey_from_der: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1verifyingkey_from_pem: (args: [ + /* s */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_secp256k1verifyingkey_new: (args: [ + /* public_key */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256k1verifyingkey_public_key: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256k1verifyingkey_to_der: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_secp256k1verifyingkey_to_pem: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_secp256k1verifyingkey_verify: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_secp256k1verifyingkey_verify_simple: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_secp256k1verifyingkey_verify_user: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_secp256k1verifyingkey_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_secp256k1verifyingkey_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_secp256k1verifyingkey_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_secp256r1privatekey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_secp256r1privatekey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1privatekey_from_bech32: (args: [ + /* value */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1privatekey_from_der: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1privatekey_from_mnemonic: (args: [ + /* phrase */ /* RustBuffer */ UniffiRustBufferStruct, + /* account_index */ bigint, + /* password */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1privatekey_from_mnemonic_with_path: (args: [ + /* phrase */ /* RustBuffer */ UniffiRustBufferStruct, + /* path */ /* RustBuffer */ UniffiRustBufferStruct, + /* password */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1privatekey_from_pem: (args: [ + /* s */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1privatekey_generate: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1privatekey_new: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_public_key: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_scheme: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_sign_personal_message: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_sign_transaction: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* transaction */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_to_bech32: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_to_bytes: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_to_der: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_to_pem: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_try_sign: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_try_sign_simple: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_try_sign_user: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_verifying_key: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_secp256r1privatekey_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_secp256r1publickey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_secp256r1publickey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1publickey_from_bytes: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1publickey_from_str: (args: [ + /* s */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1publickey_generate: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256r1publickey_derive_address: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256r1publickey_scheme: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_secp256r1publickey_to_bytes: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_secp256r1publickey_to_flagged_bytes: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_secp256r1publickey_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_secp256r1publickey_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_secp256r1publickey_uniffi_trait_hash: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_clone_secp256r1signature: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_secp256r1signature: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1signature_from_bytes: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1signature_from_str: (args: [ + /* s */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1signature_generate: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256r1signature_to_bytes: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_secp256r1signature_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_secp256r1signature_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_secp256r1signature_uniffi_trait_hash: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_clone_secp256r1verifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_secp256r1verifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1verifier_new: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256r1verifier_verify_simple: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_secp256r1verifier_verify_user: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_secp256r1verifier_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_clone_secp256r1verifyingkey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_secp256r1verifyingkey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1verifyingkey_from_der: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1verifyingkey_from_pem: (args: [ + /* s */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_secp256r1verifyingkey_new: (args: [ + /* public_key */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256r1verifyingkey_public_key: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_secp256r1verifyingkey_to_der: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_secp256r1verifyingkey_to_pem: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_secp256r1verifyingkey_verify: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_secp256r1verifyingkey_verify_simple: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_secp256r1verifyingkey_verify_user: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_secp256r1verifyingkey_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_secp256r1verifyingkey_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_secp256r1verifyingkey_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_simplekeypair: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_simplekeypair: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_simplekeypair_from_bech32: (args: [ + /* value */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_simplekeypair_from_bytes: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_simplekeypair_from_der: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_simplekeypair_from_ed25519: (args: [ + /* keypair */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_simplekeypair_from_pem: (args: [ + /* s */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_simplekeypair_from_secp256k1: (args: [ + /* keypair */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_simplekeypair_from_secp256r1: (args: [ + /* keypair */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_simplekeypair_public_key: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_simplekeypair_scheme: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_simplekeypair_sign_personal_message: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_simplekeypair_sign_transaction: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* transaction */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_simplekeypair_to_bech32: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_simplekeypair_to_bytes: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_simplekeypair_to_der: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_simplekeypair_to_pem: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_simplekeypair_try_sign: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_simplekeypair_try_sign_user: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_simplekeypair_verifying_key: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_simplekeypair_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_clone_simplesignature: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_simplesignature: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_simplesignature_new_ed25519: (args: [ + /* signature */ /* RustArcPtr */ bigint, + /* public_key */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_simplesignature_new_secp256k1: (args: [ + /* signature */ /* RustArcPtr */ bigint, + /* public_key */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_simplesignature_new_secp256r1: (args: [ + /* signature */ /* RustArcPtr */ bigint, + /* public_key */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_simplesignature_ed25519_pub_key: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_simplesignature_ed25519_pub_key_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_simplesignature_ed25519_sig: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_simplesignature_ed25519_sig_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_simplesignature_is_ed25519: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_simplesignature_is_secp256k1: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_simplesignature_is_secp256r1: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_simplesignature_scheme: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256k1_pub_key: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256k1_pub_key_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256k1_sig: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256k1_sig_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256r1_pub_key: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256r1_pub_key_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256r1_sig: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256r1_sig_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_simplesignature_to_bytes: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_simplesignature_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_simplesignature_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_simplesignature_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_simplesignature_uniffi_trait_hash: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_clone_simpleverifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_simpleverifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_simpleverifier_new: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_simpleverifier_verify: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_clone_simpleverifyingkey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_simpleverifyingkey: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_simpleverifyingkey_from_der: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_simpleverifyingkey_from_pem: (args: [ + /* s */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_simpleverifyingkey_public_key: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_simpleverifyingkey_scheme: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_simpleverifyingkey_to_der: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_simpleverifyingkey_to_pem: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_simpleverifyingkey_verify: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_simpleverifyingkey_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_simpleverifyingkey_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_simpleverifyingkey_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_splitcoins: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_splitcoins: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_splitcoins_new: (args: [ + /* coin */ /* RustArcPtr */ bigint, + /* amounts */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_splitcoins_amounts: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_splitcoins_coin: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_splitcoins_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_splitcoins_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_splitcoins_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_structtag: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_structtag: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new: (args: [ + /* address */ /* RustArcPtr */ bigint, + /* module */ /* RustArcPtr */ bigint, + /* name */ /* RustArcPtr */ bigint, + /* type_params */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_ascii_string: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_balance: (args: [ + /* type_tag */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_clock: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_coin: (args: [ + /* type_tag */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_coin_manager: (args: [ + /* struct_tag */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_coin_metadata: (args: [ + /* struct_tag */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_config: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_config_setting: (args: [ + /* type_tag */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_deny_list_address_key: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_deny_list_config_key: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_deny_list_global_pause_key: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_display_created: (args: [ + /* struct_tag */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_dynamic_object_field_wrapper: (args: [ + /* type_tag */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_field: (args: [ + /* key */ /* RustArcPtr */ bigint, + /* value */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_gas_coin: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_id: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_iota_coin_type: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_iota_system_admin_cap: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_iota_system_state: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_iota_treasury_cap: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_name: (args: [ + /* address */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_staked_iota: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_string: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_system_epoch_info_event: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_time_lock: (args: [ + /* type_tag */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_timelocked_staked_iota: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_transfer_receiving: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_treasury_cap: (args: [ + /* struct_tag */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_uid: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_upgrade_cap: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_upgrade_receipt: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_upgrade_ticket: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_structtag_new_version_updated: (args: [ + /* struct_tag */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_structtag_address: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_structtag_coin_type: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_structtag_coin_type_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_structtag_module: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_structtag_name: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_structtag_to_canonical_string: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* with_prefix */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_structtag_type_args: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_structtag_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_structtag_uniffi_trait_display: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_structtag_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_structtag_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_structtag_uniffi_trait_hash: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_clone_systempackage: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_systempackage: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_systempackage_new: (args: [ + /* version */ bigint, + /* modules */ /* RustBuffer */ UniffiRustBufferStruct, + /* dependencies */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_systempackage_dependencies: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_systempackage_modules: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_systempackage_version: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_systempackage_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_systempackage_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_systempackage_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_transaction: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_transaction: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_transaction_from_base64: (args: [ + /* base64 */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_transaction_new_v1: (args: [ + /* transaction_v1 */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transaction_as_v1: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transaction_digest: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transaction_expiration: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_transaction_gas_payment: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_transaction_kind: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transaction_sender: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transaction_signing_digest: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_transaction_signing_digest_hex: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_transaction_to_base64: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_transaction_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_transaction_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_transaction_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_transactionbuilder: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_transactionbuilder: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_transactionbuilder_new: (args: [ + /* sender */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_execute_with_gas_station: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* signer */ /* RustArcPtr */ bigint + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_expiration: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* epoch */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_finish: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_gas: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* object_refs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_gas_budget: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* budget */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_gas_price: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* price */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_gas_station_sponsor: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* url */ /* RustBuffer */ UniffiRustBufferStruct, + /* duration */ /* RustBuffer */ UniffiRustBufferStruct, + /* headers */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_make_move_vec: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* elements */ /* RustBuffer */ UniffiRustBufferStruct, + /* type_tag */ /* RustArcPtr */ bigint, + /* name */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_merge_coins: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* primary_coin */ /* RustArcPtr */ bigint, + /* consumed_coins */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_move_call: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* package */ /* RustArcPtr */ bigint, + /* module */ /* RustArcPtr */ bigint, + /* function */ /* RustArcPtr */ bigint, + /* arguments */ /* RustBuffer */ UniffiRustBufferStruct, + /* type_args */ /* RustBuffer */ UniffiRustBufferStruct, + /* names */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_publish: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* package_data */ /* RustArcPtr */ bigint, + /* upgrade_cap_name */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_send_coins: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* coins */ /* RustBuffer */ UniffiRustBufferStruct, + /* recipient */ /* RustArcPtr */ bigint, + /* amount */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_send_iota: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* recipient */ /* RustArcPtr */ bigint, + /* amount */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_set_sender: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* sender */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_split_coins: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* coin */ /* RustArcPtr */ bigint, + /* amounts */ /* RustBuffer */ UniffiRustBufferStruct, + /* names */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_sponsor: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* sponsor */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_stake: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* stake */ /* RustArcPtr */ bigint, + /* validator_address */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_transfer_objects: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* recipient */ /* RustArcPtr */ bigint, + /* objects */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_unstake: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* staked_iota */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_upgrade: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* package_id */ /* RustArcPtr */ bigint, + /* package_data */ /* RustArcPtr */ bigint, + /* upgrade_ticket */ /* RustArcPtr */ bigint, + /* name */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_with_client: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* client */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionbuilder_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_clone_transactioneffects: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_transactioneffects: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_transactioneffects_new_v1: (args: [ + /* effects */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactioneffects_as_v1: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_transactioneffects_digest: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactioneffects_is_v1: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_transactioneffects_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_transactioneffects_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_transactioneffects_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_transactionevents: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_transactionevents: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_transactionevents_new: (args: [ + /* events */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionevents_digest: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionevents_events: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_clone_transactionkind: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_transactionkind: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_transactionkind_new_authenticator_state_update_v1: (args: [ + /* tx */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_transactionkind_new_consensus_commit_prologue_v1: (args: [ + /* tx */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_transactionkind_new_end_of_epoch: (args: [ + /* tx */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_transactionkind_new_genesis: (args: [ + /* tx */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_transactionkind_new_programmable_transaction: (args: [ + /* tx */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_transactionkind_new_randomness_state_update: (args: [ + /* tx */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionkind_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_transactionkind_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_transactionkind_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_transactionsigner: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_transactionsigner: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_transactionsigner_from_ed25519: (args: [ + /* key */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_transactionsigner_from_keypair: (args: [ + /* key */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_transactionsigner_from_move_authenticator: (args: [ + /* auth */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_transactionsigner_from_secp256k1: (args: [ + /* key */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_transactionsigner_from_secp256r1: (args: [ + /* key */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_transactionsigner_new: (args: [ + /* signer_fn */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionsigner_sign: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* txn */ /* RustArcPtr */ bigint + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_clone_transactionsignerfn: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_transactionsignerfn: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_init_callback_vtable_transactionsignerfn: (args: [ + /* vtable */ /* Reference to UniffiVTableCallbackInterfaceTransactionSignerFn */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_transactionsignerfn_sign: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* transaction */ /* RustArcPtr */ bigint + ]) =>/* handle */ bigint, + uniffi_iota_sdk_ffi_fn_clone_transactionv1: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_transactionv1: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_transactionv1_from_base64: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_transactionv1_new: (args: [ + /* kind */ /* RustArcPtr */ bigint, + /* sender */ /* RustArcPtr */ bigint, + /* gas_payment */ /* RustBuffer */ UniffiRustBufferStruct, + /* expiration */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionv1_digest: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionv1_expiration: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_transactionv1_gas_payment: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_transactionv1_kind: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionv1_sender: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transactionv1_signing_digest: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_transactionv1_signing_digest_hex: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_transactionv1_to_base64: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_transactionv1_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_transactionv1_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_transactionv1_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_transferobjects: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_transferobjects: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_transferobjects_new: (args: [ + /* objects */ /* RustBuffer */ UniffiRustBufferStruct, + /* address */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transferobjects_address: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_transferobjects_objects: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_transferobjects_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_transferobjects_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_transferobjects_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_typetag: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_typetag: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_typetag_new_address: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_typetag_new_bool: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_typetag_new_signer: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_typetag_new_struct: (args: [ + /* struct_tag */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_typetag_new_u128: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_typetag_new_u16: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_typetag_new_u256: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_typetag_new_u32: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_typetag_new_u64: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_typetag_new_u8: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_typetag_new_vector: (args: [ + /* type_tag */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_typetag_as_struct_tag: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_typetag_as_struct_tag_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_typetag_as_vector_type_tag: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_typetag_as_vector_type_tag_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_typetag_is_address: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_typetag_is_bool: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_typetag_is_signer: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_typetag_is_struct: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_typetag_is_u128: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_typetag_is_u16: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_typetag_is_u256: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_typetag_is_u32: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_typetag_is_u64: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_typetag_is_u8: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_typetag_is_vector: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_typetag_to_canonical_string: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* with_prefix */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_typetag_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_typetag_uniffi_trait_display: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_typetag_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_typetag_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_typetag_uniffi_trait_hash: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_clone_upgrade: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_upgrade: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_upgrade_new: (args: [ + /* modules */ /* RustBuffer */ UniffiRustBufferStruct, + /* dependencies */ /* RustBuffer */ UniffiRustBufferStruct, + /* package */ /* RustArcPtr */ bigint, + /* ticket */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_upgrade_dependencies: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_upgrade_modules: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_upgrade_package: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_upgrade_ticket: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_upgrade_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_upgrade_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_upgrade_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_upgradepolicy: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_upgradepolicy: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_upgradepolicy_additive: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_upgradepolicy_compatible: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_upgradepolicy_dep_only: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_upgradepolicy_as_u8: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_upgradepolicy_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_upgradepolicy_uniffi_trait_display: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_upgradepolicy_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_upgradepolicy_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_usersignature: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_usersignature: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_usersignature_from_base64: (args: [ + /* base64 */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_usersignature_from_bytes: (args: [ + /* bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_usersignature_new_move_authenticator: (args: [ + /* authenticator */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_usersignature_new_multisig: (args: [ + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_usersignature_new_passkey_authenticator: (args: [ + /* authenticator */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_usersignature_new_simple: (args: [ + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_usersignature_new_zklogin_authenticator: (args: [ + /* authenticator */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_usersignature_as_move_authenticator: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_usersignature_as_move_authenticator_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_usersignature_as_multisig: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_usersignature_as_multisig_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_usersignature_as_passkey_authenticator: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_usersignature_as_passkey_authenticator_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_usersignature_as_simple: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_usersignature_as_simple_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_usersignature_as_zklogin_authenticator: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_usersignature_as_zklogin_authenticator_opt: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_usersignature_is_move_authenticator: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_usersignature_is_multisig: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_usersignature_is_passkey_authenticator: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_usersignature_is_simple: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_usersignature_is_zklogin_authenticator: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_usersignature_scheme: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_usersignature_to_base64: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_usersignature_to_bytes: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_usersignature_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_usersignature_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_usersignature_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_usersignatureverifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_usersignatureverifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_usersignatureverifier_new: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_usersignatureverifier_verify: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_usersignatureverifier_with_zklogin_verifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* zklogin_verifier */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_usersignatureverifier_zklogin_verifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_usersignatureverifier_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_clone_validatoraggregatedsignature: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_validatoraggregatedsignature: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_validatoraggregatedsignature_new: (args: [ + /* epoch */ bigint, + /* signature */ /* RustArcPtr */ bigint, + /* bitmap_bytes */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_validatoraggregatedsignature_bitmap_bytes: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_validatoraggregatedsignature_epoch: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_validatoraggregatedsignature_signature: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_validatoraggregatedsignature_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_clone_validatorcommitteesignatureaggregator: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_validatorcommitteesignatureaggregator: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_validatorcommitteesignatureaggregator_new_checkpoint_summary: (args: [ + /* committee */ /* RustBuffer */ UniffiRustBufferStruct, + /* summary */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_validatorcommitteesignatureaggregator_add_signature: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_validatorcommitteesignatureaggregator_committee: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_validatorcommitteesignatureaggregator_finish: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_validatorcommitteesignatureaggregator_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_clone_validatorcommitteesignatureverifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_validatorcommitteesignatureverifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_validatorcommitteesignatureverifier_new: (args: [ + /* committee */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_validatorcommitteesignatureverifier_committee: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_validatorcommitteesignatureverifier_verify: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_validatorcommitteesignatureverifier_verify_aggregated: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_validatorcommitteesignatureverifier_verify_checkpoint_summary: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* summary */ /* RustArcPtr */ bigint, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_validatorcommitteesignatureverifier_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_clone_validatorexecutiontimeobservation: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_validatorexecutiontimeobservation: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_validatorexecutiontimeobservation_new: (args: [ + /* validator */ /* RustArcPtr */ bigint, + /* duration */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_validatorexecutiontimeobservation_duration: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_validatorexecutiontimeobservation_validator: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_validatorexecutiontimeobservation_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_validatorexecutiontimeobservation_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_validatorexecutiontimeobservation_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_validatorexecutiontimeobservation_uniffi_trait_hash: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_clone_validatorsignature: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_validatorsignature: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_validatorsignature_new: (args: [ + /* epoch */ bigint, + /* public_key */ /* RustArcPtr */ bigint, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_validatorsignature_epoch: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_validatorsignature_public_key: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_validatorsignature_signature: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_validatorsignature_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_validatorsignature_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_validatorsignature_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_versionassignment: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_versionassignment: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_versionassignment_new: (args: [ + /* object_id */ /* RustArcPtr */ bigint, + /* version */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_versionassignment_object_id: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_versionassignment_version: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_versionassignment_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_versionassignment_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_versionassignment_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_zkloginauthenticator: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_zkloginauthenticator: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_zkloginauthenticator_new: (args: [ + /* inputs */ /* RustArcPtr */ bigint, + /* max_epoch */ bigint, + /* signature */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_zkloginauthenticator_inputs: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_zkloginauthenticator_max_epoch: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_method_zkloginauthenticator_signature: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_zkloginauthenticator_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_zkloginauthenticator_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_zkloginauthenticator_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_zklogininputs: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_zklogininputs: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_zklogininputs_new: (args: [ + /* proof_points */ /* RustArcPtr */ bigint, + /* iss_base64_details */ /* RustBuffer */ UniffiRustBufferStruct, + /* header_base64 */ /* RustBuffer */ UniffiRustBufferStruct, + /* address_seed */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_zklogininputs_address_seed: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_zklogininputs_header_base64: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_zklogininputs_iss: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_zklogininputs_iss_base64_details: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_zklogininputs_jwk_id: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_zklogininputs_proof_points: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_zklogininputs_public_identifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_zklogininputs_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_zklogininputs_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_zklogininputs_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_zkloginproof: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_zkloginproof: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_zkloginproof_new: (args: [ + /* a */ /* RustArcPtr */ bigint, + /* b */ /* RustArcPtr */ bigint, + /* c */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_zkloginproof_a: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_zkloginproof_b: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_zkloginproof_c: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_zkloginproof_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_zkloginproof_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_zkloginproof_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_zkloginpublicidentifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_zkloginpublicidentifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_zkloginpublicidentifier_new: (args: [ + /* iss */ /* RustBuffer */ UniffiRustBufferStruct, + /* address_seed */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_zkloginpublicidentifier_address_seed: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_zkloginpublicidentifier_derive_address: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_zkloginpublicidentifier_derive_address_padded: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_zkloginpublicidentifier_derive_address_unpadded: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_zkloginpublicidentifier_iss: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_zkloginpublicidentifier_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_zkloginpublicidentifier_uniffi_trait_eq_eq: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_method_zkloginpublicidentifier_uniffi_trait_eq_ne: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* other */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_clone_zkloginverifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_free_zkloginverifier: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_constructor_zkloginverifier_new_dev: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_constructor_zkloginverifier_new_mainnet: (args: [/* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_zkloginverifier_jwks: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_method_zkloginverifier_verify: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* message */ /* RustBuffer */ UniffiRustBufferStruct, + /* authenticator */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_fn_method_zkloginverifier_with_jwks: (args: [ + /* ptr */ /* RustArcPtr */ bigint, + /* jwks */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_method_zkloginverifier_uniffi_trait_debug: (args: [ + /* ptr */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_active_jwk_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_active_jwk_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_active_jwk_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_active_jwk_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_address_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_address_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_address_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_address_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_argument_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_argument_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_argument_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_argument_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_authenticator_state_expire_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_authenticator_state_expire_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_authenticator_state_expire_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_authenticator_state_expire_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_authenticator_state_update_v1_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_authenticator_state_update_v1_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_authenticator_state_update_v1_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_authenticator_state_update_v1_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_base64_decode: (args: [ + /* input */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_base64_encode: (args: [ + /* input */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_bls12381_public_key_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_bls12381_public_key_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_bls12381_public_key_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_bls12381_public_key_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_bls12381_signature_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_bls12381_signature_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_bls12381_signature_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_bls12381_signature_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_bn254_field_element_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_bn254_field_element_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_bn254_field_element_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_bn254_field_element_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_bool_from_bcs: (args: [ + /* input */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_func_bool_from_json: (args: [ + /* input */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_func_bool_to_bcs: (args: [ + /* input */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_bool_to_json: (args: [ + /* input */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_cancelled_transaction_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_cancelled_transaction_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_cancelled_transaction_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_cancelled_transaction_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_change_epoch_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_change_epoch_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_change_epoch_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_change_epoch_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_change_epoch_v2_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_change_epoch_v2_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_change_epoch_v2_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_change_epoch_v2_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_changed_object_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_changed_object_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_changed_object_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_changed_object_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_checkpoint_commitment_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_checkpoint_commitment_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_checkpoint_commitment_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_checkpoint_commitment_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_checkpoint_contents_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_checkpoint_contents_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_checkpoint_contents_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_checkpoint_contents_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_checkpoint_summary_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_checkpoint_summary_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_checkpoint_summary_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_checkpoint_summary_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_checkpoint_transaction_info_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_checkpoint_transaction_info_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_checkpoint_transaction_info_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_checkpoint_transaction_info_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_circom_g1_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_circom_g1_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_circom_g1_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_circom_g1_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_circom_g2_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_circom_g2_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_circom_g2_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_circom_g2_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_command_argument_error_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_command_argument_error_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_command_argument_error_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_command_argument_error_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_command_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_command_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_command_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_command_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_consensus_commit_prologue_v1_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_consensus_commit_prologue_v1_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_consensus_commit_prologue_v1_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_consensus_commit_prologue_v1_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_consensus_determined_version_assignments_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_consensus_determined_version_assignments_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_consensus_determined_version_assignments_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_consensus_determined_version_assignments_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_digest_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_digest_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_digest_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_digest_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_ed25519_public_key_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_ed25519_public_key_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_ed25519_public_key_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_ed25519_public_key_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_ed25519_signature_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_ed25519_signature_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_ed25519_signature_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_ed25519_signature_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_end_of_epoch_data_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_end_of_epoch_data_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_end_of_epoch_data_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_end_of_epoch_data_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_event_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_event_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_event_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_event_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_execution_error_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_execution_error_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_execution_error_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_execution_error_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_execution_status_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_execution_status_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_execution_status_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_execution_status_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_execution_time_observation_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_execution_time_observation_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_execution_time_observation_key_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_execution_time_observation_key_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_execution_time_observation_key_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_execution_time_observation_key_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_execution_time_observation_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_execution_time_observation_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_execution_time_observations_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_execution_time_observations_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_execution_time_observations_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_execution_time_observations_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_gas_cost_summary_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_gas_cost_summary_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_gas_cost_summary_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_gas_cost_summary_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_gas_payment_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_gas_payment_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_gas_payment_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_gas_payment_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_generate_mnemonic: (args: [ + /* word_count */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_genesis_object_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_genesis_object_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_genesis_object_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_genesis_object_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_genesis_transaction_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_genesis_transaction_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_genesis_transaction_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_genesis_transaction_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_hex_decode: (args: [ + /* input */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_hex_encode: (args: [ + /* input */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_i16_from_bcs: (args: [ + /* input */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_func_i16_from_json: (args: [ + /* input */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_func_i16_to_bcs: (args: [ + /* input */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_i16_to_json: (args: [ + /* input */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_i32_from_bcs: (args: [ + /* input */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_func_i32_from_json: (args: [ + /* input */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_func_i32_to_bcs: (args: [ + /* input */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_i32_to_json: (args: [ + /* input */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_i64_from_bcs: (args: [ + /* input */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_func_i64_from_json: (args: [ + /* input */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_func_i64_to_bcs: (args: [ + /* input */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_i64_to_json: (args: [ + /* input */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_i8_from_bcs: (args: [ + /* input */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_func_i8_from_json: (args: [ + /* input */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_func_i8_to_bcs: (args: [ + /* input */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_i8_to_json: (args: [ + /* input */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_id_operation_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_id_operation_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_id_operation_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_id_operation_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_identifier_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_identifier_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_identifier_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_identifier_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_input_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_input_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_input_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_input_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_jwk_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_jwk_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_jwk_id_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_jwk_id_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_jwk_id_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_jwk_id_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_jwk_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_jwk_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_make_move_vector_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_make_move_vector_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_make_move_vector_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_make_move_vector_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_merge_coins_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_merge_coins_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_merge_coins_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_merge_coins_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_move_call_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_move_call_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_move_call_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_move_call_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_move_location_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_move_location_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_move_location_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_move_location_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_move_package_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_move_package_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_move_package_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_move_package_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_move_struct_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_move_struct_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_move_struct_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_move_struct_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_multisig_aggregated_signature_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_multisig_aggregated_signature_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_multisig_aggregated_signature_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_multisig_aggregated_signature_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_multisig_committee_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_multisig_committee_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_multisig_committee_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_multisig_committee_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_multisig_member_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_multisig_member_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_multisig_member_public_key_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_multisig_member_public_key_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_multisig_member_public_key_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_multisig_member_public_key_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_multisig_member_signature_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_multisig_member_signature_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_multisig_member_signature_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_multisig_member_signature_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_multisig_member_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_multisig_member_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_object_data_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_object_data_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_object_data_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_object_data_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_object_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_object_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_object_id_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_object_id_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_object_id_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_object_id_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_object_in_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_object_in_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_object_in_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_object_in_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_object_out_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_object_out_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_object_out_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_object_out_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_object_reference_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_object_reference_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_object_reference_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_object_reference_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_object_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_object_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_owner_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_owner_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_owner_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_owner_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_package_upgrade_error_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_package_upgrade_error_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_package_upgrade_error_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_package_upgrade_error_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_passkey_authenticator_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_passkey_authenticator_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_passkey_authenticator_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_passkey_authenticator_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_programmable_transaction_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_programmable_transaction_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_programmable_transaction_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_programmable_transaction_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_publish_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_publish_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_publish_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_publish_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_randomness_state_update_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_randomness_state_update_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_randomness_state_update_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_randomness_state_update_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_secp256k1_public_key_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_secp256k1_public_key_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_secp256k1_public_key_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_secp256k1_public_key_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_secp256k1_signature_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_secp256k1_signature_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_secp256k1_signature_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_secp256k1_signature_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_secp256r1_public_key_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_secp256r1_public_key_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_secp256r1_public_key_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_secp256r1_public_key_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_secp256r1_signature_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_secp256r1_signature_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_secp256r1_signature_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_secp256r1_signature_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_signed_transaction_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_signed_transaction_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_signed_transaction_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_signed_transaction_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_simple_signature_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_simple_signature_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_simple_signature_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_simple_signature_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_split_coins_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_split_coins_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_split_coins_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_split_coins_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_string_from_bcs: (args: [ + /* input */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_string_from_json: (args: [ + /* input */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_string_to_bcs: (args: [ + /* input */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_string_to_json: (args: [ + /* input */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_struct_tag_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_struct_tag_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_struct_tag_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_struct_tag_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_system_package_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_system_package_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_system_package_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_system_package_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_transaction_effects_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_transaction_effects_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_transaction_effects_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_transaction_effects_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_transaction_effects_v1_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_transaction_effects_v1_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_transaction_effects_v1_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_transaction_effects_v1_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_transaction_events_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_transaction_events_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_transaction_events_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_transaction_events_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_transaction_expiration_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_transaction_expiration_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_transaction_expiration_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_transaction_expiration_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_transaction_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_transaction_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_transaction_kind_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_transaction_kind_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_transaction_kind_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_transaction_kind_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_transaction_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_transaction_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_transaction_v1_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_transaction_v1_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_transaction_v1_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_transaction_v1_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_transfer_objects_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_transfer_objects_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_transfer_objects_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_transfer_objects_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_type_argument_error_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_type_argument_error_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_type_argument_error_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_type_argument_error_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_type_origin_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_type_origin_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_type_origin_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_type_origin_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_type_tag_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_type_tag_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_type_tag_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_type_tag_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_u16_from_bcs: (args: [ + /* input */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_func_u16_from_json: (args: [ + /* input */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_func_u16_to_bcs: (args: [ + /* input */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_u16_to_json: (args: [ + /* input */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_u32_from_bcs: (args: [ + /* input */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_func_u32_from_json: (args: [ + /* input */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_func_u32_to_bcs: (args: [ + /* input */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_u32_to_json: (args: [ + /* input */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_u64_from_bcs: (args: [ + /* input */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_func_u64_from_json: (args: [ + /* input */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>bigint, + uniffi_iota_sdk_ffi_fn_func_u64_to_bcs: (args: [ + /* input */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_u64_to_json: (args: [ + /* input */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_u8_from_bcs: (args: [ + /* input */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_func_u8_from_json: (args: [ + /* input */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>number, + uniffi_iota_sdk_ffi_fn_func_u8_to_bcs: (args: [ + /* input */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_u8_to_json: (args: [ + /* input */ number, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_unchanged_shared_kind_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_unchanged_shared_kind_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_unchanged_shared_kind_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_unchanged_shared_kind_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_unchanged_shared_object_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_unchanged_shared_object_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_unchanged_shared_object_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_unchanged_shared_object_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_upgrade_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_upgrade_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_upgrade_info_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_upgrade_info_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_upgrade_info_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_upgrade_info_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_upgrade_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_upgrade_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_user_signature_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_user_signature_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_user_signature_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_user_signature_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_validator_aggregated_signature_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_validator_aggregated_signature_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_validator_aggregated_signature_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_validator_aggregated_signature_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_validator_committee_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_validator_committee_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_validator_committee_member_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_validator_committee_member_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_validator_committee_member_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_validator_committee_member_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_validator_committee_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_validator_committee_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_validator_execution_time_observation_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_validator_execution_time_observation_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_validator_execution_time_observation_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_validator_execution_time_observation_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_validator_signature_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_validator_signature_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_validator_signature_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_validator_signature_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_version_assignment_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_version_assignment_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_version_assignment_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_version_assignment_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_zk_login_authenticator_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_zk_login_authenticator_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_zk_login_authenticator_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_zk_login_authenticator_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_zk_login_claim_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_zk_login_claim_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_zk_login_claim_to_bcs: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_zk_login_claim_to_json: (args: [ + /* data */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_zk_login_proof_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_zk_login_proof_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_zk_login_proof_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_zk_login_proof_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_zk_login_public_identifier_from_bcs: (args: [ + /* bcs */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_zk_login_public_identifier_from_json: (args: [ + /* json */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + uniffi_iota_sdk_ffi_fn_func_zk_login_public_identifier_to_bcs: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + uniffi_iota_sdk_ffi_fn_func_zk_login_public_identifier_to_json: (args: [ + /* data */ /* RustArcPtr */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + ffi_iota_sdk_ffi_rustbuffer_alloc: (args: [ + /* size */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + ffi_iota_sdk_ffi_rustbuffer_from_bytes: (args: [ + /* bytes */ UniffiForeignBytes, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + ffi_iota_sdk_ffi_rustbuffer_free: (args: [ + /* buf */ /* RustBuffer */ UniffiRustBufferStruct, /* RustCallStatus */ JsExternal + ]) => + void, + ffi_iota_sdk_ffi_rustbuffer_reserve: (args: [ + /* buf */ /* RustBuffer */ UniffiRustBufferStruct, + /* additional */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + ffi_iota_sdk_ffi_rust_future_poll_u8: (args: [ + /* handle */ /* handle */ bigint, + /* callback */ /* callback UniffiCallbackRustFutureContinuationCallback */ JsExternal, + /* callback_data */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_cancel_u8: (args: [ + /* handle */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_free_u8: (args: [ + /* handle */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_complete_u8: (args: [ + /* handle */ /* handle */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + ffi_iota_sdk_ffi_rust_future_poll_i8: (args: [ + /* handle */ /* handle */ bigint, + /* callback */ /* callback UniffiCallbackRustFutureContinuationCallback */ JsExternal, + /* callback_data */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_cancel_i8: (args: [ + /* handle */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_free_i8: (args: [ + /* handle */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_complete_i8: (args: [ + /* handle */ /* handle */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + ffi_iota_sdk_ffi_rust_future_poll_u16: (args: [ + /* handle */ /* handle */ bigint, + /* callback */ /* callback UniffiCallbackRustFutureContinuationCallback */ JsExternal, + /* callback_data */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_cancel_u16: (args: [ + /* handle */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_free_u16: (args: [ + /* handle */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_complete_u16: (args: [ + /* handle */ /* handle */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + ffi_iota_sdk_ffi_rust_future_poll_i16: (args: [ + /* handle */ /* handle */ bigint, + /* callback */ /* callback UniffiCallbackRustFutureContinuationCallback */ JsExternal, + /* callback_data */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_cancel_i16: (args: [ + /* handle */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_free_i16: (args: [ + /* handle */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_complete_i16: (args: [ + /* handle */ /* handle */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + ffi_iota_sdk_ffi_rust_future_poll_u32: (args: [ + /* handle */ /* handle */ bigint, + /* callback */ /* callback UniffiCallbackRustFutureContinuationCallback */ JsExternal, + /* callback_data */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_cancel_u32: (args: [ + /* handle */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_free_u32: (args: [ + /* handle */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_complete_u32: (args: [ + /* handle */ /* handle */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + ffi_iota_sdk_ffi_rust_future_poll_i32: (args: [ + /* handle */ /* handle */ bigint, + /* callback */ /* callback UniffiCallbackRustFutureContinuationCallback */ JsExternal, + /* callback_data */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_cancel_i32: (args: [ + /* handle */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_free_i32: (args: [ + /* handle */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_complete_i32: (args: [ + /* handle */ /* handle */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + ffi_iota_sdk_ffi_rust_future_poll_u64: (args: [ + /* handle */ /* handle */ bigint, + /* callback */ /* callback UniffiCallbackRustFutureContinuationCallback */ JsExternal, + /* callback_data */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_cancel_u64: (args: [ + /* handle */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_free_u64: (args: [ + /* handle */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_complete_u64: (args: [ + /* handle */ /* handle */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + ffi_iota_sdk_ffi_rust_future_poll_i64: (args: [ + /* handle */ /* handle */ bigint, + /* callback */ /* callback UniffiCallbackRustFutureContinuationCallback */ JsExternal, + /* callback_data */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_cancel_i64: (args: [ + /* handle */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_free_i64: (args: [ + /* handle */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_complete_i64: (args: [ + /* handle */ /* handle */ bigint, /* RustCallStatus */ JsExternal + ]) =>bigint, + ffi_iota_sdk_ffi_rust_future_poll_f32: (args: [ + /* handle */ /* handle */ bigint, + /* callback */ /* callback UniffiCallbackRustFutureContinuationCallback */ JsExternal, + /* callback_data */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_cancel_f32: (args: [ + /* handle */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_free_f32: (args: [ + /* handle */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_complete_f32: (args: [ + /* handle */ /* handle */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + ffi_iota_sdk_ffi_rust_future_poll_f64: (args: [ + /* handle */ /* handle */ bigint, + /* callback */ /* callback UniffiCallbackRustFutureContinuationCallback */ JsExternal, + /* callback_data */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_cancel_f64: (args: [ + /* handle */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_free_f64: (args: [ + /* handle */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_complete_f64: (args: [ + /* handle */ /* handle */ bigint, /* RustCallStatus */ JsExternal + ]) =>number, + ffi_iota_sdk_ffi_rust_future_poll_pointer: (args: [ + /* handle */ /* handle */ bigint, + /* callback */ /* callback UniffiCallbackRustFutureContinuationCallback */ JsExternal, + /* callback_data */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_cancel_pointer: (args: [ + /* handle */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_free_pointer: (args: [ + /* handle */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_complete_pointer: (args: [ + /* handle */ /* handle */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustArcPtr */ bigint, + ffi_iota_sdk_ffi_rust_future_poll_rust_buffer: (args: [ + /* handle */ /* handle */ bigint, + /* callback */ /* callback UniffiCallbackRustFutureContinuationCallback */ JsExternal, + /* callback_data */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer: (args: [ + /* handle */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_free_rust_buffer: (args: [ + /* handle */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_complete_rust_buffer: (args: [ + /* handle */ /* handle */ bigint, /* RustCallStatus */ JsExternal + ]) =>/* RustBuffer */ UniffiRustBufferStruct, + ffi_iota_sdk_ffi_rust_future_poll_void: (args: [ + /* handle */ /* handle */ bigint, + /* callback */ /* callback UniffiCallbackRustFutureContinuationCallback */ JsExternal, + /* callback_data */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_cancel_void: (args: [ + /* handle */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_free_void: (args: [ + /* handle */ /* handle */ bigint + ]) => + void, + ffi_iota_sdk_ffi_rust_future_complete_void: (args: [ + /* handle */ /* handle */ bigint, /* RustCallStatus */ JsExternal + ]) => + void, + uniffi_iota_sdk_ffi_checksum_func_active_jwk_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_active_jwk_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_active_jwk_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_active_jwk_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_address_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_address_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_address_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_address_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_argument_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_argument_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_argument_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_argument_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_authenticator_state_expire_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_authenticator_state_expire_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_authenticator_state_expire_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_authenticator_state_expire_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_authenticator_state_update_v1_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_authenticator_state_update_v1_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_authenticator_state_update_v1_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_authenticator_state_update_v1_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_base64_decode: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_base64_encode: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_bls12381_public_key_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_bls12381_public_key_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_bls12381_public_key_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_bls12381_public_key_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_bls12381_signature_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_bls12381_signature_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_bls12381_signature_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_bls12381_signature_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_bn254_field_element_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_bn254_field_element_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_bn254_field_element_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_bn254_field_element_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_bool_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_bool_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_bool_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_bool_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_cancelled_transaction_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_cancelled_transaction_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_cancelled_transaction_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_cancelled_transaction_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_change_epoch_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_change_epoch_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_change_epoch_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_change_epoch_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_change_epoch_v2_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_change_epoch_v2_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_change_epoch_v2_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_change_epoch_v2_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_changed_object_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_changed_object_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_changed_object_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_changed_object_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_commitment_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_commitment_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_commitment_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_commitment_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_contents_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_contents_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_contents_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_contents_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_summary_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_summary_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_summary_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_summary_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_transaction_info_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_transaction_info_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_transaction_info_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_checkpoint_transaction_info_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_circom_g1_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_circom_g1_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_circom_g1_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_circom_g1_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_circom_g2_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_circom_g2_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_circom_g2_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_circom_g2_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_command_argument_error_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_command_argument_error_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_command_argument_error_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_command_argument_error_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_command_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_command_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_command_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_command_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_consensus_commit_prologue_v1_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_consensus_commit_prologue_v1_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_consensus_commit_prologue_v1_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_consensus_commit_prologue_v1_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_consensus_determined_version_assignments_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_consensus_determined_version_assignments_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_consensus_determined_version_assignments_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_consensus_determined_version_assignments_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_digest_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_digest_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_digest_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_digest_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_ed25519_public_key_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_ed25519_public_key_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_ed25519_public_key_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_ed25519_public_key_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_ed25519_signature_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_ed25519_signature_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_ed25519_signature_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_ed25519_signature_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_end_of_epoch_data_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_end_of_epoch_data_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_end_of_epoch_data_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_end_of_epoch_data_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_event_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_event_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_event_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_event_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_execution_error_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_execution_error_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_execution_error_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_execution_error_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_execution_status_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_execution_status_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_execution_status_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_execution_status_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_execution_time_observation_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_execution_time_observation_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_execution_time_observation_key_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_execution_time_observation_key_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_execution_time_observation_key_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_execution_time_observation_key_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_execution_time_observation_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_execution_time_observation_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_execution_time_observations_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_execution_time_observations_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_execution_time_observations_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_execution_time_observations_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_gas_cost_summary_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_gas_cost_summary_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_gas_cost_summary_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_gas_cost_summary_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_gas_payment_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_gas_payment_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_gas_payment_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_gas_payment_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_generate_mnemonic: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_genesis_object_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_genesis_object_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_genesis_object_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_genesis_object_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_genesis_transaction_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_genesis_transaction_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_genesis_transaction_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_genesis_transaction_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_hex_decode: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_hex_encode: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_i16_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_i16_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_i16_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_i16_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_i32_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_i32_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_i32_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_i32_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_i64_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_i64_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_i64_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_i64_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_i8_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_i8_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_i8_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_i8_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_id_operation_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_id_operation_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_id_operation_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_id_operation_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_identifier_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_identifier_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_identifier_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_identifier_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_input_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_input_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_input_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_input_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_jwk_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_jwk_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_jwk_id_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_jwk_id_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_jwk_id_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_jwk_id_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_jwk_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_jwk_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_make_move_vector_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_make_move_vector_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_make_move_vector_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_make_move_vector_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_merge_coins_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_merge_coins_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_merge_coins_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_merge_coins_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_move_call_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_move_call_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_move_call_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_move_call_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_move_location_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_move_location_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_move_location_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_move_location_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_move_package_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_move_package_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_move_package_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_move_package_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_move_struct_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_move_struct_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_move_struct_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_move_struct_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_multisig_aggregated_signature_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_multisig_aggregated_signature_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_multisig_aggregated_signature_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_multisig_aggregated_signature_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_multisig_committee_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_multisig_committee_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_multisig_committee_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_multisig_committee_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_multisig_member_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_multisig_member_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_multisig_member_public_key_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_multisig_member_public_key_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_multisig_member_public_key_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_multisig_member_public_key_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_multisig_member_signature_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_multisig_member_signature_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_multisig_member_signature_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_multisig_member_signature_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_multisig_member_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_multisig_member_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_object_data_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_object_data_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_object_data_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_object_data_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_object_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_object_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_object_id_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_object_id_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_object_id_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_object_id_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_object_in_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_object_in_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_object_in_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_object_in_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_object_out_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_object_out_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_object_out_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_object_out_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_object_reference_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_object_reference_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_object_reference_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_object_reference_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_object_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_object_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_owner_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_owner_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_owner_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_owner_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_package_upgrade_error_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_package_upgrade_error_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_package_upgrade_error_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_package_upgrade_error_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_passkey_authenticator_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_passkey_authenticator_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_passkey_authenticator_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_passkey_authenticator_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_programmable_transaction_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_programmable_transaction_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_programmable_transaction_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_programmable_transaction_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_publish_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_publish_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_publish_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_publish_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_randomness_state_update_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_randomness_state_update_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_randomness_state_update_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_randomness_state_update_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_secp256k1_public_key_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_secp256k1_public_key_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_secp256k1_public_key_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_secp256k1_public_key_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_secp256k1_signature_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_secp256k1_signature_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_secp256k1_signature_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_secp256k1_signature_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_secp256r1_public_key_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_secp256r1_public_key_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_secp256r1_public_key_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_secp256r1_public_key_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_secp256r1_signature_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_secp256r1_signature_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_secp256r1_signature_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_secp256r1_signature_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_signed_transaction_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_signed_transaction_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_signed_transaction_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_signed_transaction_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_simple_signature_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_simple_signature_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_simple_signature_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_simple_signature_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_split_coins_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_split_coins_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_split_coins_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_split_coins_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_string_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_string_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_string_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_string_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_struct_tag_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_struct_tag_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_struct_tag_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_struct_tag_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_system_package_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_system_package_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_system_package_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_system_package_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_effects_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_effects_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_effects_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_effects_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_effects_v1_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_effects_v1_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_effects_v1_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_effects_v1_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_events_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_events_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_events_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_events_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_expiration_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_expiration_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_expiration_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_expiration_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_kind_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_kind_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_kind_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_kind_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_v1_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_v1_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_v1_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transaction_v1_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transfer_objects_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transfer_objects_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transfer_objects_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_transfer_objects_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_type_argument_error_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_type_argument_error_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_type_argument_error_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_type_argument_error_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_type_origin_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_type_origin_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_type_origin_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_type_origin_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_type_tag_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_type_tag_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_type_tag_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_type_tag_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_u16_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_u16_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_u16_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_u16_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_u32_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_u32_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_u32_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_u32_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_u64_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_u64_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_u64_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_u64_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_u8_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_u8_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_u8_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_u8_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_unchanged_shared_kind_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_unchanged_shared_kind_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_unchanged_shared_kind_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_unchanged_shared_kind_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_unchanged_shared_object_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_unchanged_shared_object_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_unchanged_shared_object_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_unchanged_shared_object_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_upgrade_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_upgrade_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_upgrade_info_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_upgrade_info_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_upgrade_info_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_upgrade_info_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_upgrade_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_upgrade_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_user_signature_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_user_signature_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_user_signature_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_user_signature_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_validator_aggregated_signature_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_validator_aggregated_signature_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_validator_aggregated_signature_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_validator_aggregated_signature_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_validator_committee_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_validator_committee_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_validator_committee_member_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_validator_committee_member_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_validator_committee_member_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_validator_committee_member_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_validator_committee_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_validator_committee_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_validator_execution_time_observation_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_validator_execution_time_observation_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_validator_execution_time_observation_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_validator_execution_time_observation_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_validator_signature_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_validator_signature_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_validator_signature_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_validator_signature_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_version_assignment_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_version_assignment_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_version_assignment_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_version_assignment_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_zk_login_authenticator_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_zk_login_authenticator_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_zk_login_authenticator_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_zk_login_authenticator_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_zk_login_claim_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_zk_login_claim_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_zk_login_claim_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_zk_login_claim_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_zk_login_proof_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_zk_login_proof_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_zk_login_proof_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_zk_login_proof_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_zk_login_public_identifier_from_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_zk_login_public_identifier_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_zk_login_public_identifier_to_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_func_zk_login_public_identifier_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_address_to_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_address_to_canonical_string: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_address_to_hex: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_address_to_short_string: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_argument_get_nested_result: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_bls12381privatekey_public_key: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_bls12381privatekey_scheme: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_bls12381privatekey_sign_checkpoint_summary: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_bls12381privatekey_try_sign: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_bls12381privatekey_verifying_key: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_bls12381publickey_to_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_bls12381signature_to_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_bls12381verifyingkey_public_key: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_bls12381verifyingkey_verify: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_bn254fieldelement_padded: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_bn254fieldelement_unpadded: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_cancelledtransaction_digest: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_cancelledtransaction_version_assignments: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepoch_computation_charge: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepoch_epoch: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepoch_epoch_start_timestamp_ms: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepoch_non_refundable_storage_fee: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepoch_protocol_version: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepoch_storage_charge: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepoch_storage_rebate: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepoch_system_packages: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv2_computation_charge: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv2_computation_charge_burned: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv2_epoch: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv2_epoch_start_timestamp_ms: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv2_non_refundable_storage_fee: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv2_protocol_version: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv2_storage_charge: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv2_storage_rebate: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv2_system_packages: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv3_computation_charge: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv3_computation_charge_burned: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv3_eligible_active_validators: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv3_epoch: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv3_epoch_start_timestamp_ms: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv3_non_refundable_storage_fee: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv3_protocol_version: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv3_storage_charge: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv3_storage_rebate: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv3_system_packages: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv4_adjust_rewards_by_score: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv4_computation_charge: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv4_computation_charge_burned: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv4_eligible_active_validators: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv4_epoch: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv4_epoch_start_timestamp_ms: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv4_non_refundable_storage_fee: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv4_protocol_version: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv4_scores: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv4_storage_charge: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv4_storage_rebate: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_changeepochv4_system_packages: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_checkpointcommitment_as_ecmh_live_object_set_digest: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_checkpointcommitment_is_ecmh_live_object_set: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_checkpointcontents_digest: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_checkpointcontents_transaction_info: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_checkpointsummary_checkpoint_commitments: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_checkpointsummary_content_digest: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_checkpointsummary_digest: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_checkpointsummary_end_of_epoch_data: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_checkpointsummary_epoch: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_checkpointsummary_epoch_rolling_gas_cost_summary: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_checkpointsummary_network_total_transactions: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_checkpointsummary_previous_digest: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_checkpointsummary_sequence_number: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_checkpointsummary_signing_message: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_checkpointsummary_signing_message_hex: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_checkpointsummary_timestamp_ms: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_checkpointsummary_version_specific_data: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_checkpointtransactioninfo_effects: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_checkpointtransactioninfo_signatures: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_checkpointtransactioninfo_transaction: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_dry_run: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_execute: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_execute_with_sponsor: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_expiration: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_finish: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_gas: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_gas_budget: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_gas_price: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_gas_station_sponsor: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_make_move_vec: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_merge_coins: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_move_call: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_publish: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_send_coins: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_send_iota: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_set_sender: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_split_coins: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_sponsor: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_stake: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_transfer_objects: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_unstake: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_clienttransactionbuilder_upgrade: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_coin_balance: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_coin_coin_type: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_coin_id: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_consensuscommitprologuev1_commit_timestamp_ms: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_consensuscommitprologuev1_consensus_commit_digest: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_consensuscommitprologuev1_consensus_determined_version_assignments: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_consensuscommitprologuev1_epoch: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_consensuscommitprologuev1_round: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_consensuscommitprologuev1_sub_dag_index: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_consensusdeterminedversionassignments_as_cancelled_transactions: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_consensusdeterminedversionassignments_is_cancelled_transactions: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_digest_next_lexicographical: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_digest_to_base58: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_digest_to_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_ed25519privatekey_public_key: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_ed25519privatekey_scheme: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_ed25519privatekey_sign_personal_message: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_ed25519privatekey_sign_transaction: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_ed25519privatekey_to_bech32: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_ed25519privatekey_to_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_ed25519privatekey_to_der: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_ed25519privatekey_to_pem: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_ed25519privatekey_try_sign: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_ed25519privatekey_try_sign_simple: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_ed25519privatekey_try_sign_user: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_ed25519privatekey_verifying_key: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_ed25519publickey_derive_address: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_ed25519publickey_scheme: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_ed25519publickey_to_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_ed25519publickey_to_flagged_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_ed25519signature_to_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_ed25519verifier_verify_simple: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_ed25519verifier_verify_user: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_ed25519verifyingkey_public_key: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_ed25519verifyingkey_to_der: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_ed25519verifyingkey_to_pem: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_ed25519verifyingkey_verify: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_ed25519verifyingkey_verify_simple: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_ed25519verifyingkey_verify_user: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_executiontimeobservation_key: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_executiontimeobservation_observations: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_faucetclient_request: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_faucetclient_request_and_wait: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_faucetclient_request_and_wait_for_finalized: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_faucetclient_request_status: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_genesisobject_data: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_genesisobject_object_id: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_genesisobject_object_type: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_genesisobject_owner: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_genesisobject_version: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_genesistransaction_events: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_genesistransaction_objects: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_active_validators: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_balance: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_chain_id: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_checkpoint: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_checkpoints: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_coin_metadata: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_coins: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_dry_run_tx: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_dry_run_tx_kind: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_dynamic_field: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_dynamic_fields: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_dynamic_object_field: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_epoch: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_epoch_total_checkpoints: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_epoch_total_transaction_blocks: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_events: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_execute_tx: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_gas_coins: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_iota_names_default_name: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_iota_names_lookup: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_iota_names_registrations: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_is_tx_finalized: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_is_tx_indexed_on_node: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_latest_checkpoint_sequence_number: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_max_page_size: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_move_object_contents: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_move_object_contents_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_move_view_call: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_move_view_call_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_normalized_move_function: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_normalized_move_module: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_object: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_object_bcs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_objects: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_package: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_package_latest: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_package_versions: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_packages: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_protocol_config: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_reference_gas_price: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_run_query: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_service_config: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_set_rpc_server: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_total_supply: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_total_transaction_blocks: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_total_transaction_blocks_by_digest: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_total_transaction_blocks_by_seq_num: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_transaction: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_transaction_data_effects: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_transaction_effects: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_transactions: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_transactions_data_effects: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_transactions_effects: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_graphqlclient_wait_for_tx: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_identifier_as_str: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_intent_app_id: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_intent_scope: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_intent_to_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_intent_version: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_makemovevector_elements: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_makemovevector_type_tag: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_mergecoins_coin: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_mergecoins_coins_to_merge: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_moveauthenticator_address: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_moveauthenticator_call_args: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_moveauthenticator_object_to_authenticate: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_moveauthenticator_type_args: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_moveauthenticatorbuilder_finish: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_movecall_arguments: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_movecall_function: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_movecall_module: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_movecall_package: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_movecall_type_arguments: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_movefunction_is_entry: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_movefunction_name: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_movefunction_parameters: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_movefunction_return_type: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_movefunction_type_parameters: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_movefunction_visibility: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_movepackage_id: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_movepackage_linkage_table: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_movepackage_modules: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_movepackage_type_origin_table: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_movepackage_version: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_movepackagedata_dependencies: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_movepackagedata_digest: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_movepackagedata_modules: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_movepackagedata_to_base64: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_movepackagedata_to_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigaggregatedsignature_bitmap: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigaggregatedsignature_committee: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigaggregatedsignature_signatures: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigaggregator_finish: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigaggregator_verifier: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigaggregator_with_signature: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigaggregator_with_verifier: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigcommittee_derive_address: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigcommittee_is_valid: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigcommittee_members: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigcommittee_scheme: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigcommittee_threshold: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmember_public_key: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmember_weight: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_ed25519: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_ed25519_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_secp256k1: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_secp256k1_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_secp256r1: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_secp256r1_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_zklogin: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_zklogin_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_is_ed25519: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_is_secp256k1: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_is_secp256r1: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_is_zklogin: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_scheme: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_ed25519: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_ed25519_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_secp256k1: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_secp256k1_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_secp256r1: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_secp256r1_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_zklogin: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_zklogin_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_is_ed25519: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_is_secp256k1: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_is_secp256r1: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_is_zklogin: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigverifier_verify: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigverifier_with_zklogin_verifier: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_multisigverifier_zklogin_verifier: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_name_format: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_name_is_sln: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_name_is_subname: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_name_label: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_name_labels: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_name_num_labels: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_name_parent: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_nameregistration_expiration_timestamp_ms: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_nameregistration_id: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_nameregistration_name: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_nameregistration_name_str: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_object_as_package: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_object_as_package_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_object_as_struct: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_object_as_struct_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_object_data: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_object_digest: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_object_object_id: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_object_object_ref: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_object_object_type: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_object_owner: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_object_previous_transaction: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_object_storage_rebate: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_object_version: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_objectdata_as_package_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_objectdata_as_struct_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_objectdata_is_package: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_objectdata_is_struct: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_objectid_derive_dynamic_child_id: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_objectid_to_address: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_objectid_to_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_objectid_to_canonical_string: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_objectid_to_hex: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_objectid_to_short_string: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_objecttype_as_struct: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_objecttype_as_struct_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_objecttype_is_package: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_objecttype_is_struct: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_owner_as_address: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_owner_as_address_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_owner_as_object: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_owner_as_object_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_owner_as_shared: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_owner_as_shared_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_owner_is_address: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_owner_is_immutable: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_owner_is_object: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_owner_is_shared: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_passkeyauthenticator_authenticator_data: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_passkeyauthenticator_challenge: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_passkeyauthenticator_client_data_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_passkeyauthenticator_public_key: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_passkeyauthenticator_signature: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_passkeypublickey_derive_address: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_passkeypublickey_inner: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_passkeyverifier_verify: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_personalmessage_message_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_personalmessage_signing_digest: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_personalmessage_signing_digest_hex: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_programmabletransaction_commands: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_programmabletransaction_inputs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_publish_dependencies: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_publish_modules: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256k1privatekey_public_key: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256k1privatekey_scheme: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256k1privatekey_sign_personal_message: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256k1privatekey_sign_transaction: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256k1privatekey_to_bech32: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256k1privatekey_to_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256k1privatekey_to_der: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256k1privatekey_to_pem: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256k1privatekey_try_sign: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256k1privatekey_try_sign_simple: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256k1privatekey_try_sign_user: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256k1privatekey_verifying_key: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256k1publickey_derive_address: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256k1publickey_scheme: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256k1publickey_to_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256k1publickey_to_flagged_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256k1signature_to_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256k1verifier_verify_simple: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256k1verifier_verify_user: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256k1verifyingkey_public_key: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256k1verifyingkey_to_der: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256k1verifyingkey_to_pem: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256k1verifyingkey_verify: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256k1verifyingkey_verify_simple: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256k1verifyingkey_verify_user: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256r1privatekey_public_key: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256r1privatekey_scheme: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256r1privatekey_sign_personal_message: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256r1privatekey_sign_transaction: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256r1privatekey_to_bech32: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256r1privatekey_to_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256r1privatekey_to_der: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256r1privatekey_to_pem: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256r1privatekey_try_sign: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256r1privatekey_try_sign_simple: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256r1privatekey_try_sign_user: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256r1privatekey_verifying_key: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256r1publickey_derive_address: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256r1publickey_scheme: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256r1publickey_to_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256r1publickey_to_flagged_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256r1signature_to_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256r1verifier_verify_simple: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256r1verifier_verify_user: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256r1verifyingkey_public_key: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256r1verifyingkey_to_der: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256r1verifyingkey_to_pem: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256r1verifyingkey_verify: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256r1verifyingkey_verify_simple: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_secp256r1verifyingkey_verify_user: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplekeypair_public_key: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplekeypair_scheme: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplekeypair_sign_personal_message: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplekeypair_sign_transaction: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplekeypair_to_bech32: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplekeypair_to_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplekeypair_to_der: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplekeypair_to_pem: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplekeypair_try_sign: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplekeypair_try_sign_user: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplekeypair_verifying_key: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_ed25519_pub_key: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_ed25519_pub_key_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_ed25519_sig: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_ed25519_sig_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_is_ed25519: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_is_secp256k1: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_is_secp256r1: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_scheme: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256k1_pub_key: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256k1_pub_key_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256k1_sig: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256k1_sig_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256r1_pub_key: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256r1_pub_key_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256r1_sig: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256r1_sig_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simplesignature_to_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simpleverifier_verify: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simpleverifyingkey_public_key: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simpleverifyingkey_scheme: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simpleverifyingkey_to_der: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simpleverifyingkey_to_pem: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_simpleverifyingkey_verify: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_splitcoins_amounts: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_splitcoins_coin: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_structtag_address: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_structtag_coin_type: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_structtag_coin_type_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_structtag_module: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_structtag_name: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_structtag_to_canonical_string: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_structtag_type_args: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_systempackage_dependencies: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_systempackage_modules: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_systempackage_version: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transaction_as_v1: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transaction_digest: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transaction_expiration: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transaction_gas_payment: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transaction_kind: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transaction_sender: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transaction_signing_digest: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transaction_signing_digest_hex: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transaction_to_base64: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_execute_with_gas_station: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_expiration: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_finish: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_gas: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_gas_budget: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_gas_price: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_gas_station_sponsor: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_make_move_vec: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_merge_coins: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_move_call: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_publish: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_send_coins: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_send_iota: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_set_sender: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_split_coins: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_sponsor: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_stake: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_transfer_objects: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_unstake: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_upgrade: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionbuilder_with_client: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactioneffects_as_v1: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactioneffects_digest: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactioneffects_is_v1: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionevents_digest: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionevents_events: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionsigner_sign: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionsignerfn_sign: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionv1_digest: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionv1_expiration: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionv1_gas_payment: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionv1_kind: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionv1_sender: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionv1_signing_digest: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionv1_signing_digest_hex: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transactionv1_to_base64: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transferobjects_address: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_transferobjects_objects: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_typetag_as_struct_tag: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_typetag_as_struct_tag_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_typetag_as_vector_type_tag: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_typetag_as_vector_type_tag_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_typetag_is_address: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_typetag_is_bool: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_typetag_is_signer: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_typetag_is_struct: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_typetag_is_u128: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_typetag_is_u16: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_typetag_is_u256: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_typetag_is_u32: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_typetag_is_u64: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_typetag_is_u8: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_typetag_is_vector: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_typetag_to_canonical_string: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_upgrade_dependencies: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_upgrade_modules: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_upgrade_package: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_upgrade_ticket: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_upgradepolicy_as_u8: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_usersignature_as_move_authenticator: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_usersignature_as_move_authenticator_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_usersignature_as_multisig: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_usersignature_as_multisig_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_usersignature_as_passkey_authenticator: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_usersignature_as_passkey_authenticator_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_usersignature_as_simple: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_usersignature_as_simple_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_usersignature_as_zklogin_authenticator: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_usersignature_as_zklogin_authenticator_opt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_usersignature_is_move_authenticator: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_usersignature_is_multisig: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_usersignature_is_passkey_authenticator: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_usersignature_is_simple: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_usersignature_is_zklogin_authenticator: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_usersignature_scheme: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_usersignature_to_base64: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_usersignature_to_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_usersignatureverifier_verify: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_usersignatureverifier_with_zklogin_verifier: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_usersignatureverifier_zklogin_verifier: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_validatoraggregatedsignature_bitmap_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_validatoraggregatedsignature_epoch: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_validatoraggregatedsignature_signature: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_validatorcommitteesignatureaggregator_add_signature: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_validatorcommitteesignatureaggregator_committee: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_validatorcommitteesignatureaggregator_finish: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_validatorcommitteesignatureverifier_committee: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_validatorcommitteesignatureverifier_verify: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_validatorcommitteesignatureverifier_verify_aggregated: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_validatorcommitteesignatureverifier_verify_checkpoint_summary: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_validatorexecutiontimeobservation_duration: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_validatorexecutiontimeobservation_validator: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_validatorsignature_epoch: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_validatorsignature_public_key: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_validatorsignature_signature: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_versionassignment_object_id: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_versionassignment_version: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_zkloginauthenticator_inputs: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_zkloginauthenticator_max_epoch: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_zkloginauthenticator_signature: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_zklogininputs_address_seed: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_zklogininputs_header_base64: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_zklogininputs_iss: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_zklogininputs_iss_base64_details: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_zklogininputs_jwk_id: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_zklogininputs_proof_points: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_zklogininputs_public_identifier: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_zkloginproof_a: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_zkloginproof_b: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_zkloginproof_c: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_zkloginpublicidentifier_address_seed: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_zkloginpublicidentifier_derive_address: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_zkloginpublicidentifier_derive_address_padded: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_zkloginpublicidentifier_derive_address_unpadded: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_zkloginpublicidentifier_iss: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_zkloginverifier_jwks: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_zkloginverifier_verify: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_method_zkloginverifier_with_jwks: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_address_framework: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_address_from_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_address_from_hex: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_address_generate: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_address_std: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_address_system: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_address_zero: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_argument_new_gas: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_argument_new_input: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_argument_new_nested_result: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_argument_new_result: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_bls12381privatekey_generate: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_bls12381privatekey_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_bls12381publickey_from_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_bls12381publickey_from_str: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_bls12381publickey_generate: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_bls12381signature_from_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_bls12381signature_from_str: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_bls12381signature_generate: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_bls12381verifyingkey_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_bn254fieldelement_from_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_bn254fieldelement_from_str: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_bn254fieldelement_from_str_radix_10: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_cancelledtransaction_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_changeepoch_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_changeepochv2_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_changeepochv3_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_changeepochv4_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_checkpointcontents_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_checkpointsummary_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_checkpointtransactioninfo_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_circomg1_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_circomg2_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_coin_try_from_object: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_command_new_make_move_vector: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_command_new_merge_coins: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_command_new_move_call: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_command_new_publish: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_command_new_split_coins: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_command_new_transfer_objects: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_command_new_upgrade: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_consensuscommitprologuev1_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_consensusdeterminedversionassignments_new_cancelled_transactions: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_digest_from_base58: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_digest_from_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_digest_generate: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519privatekey_from_bech32: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519privatekey_from_der: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519privatekey_from_mnemonic: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519privatekey_from_mnemonic_with_path: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519privatekey_from_pem: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519privatekey_generate: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519privatekey_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519publickey_from_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519publickey_from_str: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519publickey_generate: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519signature_from_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519signature_from_str: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519signature_generate: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519verifier_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519verifyingkey_from_der: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519verifyingkey_from_pem: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ed25519verifyingkey_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_endofepochtransactionkind_new_authenticator_state_create: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_endofepochtransactionkind_new_authenticator_state_expire: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_endofepochtransactionkind_new_change_epoch: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_endofepochtransactionkind_new_change_epoch_v2: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_endofepochtransactionkind_new_change_epoch_v3: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_endofepochtransactionkind_new_change_epoch_v4: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservation_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_make_move_vec: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_merge_coins: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_move_entry_point: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_publish: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_split_coins: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_transfer_objects: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_upgrade: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservations_new_v1: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_faucetclient_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_faucetclient_new_devnet: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_faucetclient_new_localnet: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_faucetclient_new_testnet: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_genesisobject_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_genesistransaction_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_graphqlclient_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_graphqlclient_new_devnet: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_graphqlclient_new_localnet: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_graphqlclient_new_mainnet: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_graphqlclient_new_testnet: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_identifier_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_input_new_immutable_or_owned: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_input_new_pure: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_input_new_receiving: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_input_new_shared: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_intent_from_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_intent_from_hex: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_intent_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_intent_new_consensus_app: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_intent_new_iota_app: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_intent_new_iota_transaction: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_intent_new_personal_message: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_makemovevector_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_mergecoins_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_address: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_address_from_hex: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_address_vec: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_address_vec_from_hex: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_bool: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_bool_vec: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_digest: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_digest_from_base58: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_digest_vec: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_digest_vec_from_base58: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_option: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_string: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_string_vec: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_u128: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_u128_vec: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_u16: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_u16_vec: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_u256: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_u256_vec: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_u32: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_u32_vec: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_u64: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_u64_vec: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_u8: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movearg_u8_vec: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_moveauthenticator_new_immutable: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_moveauthenticator_new_shared: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_moveauthenticatorbuilder_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movecall_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movepackage_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movepackagedata_from_base64: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movepackagedata_from_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_movepackagedata_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_address: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_bool: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_json: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_null: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_object_id: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_option: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_string: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_string_vec: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_u128: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_u16: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_u32: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_u64: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_u8: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_moveviewarg_u8_vec: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_multisigaggregatedsignature_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_multisigaggregator_new_with_message: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_multisigaggregator_new_with_transaction: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_multisigcommittee_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_multisigmember_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_multisigverifier_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_name_from_str: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_nameregistration_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_object_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_objectdata_new_move_package: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_objectdata_new_move_struct: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_objectid_clock: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_objectid_derive_id: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_objectid_from_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_objectid_from_hex: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_objectid_system: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_objectid_zero: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_objecttype_new_package: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_objecttype_new_struct: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_owner_new_address: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_owner_new_immutable: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_owner_new_object: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_owner_new_shared: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_address: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_address_from_hex: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_address_vec: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_address_vec_from_hex: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_assigned: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_bool: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_bool_vec: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_digest: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_digest_from_base58: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_digest_vec: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_digest_vec_from_base58: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_gas: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_move_arg: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_object_id: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_object_id_from_hex: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_object_ref: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_option: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_receiving: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_receiving_from_hex: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_shared: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_shared_from_hex: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_shared_mut: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_shared_mut_from_hex: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_string: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_u128: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_u128_vec: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_u16: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_u16_vec: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_u256: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_u256_vec: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_u32: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_u32_vec: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_u64: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_u64_vec: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_u8: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_ptbargument_u8_vec: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_passkeypublickey_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_passkeyverifier_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_personalmessage_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_programmabletransaction_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_publish_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1privatekey_from_bech32: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1privatekey_from_der: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1privatekey_from_mnemonic: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1privatekey_from_mnemonic_with_path: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1privatekey_from_pem: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1privatekey_generate: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1privatekey_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1publickey_from_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1publickey_from_str: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1publickey_generate: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1signature_from_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1signature_from_str: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1signature_generate: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1verifier_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1verifyingkey_from_der: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1verifyingkey_from_pem: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256k1verifyingkey_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1privatekey_from_bech32: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1privatekey_from_der: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1privatekey_from_mnemonic: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1privatekey_from_mnemonic_with_path: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1privatekey_from_pem: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1privatekey_generate: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1privatekey_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1publickey_from_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1publickey_from_str: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1publickey_generate: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1signature_from_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1signature_from_str: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1signature_generate: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1verifier_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1verifyingkey_from_der: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1verifyingkey_from_pem: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_secp256r1verifyingkey_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_simplekeypair_from_bech32: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_simplekeypair_from_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_simplekeypair_from_der: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_simplekeypair_from_ed25519: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_simplekeypair_from_pem: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_simplekeypair_from_secp256k1: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_simplekeypair_from_secp256r1: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_simplesignature_new_ed25519: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_simplesignature_new_secp256k1: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_simplesignature_new_secp256r1: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_simpleverifier_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_simpleverifyingkey_from_der: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_simpleverifyingkey_from_pem: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_splitcoins_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_ascii_string: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_balance: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_clock: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_coin: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_coin_manager: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_coin_metadata: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_config: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_config_setting: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_deny_list_address_key: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_deny_list_config_key: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_deny_list_global_pause_key: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_display_created: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_dynamic_object_field_wrapper: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_field: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_gas_coin: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_id: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_iota_coin_type: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_iota_system_admin_cap: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_iota_system_state: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_iota_treasury_cap: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_name: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_staked_iota: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_string: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_system_epoch_info_event: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_time_lock: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_timelocked_staked_iota: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_transfer_receiving: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_treasury_cap: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_uid: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_upgrade_cap: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_upgrade_receipt: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_upgrade_ticket: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_structtag_new_version_updated: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_systempackage_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_transaction_from_base64: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_transaction_new_v1: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_transactionbuilder_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_transactioneffects_new_v1: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_transactionevents_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_transactionkind_new_authenticator_state_update_v1: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_transactionkind_new_consensus_commit_prologue_v1: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_transactionkind_new_end_of_epoch: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_transactionkind_new_genesis: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_transactionkind_new_programmable_transaction: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_transactionkind_new_randomness_state_update: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_transactionsigner_from_ed25519: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_transactionsigner_from_keypair: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_transactionsigner_from_move_authenticator: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_transactionsigner_from_secp256k1: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_transactionsigner_from_secp256r1: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_transactionsigner_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_transactionv1_from_base64: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_transactionv1_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_transferobjects_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_typetag_new_address: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_typetag_new_bool: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_typetag_new_signer: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_typetag_new_struct: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_typetag_new_u128: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_typetag_new_u16: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_typetag_new_u256: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_typetag_new_u32: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_typetag_new_u64: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_typetag_new_u8: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_typetag_new_vector: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_upgrade_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_upgradepolicy_additive: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_upgradepolicy_compatible: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_upgradepolicy_dep_only: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_usersignature_from_base64: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_usersignature_from_bytes: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_usersignature_new_move_authenticator: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_usersignature_new_multisig: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_usersignature_new_passkey_authenticator: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_usersignature_new_simple: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_usersignature_new_zklogin_authenticator: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_usersignatureverifier_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_validatoraggregatedsignature_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_validatorcommitteesignatureaggregator_new_checkpoint_summary: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_validatorcommitteesignatureverifier_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_validatorexecutiontimeobservation_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_validatorsignature_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_versionassignment_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_zkloginauthenticator_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_zklogininputs_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_zkloginproof_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_zkloginpublicidentifier_new: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_zkloginverifier_new_dev: (args: [ + ]) =>number, + uniffi_iota_sdk_ffi_checksum_constructor_zkloginverifier_new_mainnet: (args: [ + ]) =>number, + ffi_iota_sdk_ffi_uniffi_contract_version: (args: [ + ]) =>number, +}; + +export default FFI_DYNAMIC_LIB; \ No newline at end of file diff --git a/bindings/typescript/lib/package.json b/bindings/typescript/lib/package.json new file mode 100644 index 0000000000..6ce398a922 --- /dev/null +++ b/bindings/typescript/lib/package.json @@ -0,0 +1,17 @@ +{ + "name": "libiota-sdk-ffi", + "description": "Uniffi wrapper around the iota_sdk_ffi rust crate.", + "engines": { + "node": "^18" + }, + "dependencies": { + "ffi-rs": "^1.3.0", + "ref-napi": "^3.0.3", + "uniffi-bindgen-react-native": "^0.29.3-1" + }, + + "devDependencies": { + "@types/node": "^18", + "@types/ref-napi": "^3.0.12" + } +} \ No newline at end of file diff --git a/bindings/typescript/package-lock.json b/bindings/typescript/package-lock.json new file mode 100644 index 0000000000..0d16fd0703 --- /dev/null +++ b/bindings/typescript/package-lock.json @@ -0,0 +1,904 @@ +{ + "name": "@iota/sdk", + "version": "0.0.1-alpha.1", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "@iota/sdk", + "version": "0.0.1-alpha.1", + "license": "Apache-2.0", + "dependencies": { + "ffi-rs": "^1.3.0", + "ref-napi": "^3.0.3", + "uniffi-bindgen-react-native": "^0.29.3-1" + }, + "devDependencies": { + "@types/node": "^22.0.0", + "@types/ref-napi": "^3.0.12", + "prettier": "^3.3.0", + "tsx": "^4.19.0", + "typescript": "^5.5.0" + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.3.tgz", + "integrity": "sha512-9fJMTNFTWZMh5qwrBItuziu834eOCUcEqymSH7pY+zoMVEZg3gcPuBNxH1EvfVYe9h0x/Ptw8KBzv7qxb7l8dg==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.3.tgz", + "integrity": "sha512-i5D1hPY7GIQmXlXhs2w8AWHhenb00+GxjxRncS2ZM7YNVGNfaMxgzSGuO8o8SJzRc/oZwU2bcScvVERk03QhzA==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.3.tgz", + "integrity": "sha512-YdghPYUmj/FX2SYKJ0OZxf+iaKgMsKHVPF1MAq/P8WirnSpCStzKJFjOjzsW0QQ7oIAiccHdcqjbHmJxRb/dmg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.3.tgz", + "integrity": "sha512-IN/0BNTkHtk8lkOM8JWAYFg4ORxBkZQf9zXiEOfERX/CzxW3Vg1ewAhU7QSWQpVIzTW+b8Xy+lGzdYXV6UZObQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.3.tgz", + "integrity": "sha512-Re491k7ByTVRy0t3EKWajdLIr0gz2kKKfzafkth4Q8A5n1xTHrkqZgLLjFEHVD+AXdUGgQMq+Godfq45mGpCKg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.3.tgz", + "integrity": "sha512-vHk/hA7/1AckjGzRqi6wbo+jaShzRowYip6rt6q7VYEDX4LEy1pZfDpdxCBnGtl+A5zq8iXDcyuxwtv3hNtHFg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.3.tgz", + "integrity": "sha512-ipTYM2fjt3kQAYOvo6vcxJx3nBYAzPjgTCk7QEgZG8AUO3ydUhvelmhrbOheMnGOlaSFUoHXB6un+A7q4ygY9w==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.3.tgz", + "integrity": "sha512-dDk0X87T7mI6U3K9VjWtHOXqwAMJBNN2r7bejDsc+j03SEjtD9HrOl8gVFByeM0aJksoUuUVU9TBaZa2rgj0oA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.3.tgz", + "integrity": "sha512-s6nPv2QkSupJwLYyfS+gwdirm0ukyTFNl3KTgZEAiJDd+iHZcbTPPcWCcRYH+WlNbwChgH2QkE9NSlNrMT8Gfw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.3.tgz", + "integrity": "sha512-sZOuFz/xWnZ4KH3YfFrKCf1WyPZHakVzTiqji3WDc0BCl2kBwiJLCXpzLzUBLgmp4veFZdvN5ChW4Eq/8Fc2Fg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.3.tgz", + "integrity": "sha512-yGlQYjdxtLdh0a3jHjuwOrxQjOZYD/C9PfdbgJJF3TIZWnm/tMd/RcNiLngiu4iwcBAOezdnSLAwQDPqTmtTYg==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.3.tgz", + "integrity": "sha512-WO60Sn8ly3gtzhyjATDgieJNet/KqsDlX5nRC5Y3oTFcS1l0KWba+SEa9Ja1GfDqSF1z6hif/SkpQJbL63cgOA==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.3.tgz", + "integrity": "sha512-APsymYA6sGcZ4pD6k+UxbDjOFSvPWyZhjaiPyl/f79xKxwTnrn5QUnXR5prvetuaSMsb4jgeHewIDCIWljrSxw==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.3.tgz", + "integrity": "sha512-eizBnTeBefojtDb9nSh4vvVQ3V9Qf9Df01PfawPcRzJH4gFSgrObw+LveUyDoKU3kxi5+9RJTCWlj4FjYXVPEA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.3.tgz", + "integrity": "sha512-3Emwh0r5wmfm3ssTWRQSyVhbOHvqegUDRd0WhmXKX2mkHJe1SFCMJhagUleMq+Uci34wLSipf8Lagt4LlpRFWQ==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.3.tgz", + "integrity": "sha512-pBHUx9LzXWBc7MFIEEL0yD/ZVtNgLytvx60gES28GcWMqil8ElCYR4kvbV2BDqsHOvVDRrOxGySBM9Fcv744hw==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.3.tgz", + "integrity": "sha512-Czi8yzXUWIQYAtL/2y6vogER8pvcsOsk5cpwL4Gk5nJqH5UZiVByIY8Eorm5R13gq+DQKYg0+JyQoytLQas4dA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.3.tgz", + "integrity": "sha512-sDpk0RgmTCR/5HguIZa9n9u+HVKf40fbEUt+iTzSnCaGvY9kFP0YKBWZtJaraonFnqef5SlJ8/TiPAxzyS+UoA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.3.tgz", + "integrity": "sha512-P14lFKJl/DdaE00LItAukUdZO5iqNH7+PjoBm+fLQjtxfcfFE20Xf5CrLsmZdq5LFFZzb5JMZ9grUwvtVYzjiA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.3.tgz", + "integrity": "sha512-AIcMP77AvirGbRl/UZFTq5hjXK+2wC7qFRGoHSDrZ5v5b8DK/GYpXW3CPRL53NkvDqb9D+alBiC/dV0Fb7eJcw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.3.tgz", + "integrity": "sha512-DnW2sRrBzA+YnE70LKqnM3P+z8vehfJWHXECbwBmH/CU51z6FiqTQTHFenPlHmo3a8UgpLyH3PT+87OViOh1AQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openharmony-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.3.tgz", + "integrity": "sha512-NinAEgr/etERPTsZJ7aEZQvvg/A6IsZG/LgZy+81wON2huV7SrK3e63dU0XhyZP4RKGyTm7aOgmQk0bGp0fy2g==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.3.tgz", + "integrity": "sha512-PanZ+nEz+eWoBJ8/f8HKxTTD172SKwdXebZ0ndd953gt1HRBbhMsaNqjTyYLGLPdoWHy4zLU7bDVJztF5f3BHA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.3.tgz", + "integrity": "sha512-B2t59lWWYrbRDw/tjiWOuzSsFh1Y/E95ofKz7rIVYSQkUYBjfSgf6oeYPNWHToFRr2zx52JKApIcAS/D5TUBnA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.3.tgz", + "integrity": "sha512-QLKSFeXNS8+tHW7tZpMtjlNb7HKau0QDpwm49u0vUp9y1WOF+PEzkU84y9GqYaAVW8aH8f3GcBck26jh54cX4Q==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.3.tgz", + "integrity": "sha512-4uJGhsxuptu3OcpVAzli+/gWusVGwZZHTlS63hh++ehExkVT8SgiEf7/uC/PclrPPkLhZqGgCTjd0VWLo6xMqA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@types/node": { + "version": "22.19.15", + "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.15.tgz", + "integrity": "sha512-F0R/h2+dsy5wJAUe3tAU6oqa2qbWY5TpNfL/RGmo1y38hiyO1w3x2jPtt76wmuaJI4DQnOBu21cNXQ2STIUUWg==", + "dev": true, + "license": "MIT", + "dependencies": { + "undici-types": "~6.21.0" + } + }, + "node_modules/@types/ref-napi": { + "version": "3.0.12", + "resolved": "https://registry.npmjs.org/@types/ref-napi/-/ref-napi-3.0.12.tgz", + "integrity": "sha512-UZPKghRaLlWx2lPAphpdtYe62TbGBaPeqUM6gF1vI6FPRIu/Tff/WMAzpJRFU3jJIiD8HiXpVt2RjcFHtA6YRg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@yuuang/ffi-rs-android-arm64": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/@yuuang/ffi-rs-android-arm64/-/ffi-rs-android-arm64-1.3.1.tgz", + "integrity": "sha512-V4nmlXdOYZEa7GOxSExVG95SLp8FE0iTq2yKeN54UlfNMr3Sik+1Ff57LcCv7qYcn4TBqnBAt5rT3FAM6T6caQ==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">= 12" + } + }, + "node_modules/@yuuang/ffi-rs-darwin-arm64": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/@yuuang/ffi-rs-darwin-arm64/-/ffi-rs-darwin-arm64-1.3.1.tgz", + "integrity": "sha512-YlnTMIyzfW3mAULC5ZA774nzQfFlYXM0rrfq/8ZzWt+IMbYk55a++jrI+6JeKV+1EqlDS3TFBEFtjdBNG94KzQ==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 12" + } + }, + "node_modules/@yuuang/ffi-rs-darwin-x64": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/@yuuang/ffi-rs-darwin-x64/-/ffi-rs-darwin-x64-1.3.1.tgz", + "integrity": "sha512-sI3LpQQ34SX4nyOHc5yxA7FSqs9qPEUMqW/y/wWo9cuyPpaHMFsi/BeOVYsnC0syp3FrY7gzn6RnD6PlXCktXg==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 12" + } + }, + "node_modules/@yuuang/ffi-rs-linux-arm-gnueabihf": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/@yuuang/ffi-rs-linux-arm-gnueabihf/-/ffi-rs-linux-arm-gnueabihf-1.3.1.tgz", + "integrity": "sha512-1WkcGkJTlwh4ZA59htKI+RXhiL3oKiYwLv7PO8LUf6FuADK73s5GcXp67iakKu243uYu+qGYr4RHco4ySddYhQ==", + "cpu": [ + "arm" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12" + } + }, + "node_modules/@yuuang/ffi-rs-linux-arm64-gnu": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/@yuuang/ffi-rs-linux-arm64-gnu/-/ffi-rs-linux-arm64-gnu-1.3.1.tgz", + "integrity": "sha512-J2PwqviycZxaEVA0Bwv38LqGDGSB9A1DPN4iYginYJZSvTvKW8kh7Tis0HbZrX1YDKnY8hi3lt0N0tCTNPDH5Q==", + "cpu": [ + "arm64" + ], + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12" + } + }, + "node_modules/@yuuang/ffi-rs-linux-arm64-musl": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/@yuuang/ffi-rs-linux-arm64-musl/-/ffi-rs-linux-arm64-musl-1.3.1.tgz", + "integrity": "sha512-Hn1W1hBPssTaqikU1Bqp1XUdDdOgbnYVIOtR++LVx66hhrtjf/xrIUQOhTm+NmOFDG16JUKXe1skfM4gpaqYwg==", + "cpu": [ + "arm64" + ], + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12" + } + }, + "node_modules/@yuuang/ffi-rs-linux-x64-gnu": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/@yuuang/ffi-rs-linux-x64-gnu/-/ffi-rs-linux-x64-gnu-1.3.1.tgz", + "integrity": "sha512-kW6e+oCYZPvpH2ppPsffA18e1aLowtmWTRjVlyHtY04g/nQDepQvDUkkcvInh9fW5jLna7PjHvktW1tVgYIj2A==", + "cpu": [ + "x64" + ], + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12" + } + }, + "node_modules/@yuuang/ffi-rs-linux-x64-musl": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/@yuuang/ffi-rs-linux-x64-musl/-/ffi-rs-linux-x64-musl-1.3.1.tgz", + "integrity": "sha512-HTwblAzruUS16nQPrez3ozvEHm1Xxh8J8w7rZYrpmAcNl1hzyOT8z/hY70M9Rt9fOqQ4Ovgor9qVy/U3ZJo0ZA==", + "cpu": [ + "x64" + ], + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12" + } + }, + "node_modules/@yuuang/ffi-rs-win32-arm64-msvc": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/@yuuang/ffi-rs-win32-arm64-msvc/-/ffi-rs-win32-arm64-msvc-1.3.1.tgz", + "integrity": "sha512-WeZkGl2BP1U4tRhEQH+FXLQS52N8obp74smK5AAGOfzPAT1pHkq6+dVkC1QCSIt7dHJs7SPtlnQw+5DkdZYlWA==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 12" + } + }, + "node_modules/@yuuang/ffi-rs-win32-ia32-msvc": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/@yuuang/ffi-rs-win32-ia32-msvc/-/ffi-rs-win32-ia32-msvc-1.3.1.tgz", + "integrity": "sha512-rNGgMeCH5mdeHiMiJgt7wWXovZ+FHEfXhU9p4zZBH4n8M1/QnEsRUwlapISPLpILSGpoYS6iBuq9/fUlZY8Mhg==", + "cpu": [ + "x64", + "ia32" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 12" + } + }, + "node_modules/@yuuang/ffi-rs-win32-x64-msvc": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/@yuuang/ffi-rs-win32-x64-msvc/-/ffi-rs-win32-x64-msvc-1.3.1.tgz", + "integrity": "sha512-dr2LcLD2CXo2a7BktlOpV68QhayqiI112KxIJC9tBgQO/Dkdg4CPsdqmvzzLhFo64iC5RLl2BT7M5lJImrfUWw==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 12" + } + }, + "node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/esbuild": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.3.tgz", + "integrity": "sha512-8VwMnyGCONIs6cWue2IdpHxHnAjzxnw2Zr7MkVxB2vjmQ2ivqGFb4LEG3SMnv0Gb2F/G/2yA8zUaiL1gywDCCg==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.27.3", + "@esbuild/android-arm": "0.27.3", + "@esbuild/android-arm64": "0.27.3", + "@esbuild/android-x64": "0.27.3", + "@esbuild/darwin-arm64": "0.27.3", + "@esbuild/darwin-x64": "0.27.3", + "@esbuild/freebsd-arm64": "0.27.3", + "@esbuild/freebsd-x64": "0.27.3", + "@esbuild/linux-arm": "0.27.3", + "@esbuild/linux-arm64": "0.27.3", + "@esbuild/linux-ia32": "0.27.3", + "@esbuild/linux-loong64": "0.27.3", + "@esbuild/linux-mips64el": "0.27.3", + "@esbuild/linux-ppc64": "0.27.3", + "@esbuild/linux-riscv64": "0.27.3", + "@esbuild/linux-s390x": "0.27.3", + "@esbuild/linux-x64": "0.27.3", + "@esbuild/netbsd-arm64": "0.27.3", + "@esbuild/netbsd-x64": "0.27.3", + "@esbuild/openbsd-arm64": "0.27.3", + "@esbuild/openbsd-x64": "0.27.3", + "@esbuild/openharmony-arm64": "0.27.3", + "@esbuild/sunos-x64": "0.27.3", + "@esbuild/win32-arm64": "0.27.3", + "@esbuild/win32-ia32": "0.27.3", + "@esbuild/win32-x64": "0.27.3" + } + }, + "node_modules/ffi-rs": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/ffi-rs/-/ffi-rs-1.3.1.tgz", + "integrity": "sha512-ZyNXL9fnclnZV+waQmWB9JrfbIEyxQa1OWtMrHOrAgcC04PgP5hBMG5TdhVN8N4uT/eul8zCFMVnJUukAFFlXA==", + "license": "MIT", + "optionalDependencies": { + "@yuuang/ffi-rs-android-arm64": "1.3.1", + "@yuuang/ffi-rs-darwin-arm64": "1.3.1", + "@yuuang/ffi-rs-darwin-x64": "1.3.1", + "@yuuang/ffi-rs-linux-arm-gnueabihf": "1.3.1", + "@yuuang/ffi-rs-linux-arm64-gnu": "1.3.1", + "@yuuang/ffi-rs-linux-arm64-musl": "1.3.1", + "@yuuang/ffi-rs-linux-x64-gnu": "1.3.1", + "@yuuang/ffi-rs-linux-x64-musl": "1.3.1", + "@yuuang/ffi-rs-win32-arm64-msvc": "1.3.1", + "@yuuang/ffi-rs-win32-ia32-msvc": "1.3.1", + "@yuuang/ffi-rs-win32-x64-msvc": "1.3.1" + } + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/get-symbol-from-current-process-h": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/get-symbol-from-current-process-h/-/get-symbol-from-current-process-h-1.0.2.tgz", + "integrity": "sha512-syloC6fsCt62ELLrr1VKBM1ggOpMdetX9hTrdW77UQdcApPHLmf7CI7OKcN1c9kYuNxKcDe4iJ4FY9sX3aw2xw==", + "license": "MIT" + }, + "node_modules/get-tsconfig": { + "version": "4.13.6", + "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.13.6.tgz", + "integrity": "sha512-shZT/QMiSHc/YBLxxOkMtgSid5HFoauqCE3/exfsEcwg1WkeqjG+V40yBbBrsD+jW2HDXcs28xOfcbm2jI8Ddw==", + "dev": true, + "license": "MIT", + "dependencies": { + "resolve-pkg-maps": "^1.0.0" + }, + "funding": { + "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" + }, + "node_modules/node-addon-api": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-3.2.1.tgz", + "integrity": "sha512-mmcei9JghVNDYydghQmeDX8KoAm0FAiYyIcUt/N4nhyAipB17pllZQDOJD2fotxABnt4Mdz+dKTO7eftLg4d0A==", + "license": "MIT" + }, + "node_modules/node-gyp-build": { + "version": "4.8.4", + "resolved": "https://registry.npmjs.org/node-gyp-build/-/node-gyp-build-4.8.4.tgz", + "integrity": "sha512-LA4ZjwlnUblHVgq0oBF3Jl/6h/Nvs5fzBLwdEF4nuxnFdsfajde4WfxtJr3CaiH+F6ewcIB/q4jQ4UzPyid+CQ==", + "license": "MIT", + "bin": { + "node-gyp-build": "bin.js", + "node-gyp-build-optional": "optional.js", + "node-gyp-build-test": "build-test.js" + } + }, + "node_modules/prettier": { + "version": "3.8.1", + "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.8.1.tgz", + "integrity": "sha512-UOnG6LftzbdaHZcKoPFtOcCKztrQ57WkHDeRD9t/PTQtmT0NHSeWWepj6pS0z/N7+08BHFDQVUrfmfMRcZwbMg==", + "dev": true, + "license": "MIT", + "bin": { + "prettier": "bin/prettier.cjs" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/prettier/prettier?sponsor=1" + } + }, + "node_modules/ref-napi": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/ref-napi/-/ref-napi-3.0.3.tgz", + "integrity": "sha512-LiMq/XDGcgodTYOMppikEtJelWsKQERbLQsYm0IOOnzhwE9xYZC7x8txNnFC9wJNOkPferQI4vD4ZkC0mDyrOA==", + "hasInstallScript": true, + "license": "MIT", + "dependencies": { + "debug": "^4.1.1", + "get-symbol-from-current-process-h": "^1.0.2", + "node-addon-api": "^3.0.0", + "node-gyp-build": "^4.2.1" + }, + "engines": { + "node": ">= 10.0" + } + }, + "node_modules/resolve-pkg-maps": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz", + "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1" + } + }, + "node_modules/tsx": { + "version": "4.21.0", + "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.21.0.tgz", + "integrity": "sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "~0.27.0", + "get-tsconfig": "^4.7.5" + }, + "bin": { + "tsx": "dist/cli.mjs" + }, + "engines": { + "node": ">=18.0.0" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + } + }, + "node_modules/typescript": { + "version": "5.9.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/undici-types": { + "version": "6.21.0", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz", + "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/uniffi-bindgen-react-native": { + "version": "0.29.3-1", + "resolved": "https://registry.npmjs.org/uniffi-bindgen-react-native/-/uniffi-bindgen-react-native-0.29.3-1.tgz", + "integrity": "sha512-o6gXZsAh55yuvhwF2WSFdIHV4phyfWcCmg4DuyfJWJ7CvUz1UcIz2S4u9SmXAz1jsuqvu6Xc9hexrRBB0a5osg==", + "license": "MPL-2.0", + "bin": { + "ubrn": "bin/cli.cjs", + "uniffi-bindgen-react-native": "bin/cli.cjs" + } + } + } +} diff --git a/bindings/typescript/package.json b/bindings/typescript/package.json new file mode 100644 index 0000000000..5c9c64c9ad --- /dev/null +++ b/bindings/typescript/package.json @@ -0,0 +1,32 @@ +{ + "name": "@iota/sdk", + "version": "0.0.1-alpha.1", + "description": "IOTA SDK TypeScript bindings", + "main": "lib/index.ts", + "license": "Apache-2.0", + "author": "IOTA Foundation ", + "homepage": "https://iota.org", + "repository": { + "type": "git", + "url": "https://github.com/iotaledger/iota-rust-sdk" + }, + "files": [ + "lib/**/*" + ], + "scripts": { + "lint": "prettier --check examples/**/*.ts", + "format": "prettier --write examples/**/*.ts" + }, + "dependencies": { + "ffi-rs": "^1.3.0", + "ref-napi": "^3.0.3", + "uniffi-bindgen-react-native": "^0.29.3-1" + }, + "devDependencies": { + "tsx": "^4.19.0", + "typescript": "^5.5.0", + "prettier": "^3.3.0", + "@types/node": "^22.0.0", + "@types/ref-napi": "^3.0.12" + } +} diff --git a/bindings/typescript/tsconfig.json b/bindings/typescript/tsconfig.json new file mode 100644 index 0000000000..ab8ccadfb5 --- /dev/null +++ b/bindings/typescript/tsconfig.json @@ -0,0 +1,14 @@ +{ + "compilerOptions": { + "target": "ES2022", + "module": "Node16", + "moduleResolution": "Node16", + "strict": true, + "esModuleInterop": true, + "skipLibCheck": true, + "outDir": "dist", + "rootDir": ".", + "declaration": true + }, + "include": ["examples/**/*.ts", "lib/**/*.ts"] +} diff --git a/bindings/typescript/uniffi-bindgen-node-0.29.patch b/bindings/typescript/uniffi-bindgen-node-0.29.patch new file mode 100644 index 0000000000..89c4ff7eaa --- /dev/null +++ b/bindings/typescript/uniffi-bindgen-node-0.29.patch @@ -0,0 +1,445 @@ +diff --git a/Cargo.lock b/Cargo.lock +index a98f074..768e151 100644 +--- a/Cargo.lock ++++ b/Cargo.lock +@@ -372,8 +372,6 @@ checksum = "6717a8d2a5a929a1a2eb43a12812498ed141a0bcfb7e8f7844fbdbe4303bba9f" + dependencies = [ + "equivalent", + "hashbrown", +- "serde", +- "serde_core", + ] + + [[package]] +@@ -592,15 +590,6 @@ dependencies = [ + "zmij", + ] + +-[[package]] +-name = "serde_spanned" +-version = "1.0.3" +-source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "e24345aa0fe688594e73770a5f6d1b216508b4f93484c0026d521acd30134392" +-dependencies = [ +- "serde_core", +-] +- + [[package]] + name = "siphasher" + version = "0.3.11" +@@ -682,43 +671,13 @@ dependencies = [ + + [[package]] + name = "toml" +-version = "0.9.8" ++version = "0.5.11" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "f0dc8b1fb61449e27716ec0e1bdf0f6b8f3e8f6b05391e8497b8b6d7804ea6d8" ++checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234" + dependencies = [ +- "indexmap", +- "serde_core", +- "serde_spanned", +- "toml_datetime", +- "toml_parser", +- "toml_writer", +- "winnow", +-] +- +-[[package]] +-name = "toml_datetime" +-version = "0.7.3" +-source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "f2cdb639ebbc97961c51720f858597f7f24c4fc295327923af55b74c3c724533" +-dependencies = [ +- "serde_core", +-] +- +-[[package]] +-name = "toml_parser" +-version = "1.0.4" +-source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "c0cbe268d35bdb4bb5a56a2de88d0ad0eb70af5384a99d648cd4b3d04039800e" +-dependencies = [ +- "winnow", ++ "serde", + ] + +-[[package]] +-name = "toml_writer" +-version = "1.0.4" +-source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "df8b2b54733674ad286d16267dcfc7a71ed5c776e4ac7aa3c3e2561f7c637bf2" +- + [[package]] + name = "unicode-ident" + version = "1.0.20" +@@ -739,9 +698,9 @@ checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254" + + [[package]] + name = "uniffi" +-version = "0.30.0" ++version = "0.29.5" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "c866f627c3f04c3df068b68bb2d725492caaa539dd313e2a9d26bb85b1a32f4e" ++checksum = "3291800a6b06569f7d3e15bdb6dc235e0f0c8bd3eb07177f430057feb076415f" + dependencies = [ + "anyhow", + "cargo_metadata", +@@ -771,9 +730,9 @@ dependencies = [ + + [[package]] + name = "uniffi_bindgen" +-version = "0.30.0" ++version = "0.29.5" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "7c8ca600167641ebe7c8ba9254af40492dda3397c528cc3b2f511bd23e8541a5" ++checksum = "a04b99fa7796eaaa7b87976a0dbdd1178dc1ee702ea00aca2642003aef9b669e" + dependencies = [ + "anyhow", + "askama 0.13.1", +@@ -797,9 +756,9 @@ dependencies = [ + + [[package]] + name = "uniffi_core" +-version = "0.30.0" ++version = "0.29.5" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "7e7a5a038ebffe8f4cf91416b154ef3c2468b18e828b7009e01b1b99938089f9" ++checksum = "f38a9a27529ccff732f8efddb831b65b1e07f7dea3fd4cacd4a35a8c4b253b98" + dependencies = [ + "anyhow", + "bytes", +@@ -809,9 +768,9 @@ dependencies = [ + + [[package]] + name = "uniffi_internal_macros" +-version = "0.30.0" ++version = "0.29.5" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "e3c2a6f93e7b73726e2015696ece25ca0ac5a5f1cf8d6a7ab5214dd0a01d2edf" ++checksum = "09acd2ce09c777dd65ee97c251d33c8a972afc04873f1e3b21eb3492ade16933" + dependencies = [ + "anyhow", + "indexmap", +@@ -822,9 +781,9 @@ dependencies = [ + + [[package]] + name = "uniffi_macros" +-version = "0.30.0" ++version = "0.29.5" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "64c6309fc36c7992afc03bc0c5b059c656bccbef3f2a4bc362980017f8936141" ++checksum = "5596f178c4f7aafa1a501c4e0b96236a96bc2ef92bdb453d83e609dad0040152" + dependencies = [ + "camino", + "fs-err", +@@ -839,9 +798,9 @@ dependencies = [ + + [[package]] + name = "uniffi_meta" +-version = "0.30.0" ++version = "0.29.5" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "0a138823392dba19b0aa494872689f97d0ee157de5852e2bec157ce6de9cdc22" ++checksum = "beadc1f460eb2e209263c49c4f5b19e9a02e00a3b2b393f78ad10d766346ecff" + dependencies = [ + "anyhow", + "siphasher", +@@ -851,9 +810,9 @@ dependencies = [ + + [[package]] + name = "uniffi_pipeline" +-version = "0.30.0" ++version = "0.29.5" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "8c27c4b515d25f8e53cc918e238c39a79c3144a40eaf2e51c4a7958973422c29" ++checksum = "dd76b3ac8a2d964ca9fce7df21c755afb4c77b054a85ad7a029ad179cc5abb8a" + dependencies = [ + "anyhow", + "heck", +@@ -864,9 +823,9 @@ dependencies = [ + + [[package]] + name = "uniffi_udl" +-version = "0.30.0" ++version = "0.29.5" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "d0adacdd848aeed7af4f5af7d2f621d5e82531325d405e29463482becfdeafca" ++checksum = "4319cf905911d70d5b97ce0f46f101619a22e9a189c8c46d797a9955e9233716" + dependencies = [ + "anyhow", + "textwrap", +diff --git a/Cargo.toml b/Cargo.toml +index 3f079fa..a7e6200 100644 +--- a/Cargo.toml ++++ b/Cargo.toml +@@ -13,6 +13,6 @@ heck = "0.5.0" + serde = "1.0.228" + serde_json = "1.0.149" + textwrap = "0.16.2" +-toml = "0.9.8" +-uniffi = "0.30.0" +-uniffi_bindgen = "0.30.0" ++toml = "0.5" ++uniffi = "0.29" ++uniffi_bindgen = "0.29" +diff --git a/src/bindings/filters.rs b/src/bindings/filters.rs +index 90c6689..4092de9 100644 +--- a/src/bindings/filters.rs ++++ b/src/bindings/filters.rs +@@ -42,7 +42,7 @@ pub fn typescript_type_name(typ: &impl AsType, askama_values: &dyn askama::Value + typescript_type_name(&key_type, askama_values)?, + typescript_type_name(&value_type, askama_values)?, + ), +- Type::Custom { name, .. } => name.to_pascal_case(), ++ Type::Custom { builtin, .. } => typescript_type_name(&builtin, askama_values)?, + }) + } + +@@ -67,6 +67,7 @@ pub fn typescript_ffi_type_name(ffi_type: &FfiType, askama_values: &dyn askama:: + FfiType::MutReference(inner) => format!("/* MutReference to {} */ JsExternal", strip_comments(typescript_ffi_type_name(inner, askama_values)?)), + FfiType::Reference(inner) => format!("/* Reference to {} */ JsExternal", strip_comments(typescript_ffi_type_name(inner, askama_values)?)), + FfiType::VoidPointer => "void".into(), // ??? ++ FfiType::RustArcPtr(_) => "/* RustArcPtr */ bigint".into(), + }) + } + +@@ -75,22 +76,23 @@ pub fn typescript_ffi_datatype_name(ffi_type: &FfiType, askama_values: &dyn aska + FfiType::Int8 => "/* i8 */ DataType.U8".into(), + FfiType::Int16 => "DataType.I16".into(), + FfiType::Int32 => "DataType.I32".into(), +- FfiType::Int64 => "DataType.I64".into(), ++ FfiType::Int64 => "/* i64 */ DataType.BigInt".into(), + FfiType::UInt8 => "DataType.U8".into(), +- FfiType::UInt16 => "/* u16 */ DataType.U64".into(), +- FfiType::UInt32 => "/* u32 */ DataType.U64".into(), +- FfiType::UInt64 => "DataType.U64".into(), ++ FfiType::UInt16 => "/* u16 */ DataType.I32".into(), ++ FfiType::UInt32 => "/* u32 */ DataType.I32".into(), ++ FfiType::UInt64 => "/* u64 */ DataType.BigInt".into(), + FfiType::Float32 => "/* f32 */ DataType.Float".into(), + FfiType::Float64 => "/* f64 */ DataType.Double".into(), // FIXME: is this right for f64? I am not sure `number` is big enough? + FfiType::RustBuffer(_) => "DataType_UniffiRustBufferStruct".into(), + FfiType::ForeignBytes => "DataType_UniffiForeignBytes".into(), + FfiType::Callback(_name) => "/* callback */ DataType.External".into(), + FfiType::Struct(name) => format!("/* {} */ DataType.U8Array", typescript_ffi_struct_name(name, askama_values)?), // FIXME: this should make struct definitions in ffi-rs +- FfiType::Handle => "/* handle */ DataType.U64".into(), ++ FfiType::Handle => "/* handle */ DataType.BigInt".into(), + FfiType::RustCallStatus => "/* RustCallStatus */ DataType.External".into(), + FfiType::MutReference(inner) => format!("/* MutReference to {} */ DataType.External", strip_comments(typescript_ffi_type_name(inner, askama_values)?)), + FfiType::Reference(inner) => format!("/* Reference to {} */ DataType.External", strip_comments(typescript_ffi_type_name(inner, askama_values)?)), + FfiType::VoidPointer => "DataType.Void".into(), // ??? ++ FfiType::RustArcPtr(_) => "/* RustArcPtr */ DataType.BigInt".into(), + }) + } + +@@ -108,7 +110,7 @@ pub fn typescript_ffi_converter_name(typ: &impl AsType, askama_values: &dyn aska + Type::Float64 => "FfiConverterFloat64".into(), + Type::Boolean => "FfiConverterBool".into(), + Type::String => "FfiConverterString".into(), +- Type::Bytes => "FfiConverterBytes".into(), ++ Type::Bytes => "FfiConverterArrayBuffer".into(), + Type::Timestamp => "FfiConverterTimestamp".into(), + Type::Duration => "FfiConverterDuration".into(), + Type::Enum { name, .. } | Type::Record { name, .. } | Type::Object { name, .. } => typescript_ffi_converter_struct_enum_object_name(&name, askama_values)?, +@@ -125,13 +127,13 @@ pub fn typescript_ffi_converter_name(typ: &impl AsType, askama_values: &dyn aska + typescript_ffi_converter_name(&key_type, askama_values)?, + typescript_ffi_converter_name(&value_type, askama_values)?, + ), +- Type::Custom { name, .. } => format!("/* custom? */ {}", name.to_pascal_case()), // FIXME: what should this be? ++ Type::Custom { builtin, .. } => typescript_ffi_converter_name(&builtin, askama_values)?, + }) + } + + pub fn typescript_ffi_converter_lift_with(target: String, askama_values: &dyn askama::Values, typ: &impl AsType) -> Result { + Ok(match typ.as_type() { +- Type::String | Type::Map { .. } | Type::Sequence { .. } | Type::Enum { .. } | Type::Record { .. } => { ++ Type::String | Type::Bytes | Type::Map { .. } | Type::Sequence { .. } | Type::Enum { .. } | Type::Record { .. } | Type::Custom { .. } => { + format!("{}.lift(new UniffiRustBufferValue({target}).consumeIntoUint8Array())", typescript_ffi_converter_name(typ, askama_values)?) + }, + Type::Optional { inner_type } => { +@@ -143,7 +145,7 @@ pub fn typescript_ffi_converter_lift_with(target: String, askama_values: &dyn as + + pub fn typescript_ffi_converter_lower_with(target: String, askama_values: &dyn askama::Values, typ: &impl AsType) -> Result { + Ok(match typ.as_type() { +- Type::String | Type::Map { .. } | Type::Sequence { .. } | Type::Enum { .. } | Type::Record { .. } => { ++ Type::String | Type::Bytes | Type::Map { .. } | Type::Sequence { .. } | Type::Enum { .. } | Type::Record { .. } | Type::Custom { .. } => { + format!("UniffiRustBufferValue.allocateWithBytes({}.lower({target})).toStruct()", typescript_ffi_converter_name(typ, askama_values)?) + }, + Type::Optional { inner_type } => { +@@ -158,7 +160,31 @@ pub fn typescript_fn_name(raw_name: &str, _: &dyn askama::Values) -> Result Result { +- Ok(raw_name.to_lower_camel_case()) ++ let name = raw_name.to_lower_camel_case(); ++ Ok(escape_reserved_word(name)) ++} ++ ++/// Escape JavaScript/TypeScript reserved words and built-in globals by appending an underscore. ++fn escape_reserved_word(name: String) -> String { ++ match name.as_str() { ++ // JS/TS reserved words ++ "break" | "case" | "catch" | "class" | "const" | "continue" | "debugger" | ++ "default" | "delete" | "do" | "else" | "enum" | "export" | "extends" | ++ "false" | "finally" | "for" | "function" | "if" | "import" | "in" | ++ "instanceof" | "new" | "null" | "return" | "super" | "switch" | "this" | ++ "throw" | "true" | "try" | "typeof" | "var" | "void" | "while" | "with" | ++ "yield" | "let" | "static" | "implements" | "interface" | "package" | ++ "private" | "protected" | "public" | "arguments" | "async" | "await" | ++ // Built-in globals that must not be shadowed ++ "Object" | "Array" | "String" | "Number" | "Boolean" | "Symbol" | "BigInt" | ++ "Function" | "Date" | "RegExp" | "Error" | "Map" | "Set" | "WeakMap" | ++ "WeakSet" | "Promise" | "Proxy" | "Reflect" | "JSON" | "Math" | "Infinity" | ++ "NaN" | "undefined" | "globalThis" | "console" | "Buffer" | "ArrayBuffer" | ++ "DataView" | "Uint8Array" | "Int8Array" | "Float32Array" | "Float64Array" => { ++ format!("{name}_") ++ } ++ _ => name, ++ } + } + + /// The name of a given argument to a extern c ffi function call +@@ -167,7 +193,7 @@ pub fn typescript_argument_var_name(raw_name: &str, values: &dyn askama::Values) + } + + pub fn typescript_class_name(raw_name: &str, _: &dyn askama::Values) -> Result { +- Ok(raw_name.to_pascal_case()) ++ Ok(escape_reserved_word(raw_name.to_pascal_case())) + } + + pub fn typescript_protocol_name(raw_name: &str, values: &dyn askama::Values) -> Result { +diff --git a/src/bindings/generator.rs b/src/bindings/generator.rs +index ea5c585..b2ce6f3 100644 +--- a/src/bindings/generator.rs ++++ b/src/bindings/generator.rs +@@ -3,7 +3,7 @@ + // file, You can obtain one at http://mozilla.org/MPL/2.0/ + + use std::borrow::Borrow; +-use uniffi_bindgen::{ComponentInterface, interface::{AsType, FfiDefinition, FfiType, Type, Callable}}; ++use uniffi_bindgen::{ComponentInterface, interface::{AsType, FfiDefinition, FfiType, Type, Callable, UniffiTrait}}; + use anyhow::{Context, Result}; + use askama::Template; + use heck::ToKebabCase; +diff --git a/templates/node.ts b/templates/node.ts +index 86b1763..8c03a8c 100644 +--- a/templates/node.ts ++++ b/templates/node.ts +@@ -46,7 +46,7 @@ + /*rustFutureFunc:*/ () => { + {% if out_verbose_logs -%}console.log("{{ func_def.ffi_func().name() }} async call starting...");{%- endif %} + const returnedHandle = FFI_DYNAMIC_LIB.{{ func_def.ffi_func().name() }}([ +- {% if let Some(self_type) = func_def.self_type() -%} ++ {% if !associated_object_name.is_empty() -%} + {{ associated_object_name | typescript_ffi_object_factory_name }}.clonePointer(this) + {%- if !func_def.arguments().is_empty() %}, {% endif -%} + {% endif -%} +@@ -57,7 +57,7 @@ + {%- endfor -%} + + {%- if func_def.ffi_func().has_rust_call_status_arg() -%} +- {%- if !func_def.arguments().is_empty() || func_def.self_type().is_some() %}, {% endif -%} ++ {%- if !func_def.arguments().is_empty() || !associated_object_name.is_empty() %}, {% endif -%} + callStatus + {%- endif %} + ]); +@@ -93,10 +93,7 @@ + FFI_DYNAMIC_LIB.{{ func_def.ffi_rust_future_poll(ci) }}([ + handle, + unwrapped, +- // FIXME: the below should be able to passed through as a bigint, but ffi-rs doesn't seem +- // to be able to handle a bigint here even though this arg is a DataType.U64? +- // Investigate this - right now this hack could result in inadvertant precision loss. +- Number(callbackData) as unknown as bigint, ++ callbackData, + ]); + {% if out_verbose_logs -%}console.log('{{ func_def.ffi_func().name() }} async poll done');{%- endif %} + }, +@@ -125,7 +122,12 @@ + /*liftFunc:*/ (_v) => { /* void return value */ }, + {%- endif %} + /*liftString:*/ FfiConverterString.lift, +- /*asyncOpts:*/ asyncOpts_ ++ /*asyncOpts:*/ asyncOpts_, ++ {% match func_def.throws_type() -%} ++ {%- when Some(err) -%} ++ /*errorHandler:*/ (buffer) => ["{{err | typescript_type_name}}", {{err | typescript_ffi_converter_name}}.lift(buffer)], ++ {%- when None -%} ++ {%- endmatch %} + ); + + return returnValue; +@@ -148,7 +150,7 @@ + + {% if out_verbose_logs -%}console.log("{{ func_def.ffi_func().name() }} call starting...");{%- endif %} + const returnValue = FFI_DYNAMIC_LIB.{{ func_def.ffi_func().name() }}([ +- {% if let Some(self_type) = func_def.self_type() -%} ++ {% if !associated_object_name.is_empty() -%} + {{ associated_object_name | typescript_ffi_object_factory_name }}.clonePointer(this) + {%- if !func_def.arguments().is_empty() %}, {% endif -%} + {% endif -%} +@@ -159,7 +161,7 @@ + {%- endfor -%} + + {%- if func_def.ffi_func().has_rust_call_status_arg() -%} +- {%- if !func_def.arguments().is_empty() || func_def.self_type().is_some() %}, {% endif -%} ++ {%- if !func_def.arguments().is_empty() || !associated_object_name.is_empty() %}, {% endif -%} + callStatus + {%- endif %} + ]); +@@ -425,6 +427,19 @@ export class {{ object_def.name() | typescript_class_name }} extends UniffiAbstr + } + {% endfor %} + ++ // UniffiTrait implementations: ++ {% for trait_impl in object_def.uniffi_traits() %} ++ {%- match trait_impl -%} ++ {%- when UniffiTrait::Display { fmt } -%} ++ toString(): string { ++ {%- call function_call_body(fmt, object_def.name()) -%} ++ } ++ {%- when UniffiTrait::Debug { fmt } -%} ++ {%- when UniffiTrait::Eq { eq, ne } -%} ++ {%- when UniffiTrait::Hash { hash } -%} ++ {%- endmatch %} ++ {% endfor %} ++ + /** + * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy} + */ +@@ -497,14 +512,9 @@ const {{ object_def.name() | typescript_ffi_object_factory_name }}: UniffiObject + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.{{ object_def.ffi_object_clone().name() }}([ +- {% for arg in object_def.ffi_object_clone().arguments() -%} +- {{ arg.name() | typescript_argument_var_name }} +- {%- if !loop.last %}, {% endif %} +- {%- endfor -%} +- ++ handleArg + {%- if object_def.ffi_object_clone().has_rust_call_status_arg() -%} +- {%- if !object_def.ffi_object_clone().arguments().is_empty() %}, {% endif -%} +- callStatus ++ , callStatus + {%- endif %} + ]); + }, +@@ -516,14 +526,9 @@ const {{ object_def.name() | typescript_ffi_object_factory_name }}: UniffiObject + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { + return FFI_DYNAMIC_LIB.{{ object_def.ffi_object_free().name() }}([ +- {% for arg in object_def.ffi_object_free().arguments() -%} +- {{ arg.name() | typescript_argument_var_name }} +- {%- if !loop.last %}, {% endif %} +- {%- endfor -%} +- ++ handleArg + {%- if object_def.ffi_object_free().has_rust_call_status_arg() -%} +- {%- if !object_def.ffi_object_free().arguments().is_empty() %}, {% endif -%} +- callStatus ++ , callStatus + {%- endif %} + ]); + }, diff --git a/bindings/typescript/uniffi.toml b/bindings/typescript/uniffi.toml new file mode 100644 index 0000000000..697c987840 --- /dev/null +++ b/bindings/typescript/uniffi.toml @@ -0,0 +1,2 @@ +[bindings.typescript] +package_name = "iota_sdk"