From 90b3305ce2cbec5f2e3b53051195c450e16c21a8 Mon Sep 17 00:00:00 2001 From: Thibault Martinez Date: Fri, 15 Aug 2025 13:19:30 +0200 Subject: [PATCH 1/2] feat(bindings): add Swift --- Makefile | 8 + bindings/swift/lib/iota_sdk_ffi.swift | 29487 +++++++++++++++++ bindings/swift/lib/iota_sdk_ffiFFI.h | 6185 ++++ bindings/swift/lib/iota_sdk_ffiFFI.modulemap | 7 + 4 files changed, 35687 insertions(+) create mode 100644 bindings/swift/lib/iota_sdk_ffi.swift create mode 100644 bindings/swift/lib/iota_sdk_ffiFFI.h create mode 100644 bindings/swift/lib/iota_sdk_ffiFFI.modulemap diff --git a/Makefile b/Makefile index 05fe7c464..1a5302904 100644 --- a/Makefile +++ b/Makefile @@ -63,12 +63,14 @@ bindings: ## Build all bindings $(MAKE) go $(MAKE) kotlin $(MAKE) python + $(MAKE) swift .PHONY: test-bindings test-bindings: ## Test all bindings $(MAKE) test-go $(MAKE) test-kotlin $(MAKE) test-python + $(MAKE) test-swift # Build ffi crate and detect platform define build_binding @@ -98,6 +100,12 @@ python: ## Build Python bindings cargo run --bin iota_sdk_bindings -- generate --library "target/release/libiota_sdk_ffi$${LIB_EXT}" --language python --out-dir bindings/python/lib --no-format; \ cp target/release/libiota_sdk_ffi$${LIB_EXT} bindings/python/lib/ +.PHONY: swift +swift: ## Build Swift bindings + $(build_binding) \ + cargo run --bin iota_sdk_bindings -- generate --library "target/release/libiota_sdk_ffi$${LIB_EXT}" --language swift --out-dir bindings/swift/lib --no-format; \ + cp target/release/libiota_sdk_ffi$${LIB_EXT} bindings/swift/lib/ + .PHONY: test-go test-go: ## Test Go bindings cd bindings/go/; \ diff --git a/bindings/swift/lib/iota_sdk_ffi.swift b/bindings/swift/lib/iota_sdk_ffi.swift new file mode 100644 index 000000000..306704ec4 --- /dev/null +++ b/bindings/swift/lib/iota_sdk_ffi.swift @@ -0,0 +1,29487 @@ +// This file was autogenerated by some hot garbage in the `uniffi` crate. +// Trust me, you don't want to mess with it! + +// swiftlint:disable all +import Foundation + +// Depending on the consumer's build setup, the low-level FFI code +// might be in a separate module, or it might be compiled inline into +// this module. This is a bit of light hackery to work with both. +#if canImport(iota_sdk_ffiFFI) +import iota_sdk_ffiFFI +#endif + +fileprivate extension RustBuffer { + // Allocate a new buffer, copying the contents of a `UInt8` array. + init(bytes: [UInt8]) { + let rbuf = bytes.withUnsafeBufferPointer { ptr in + RustBuffer.from(ptr) + } + self.init(capacity: rbuf.capacity, len: rbuf.len, data: rbuf.data) + } + + static func empty() -> RustBuffer { + RustBuffer(capacity: 0, len:0, data: nil) + } + + static func from(_ ptr: UnsafeBufferPointer) -> RustBuffer { + try! rustCall { ffi_iota_sdk_ffi_rustbuffer_from_bytes(ForeignBytes(bufferPointer: ptr), $0) } + } + + // Frees the buffer in place. + // The buffer must not be used after this is called. + func deallocate() { + try! rustCall { ffi_iota_sdk_ffi_rustbuffer_free(self, $0) } + } +} + +fileprivate extension ForeignBytes { + init(bufferPointer: UnsafeBufferPointer) { + self.init(len: Int32(bufferPointer.count), data: bufferPointer.baseAddress) + } +} + +// For every type used in the interface, we provide helper methods for conveniently +// lifting and lowering that type from C-compatible data, and for reading and writing +// values of that type in a buffer. + +// Helper classes/extensions that don't change. +// Someday, this will be in a library of its own. + +fileprivate extension Data { + init(rustBuffer: RustBuffer) { + self.init( + bytesNoCopy: rustBuffer.data!, + count: Int(rustBuffer.len), + deallocator: .none + ) + } +} + +// Define reader functionality. Normally this would be defined in a class or +// struct, but we use standalone functions instead in order to make external +// types work. +// +// With external types, one swift source file needs to be able to call the read +// method on another source file's FfiConverter, but then what visibility +// should Reader have? +// - If Reader is fileprivate, then this means the read() must also +// be fileprivate, which doesn't work with external types. +// - If Reader is internal/public, we'll get compile errors since both source +// files will try define the same type. +// +// Instead, the read() method and these helper functions input a tuple of data + +fileprivate func createReader(data: Data) -> (data: Data, offset: Data.Index) { + (data: data, offset: 0) +} + +// Reads an integer at the current offset, in big-endian order, and advances +// the offset on success. Throws if reading the integer would move the +// offset past the end of the buffer. +fileprivate func readInt(_ reader: inout (data: Data, offset: Data.Index)) throws -> T { + let range = reader.offset...size + guard reader.data.count >= range.upperBound else { + throw UniffiInternalError.bufferOverflow + } + if T.self == UInt8.self { + let value = reader.data[reader.offset] + reader.offset += 1 + return value as! T + } + var value: T = 0 + let _ = withUnsafeMutableBytes(of: &value, { reader.data.copyBytes(to: $0, from: range)}) + reader.offset = range.upperBound + return value.bigEndian +} + +// Reads an arbitrary number of bytes, to be used to read +// raw bytes, this is useful when lifting strings +fileprivate func readBytes(_ reader: inout (data: Data, offset: Data.Index), count: Int) throws -> Array { + let range = reader.offset..<(reader.offset+count) + guard reader.data.count >= range.upperBound else { + throw UniffiInternalError.bufferOverflow + } + var value = [UInt8](repeating: 0, count: count) + value.withUnsafeMutableBufferPointer({ buffer in + reader.data.copyBytes(to: buffer, from: range) + }) + reader.offset = range.upperBound + return value +} + +// Reads a float at the current offset. +fileprivate func readFloat(_ reader: inout (data: Data, offset: Data.Index)) throws -> Float { + return Float(bitPattern: try readInt(&reader)) +} + +// Reads a float at the current offset. +fileprivate func readDouble(_ reader: inout (data: Data, offset: Data.Index)) throws -> Double { + return Double(bitPattern: try readInt(&reader)) +} + +// Indicates if the offset has reached the end of the buffer. +fileprivate func hasRemaining(_ reader: (data: Data, offset: Data.Index)) -> Bool { + return reader.offset < reader.data.count +} + +// Define writer functionality. Normally this would be defined in a class or +// struct, but we use standalone functions instead in order to make external +// types work. See the above discussion on Readers for details. + +fileprivate func createWriter() -> [UInt8] { + return [] +} + +fileprivate func writeBytes(_ writer: inout [UInt8], _ byteArr: S) where S: Sequence, S.Element == UInt8 { + writer.append(contentsOf: byteArr) +} + +// Writes an integer in big-endian order. +// +// Warning: make sure what you are trying to write +// is in the correct type! +fileprivate func writeInt(_ writer: inout [UInt8], _ value: T) { + var value = value.bigEndian + withUnsafeBytes(of: &value) { writer.append(contentsOf: $0) } +} + +fileprivate func writeFloat(_ writer: inout [UInt8], _ value: Float) { + writeInt(&writer, value.bitPattern) +} + +fileprivate func writeDouble(_ writer: inout [UInt8], _ value: Double) { + writeInt(&writer, value.bitPattern) +} + +// Protocol for types that transfer other types across the FFI. This is +// analogous to the Rust trait of the same name. +fileprivate protocol FfiConverter { + associatedtype FfiType + associatedtype SwiftType + + static func lift(_ value: FfiType) throws -> SwiftType + static func lower(_ value: SwiftType) -> FfiType + static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType + static func write(_ value: SwiftType, into buf: inout [UInt8]) +} + +// Types conforming to `Primitive` pass themselves directly over the FFI. +fileprivate protocol FfiConverterPrimitive: FfiConverter where FfiType == SwiftType { } + +extension FfiConverterPrimitive { +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public static func lift(_ value: FfiType) throws -> SwiftType { + return value + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public static func lower(_ value: SwiftType) -> FfiType { + return value + } +} + +// Types conforming to `FfiConverterRustBuffer` lift and lower into a `RustBuffer`. +// Used for complex types where it's hard to write a custom lift/lower. +fileprivate protocol FfiConverterRustBuffer: FfiConverter where FfiType == RustBuffer {} + +extension FfiConverterRustBuffer { +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public static func lift(_ buf: RustBuffer) throws -> SwiftType { + var reader = createReader(data: Data(rustBuffer: buf)) + let value = try read(from: &reader) + if hasRemaining(reader) { + throw UniffiInternalError.incompleteData + } + buf.deallocate() + return value + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public static func lower(_ value: SwiftType) -> RustBuffer { + var writer = createWriter() + write(value, into: &writer) + return RustBuffer(bytes: writer) + } +} +// An error type for FFI errors. These errors occur at the UniFFI level, not +// the library level. +fileprivate enum UniffiInternalError: LocalizedError { + case bufferOverflow + case incompleteData + case unexpectedOptionalTag + case unexpectedEnumCase + case unexpectedNullPointer + case unexpectedRustCallStatusCode + case unexpectedRustCallError + case unexpectedStaleHandle + case rustPanic(_ message: String) + + public var errorDescription: String? { + switch self { + case .bufferOverflow: return "Reading the requested value would read past the end of the buffer" + case .incompleteData: return "The buffer still has data after lifting its containing value" + case .unexpectedOptionalTag: return "Unexpected optional tag; should be 0 or 1" + case .unexpectedEnumCase: return "Raw enum value doesn't match any cases" + case .unexpectedNullPointer: return "Raw pointer value was null" + case .unexpectedRustCallStatusCode: return "Unexpected RustCallStatus code" + case .unexpectedRustCallError: return "CALL_ERROR but no errorClass specified" + case .unexpectedStaleHandle: return "The object in the handle map has been dropped already" + case let .rustPanic(message): return message + } + } +} + +fileprivate extension NSLock { + func withLock(f: () throws -> T) rethrows -> T { + self.lock() + defer { self.unlock() } + return try f() + } +} + +fileprivate let CALL_SUCCESS: Int8 = 0 +fileprivate let CALL_ERROR: Int8 = 1 +fileprivate let CALL_UNEXPECTED_ERROR: Int8 = 2 +fileprivate let CALL_CANCELLED: Int8 = 3 + +fileprivate extension RustCallStatus { + init() { + self.init( + code: CALL_SUCCESS, + errorBuf: RustBuffer.init( + capacity: 0, + len: 0, + data: nil + ) + ) + } +} + +private func rustCall(_ callback: (UnsafeMutablePointer) -> T) throws -> T { + let neverThrow: ((RustBuffer) throws -> Never)? = nil + return try makeRustCall(callback, errorHandler: neverThrow) +} + +private func rustCallWithError( + _ errorHandler: @escaping (RustBuffer) throws -> E, + _ callback: (UnsafeMutablePointer) -> T) throws -> T { + try makeRustCall(callback, errorHandler: errorHandler) +} + +private func makeRustCall( + _ callback: (UnsafeMutablePointer) -> T, + errorHandler: ((RustBuffer) throws -> E)? +) throws -> T { + uniffiEnsureIotaSdkFfiInitialized() + var callStatus = RustCallStatus.init() + let returnedVal = callback(&callStatus) + try uniffiCheckCallStatus(callStatus: callStatus, errorHandler: errorHandler) + return returnedVal +} + +private func uniffiCheckCallStatus( + callStatus: RustCallStatus, + errorHandler: ((RustBuffer) throws -> E)? +) throws { + switch callStatus.code { + case CALL_SUCCESS: + return + + case CALL_ERROR: + if let errorHandler = errorHandler { + throw try errorHandler(callStatus.errorBuf) + } else { + callStatus.errorBuf.deallocate() + throw 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 callStatus.errorBuf.len > 0 { + throw UniffiInternalError.rustPanic(try FfiConverterString.lift(callStatus.errorBuf)) + } else { + callStatus.errorBuf.deallocate() + throw UniffiInternalError.rustPanic("Rust panic") + } + + case CALL_CANCELLED: + fatalError("Cancellation not supported yet") + + default: + throw UniffiInternalError.unexpectedRustCallStatusCode + } +} + +private func uniffiTraitInterfaceCall( + callStatus: UnsafeMutablePointer, + makeCall: () throws -> T, + writeReturn: (T) -> () +) { + do { + try writeReturn(makeCall()) + } catch let error { + callStatus.pointee.code = CALL_UNEXPECTED_ERROR + callStatus.pointee.errorBuf = FfiConverterString.lower(String(describing: error)) + } +} + +private func uniffiTraitInterfaceCallWithError( + callStatus: UnsafeMutablePointer, + makeCall: () throws -> T, + writeReturn: (T) -> (), + lowerError: (E) -> RustBuffer +) { + do { + try writeReturn(makeCall()) + } catch let error as E { + callStatus.pointee.code = CALL_ERROR + callStatus.pointee.errorBuf = lowerError(error) + } catch { + callStatus.pointee.code = CALL_UNEXPECTED_ERROR + callStatus.pointee.errorBuf = FfiConverterString.lower(String(describing: error)) + } +} +fileprivate final class UniffiHandleMap: @unchecked Sendable { + // All mutation happens with this lock held, which is why we implement @unchecked Sendable. + private let lock = NSLock() + private var map: [UInt64: T] = [:] + private var currentHandle: UInt64 = 1 + + func insert(obj: T) -> UInt64 { + lock.withLock { + let handle = currentHandle + currentHandle += 1 + map[handle] = obj + return handle + } + } + + func get(handle: UInt64) throws -> T { + try lock.withLock { + guard let obj = map[handle] else { + throw UniffiInternalError.unexpectedStaleHandle + } + return obj + } + } + + @discardableResult + func remove(handle: UInt64) throws -> T { + try lock.withLock { + guard let obj = map.removeValue(forKey: handle) else { + throw UniffiInternalError.unexpectedStaleHandle + } + return obj + } + } + + var count: Int { + get { + map.count + } + } +} + + +// Public interface members begin here. + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterUInt8: FfiConverterPrimitive { + typealias FfiType = UInt8 + typealias SwiftType = UInt8 + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt8 { + return try lift(readInt(&buf)) + } + + public static func write(_ value: UInt8, into buf: inout [UInt8]) { + writeInt(&buf, lower(value)) + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterUInt16: FfiConverterPrimitive { + typealias FfiType = UInt16 + typealias SwiftType = UInt16 + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt16 { + return try lift(readInt(&buf)) + } + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + writeInt(&buf, lower(value)) + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterUInt32: FfiConverterPrimitive { + typealias FfiType = UInt32 + typealias SwiftType = UInt32 + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt32 { + return try lift(readInt(&buf)) + } + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + writeInt(&buf, lower(value)) + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterInt32: FfiConverterPrimitive { + typealias FfiType = Int32 + typealias SwiftType = Int32 + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Int32 { + return try lift(readInt(&buf)) + } + + public static func write(_ value: Int32, into buf: inout [UInt8]) { + writeInt(&buf, lower(value)) + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterUInt64: FfiConverterPrimitive { + typealias FfiType = UInt64 + typealias SwiftType = UInt64 + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt64 { + return try lift(readInt(&buf)) + } + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + writeInt(&buf, lower(value)) + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterInt64: FfiConverterPrimitive { + typealias FfiType = Int64 + typealias SwiftType = Int64 + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Int64 { + return try lift(readInt(&buf)) + } + + public static func write(_ value: Int64, into buf: inout [UInt8]) { + writeInt(&buf, lower(value)) + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterBool : FfiConverter { + typealias FfiType = Int8 + typealias SwiftType = Bool + + public static func lift(_ value: Int8) throws -> Bool { + return value != 0 + } + + public static func lower(_ value: Bool) -> Int8 { + return value ? 1 : 0 + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Bool { + return try lift(readInt(&buf)) + } + + public static func write(_ value: Bool, into buf: inout [UInt8]) { + writeInt(&buf, lower(value)) + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterString: FfiConverter { + typealias SwiftType = String + typealias FfiType = RustBuffer + + public static func lift(_ value: RustBuffer) throws -> String { + defer { + value.deallocate() + } + if value.data == nil { + return String() + } + let bytes = UnsafeBufferPointer(start: value.data!, count: Int(value.len)) + return String(bytes: bytes, encoding: String.Encoding.utf8)! + } + + public static func lower(_ value: String) -> RustBuffer { + return value.utf8CString.withUnsafeBufferPointer { ptr in + // The swift string gives us int8_t, we want uint8_t. + ptr.withMemoryRebound(to: UInt8.self) { ptr in + // The swift string gives us a trailing null byte, we don't want it. + let buf = UnsafeBufferPointer(rebasing: ptr.prefix(upTo: ptr.count - 1)) + return RustBuffer.from(buf) + } + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> String { + let len: Int32 = try readInt(&buf) + return String(bytes: try readBytes(&buf, count: Int(len)), encoding: String.Encoding.utf8)! + } + + public static func write(_ value: String, into buf: inout [UInt8]) { + let len = Int32(value.utf8.count) + writeInt(&buf, len) + writeBytes(&buf, value.utf8) + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterData: FfiConverterRustBuffer { + typealias SwiftType = Data + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Data { + let len: Int32 = try readInt(&buf) + return Data(try readBytes(&buf, count: Int(len))) + } + + public static func write(_ value: Data, into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + writeBytes(&buf, value) + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterDuration: FfiConverterRustBuffer { + typealias SwiftType = TimeInterval + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TimeInterval { + let seconds: UInt64 = try readInt(&buf) + let nanoseconds: UInt32 = try readInt(&buf) + return Double(seconds) + (Double(nanoseconds) / 1.0e9) + } + + public static func write(_ value: TimeInterval, into buf: inout [UInt8]) { + if value.rounded(.down) > Double(Int64.max) { + fatalError("Duration overflow, exceeds max bounds supported by Uniffi") + } + + if value < 0 { + fatalError("Invalid duration, must be non-negative") + } + + let seconds = UInt64(value) + let nanoseconds = UInt32((value - Double(seconds)) * 1.0e9) + writeInt(&buf, seconds) + writeInt(&buf, nanoseconds) + } +} + + + + +/** + * 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`. + * + * ``` + * use iota_types::Address; + * + * let hex = "0x02a212de6a9dfa3a69e22387acfbafbb1a9e591bd9d636e7895dcfc8de05f331"; + * let address = Address::from_hex(hex).unwrap(); + * println!("Address: {}", address); + * assert_eq!(hex, address.to_string()); + * ``` + * + * # Deriving an Address + * + * Addresses are cryptographically derived from a number of user account + * authenticators, the simplest of which is an + * [`Ed25519PublicKey`](iota_types::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 compatability reasons). For each other authenticator, this + * domain-separator is the single byte-value of its + * [`SignatureScheme`](iota_types::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. + * + * [`Ed25519PublicKey::derive_address`]: iota_types::Ed25519PublicKey::derive_address + * + * ## 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. + * + * [`ObjectId`]: iota_types::ObjectId + * + * # BCS + * + * An `Address`'s BCS serialized form is defined by the following: + * + * ```text + * address = 32OCTET + * ``` + */ +public protocol AddressProtocol: AnyObject, Sendable { + + func toBytes() -> Data + + func toHex() -> 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`. + * + * ``` + * use iota_types::Address; + * + * let hex = "0x02a212de6a9dfa3a69e22387acfbafbb1a9e591bd9d636e7895dcfc8de05f331"; + * let address = Address::from_hex(hex).unwrap(); + * println!("Address: {}", address); + * assert_eq!(hex, address.to_string()); + * ``` + * + * # Deriving an Address + * + * Addresses are cryptographically derived from a number of user account + * authenticators, the simplest of which is an + * [`Ed25519PublicKey`](iota_types::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 compatability reasons). For each other authenticator, this + * domain-separator is the single byte-value of its + * [`SignatureScheme`](iota_types::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. + * + * [`Ed25519PublicKey::derive_address`]: iota_types::Ed25519PublicKey::derive_address + * + * ## 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. + * + * [`ObjectId`]: iota_types::ObjectId + * + * # BCS + * + * An `Address`'s BCS serialized form is defined by the following: + * + * ```text + * address = 32OCTET + * ``` + */ +open class Address: AddressProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_address(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_address(pointer, $0) } + } + + +public static func fromBytes(bytes: Data)throws -> Address { + return try FfiConverterTypeAddress_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_address_from_bytes( + FfiConverterData.lower(bytes),$0 + ) +}) +} + +public static func fromHex(hex: String)throws -> Address { + return try FfiConverterTypeAddress_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_address_from_hex( + FfiConverterString.lower(hex),$0 + ) +}) +} + +public static func generate() -> Address { + return try! FfiConverterTypeAddress_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_address_generate($0 + ) +}) +} + + + +open func toBytes() -> Data { + return try! FfiConverterData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_address_to_bytes(self.uniffiClonePointer(),$0 + ) +}) +} + +open func toHex() -> String { + return try! FfiConverterString.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_address_to_hex(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeAddress: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = Address + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Address { + return Address(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: Address) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Address { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: Address, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAddress_lift(_ pointer: UnsafeMutableRawPointer) throws -> Address { + return try FfiConverterTypeAddress.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAddress_lower(_ value: Address) -> UnsafeMutableRawPointer { + return FfiConverterTypeAddress.lower(value) +} + + + + + + +/** + * 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 + * ``` + */ +public protocol ArgumentProtocol: AnyObject, Sendable { + + /** + * Turn a Result into a NestedResult. If the argument is not a Result, + * returns None. + */ + func nested(ix: UInt16) -> Argument? + +} +/** + * 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 + * ``` + */ +open class Argument: ArgumentProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_argument(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_argument(pointer, $0) } + } + + + /** + * The gas coin. The gas coin can only be used by-ref, except for with + * `TransferObjects`, which can use it by-value. + */ +public static func newGas() -> Argument { + return try! FfiConverterTypeArgument_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_argument_new_gas($0 + ) +}) +} + + /** + * One of the input objects or primitive values (from + * `ProgrammableTransaction` inputs) + */ +public static func newInput(input: UInt16) -> Argument { + return try! FfiConverterTypeArgument_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_argument_new_input( + FfiConverterUInt16.lower(input),$0 + ) +}) +} + + /** + * 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. + */ +public static func newNestedResult(commandIndex: UInt16, subresultIndex: UInt16) -> Argument { + return try! FfiConverterTypeArgument_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_argument_new_nested_result( + FfiConverterUInt16.lower(commandIndex), + FfiConverterUInt16.lower(subresultIndex),$0 + ) +}) +} + + /** + * The result of another command (from `ProgrammableTransaction` commands) + */ +public static func newResult(result: UInt16) -> Argument { + return try! FfiConverterTypeArgument_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_argument_new_result( + FfiConverterUInt16.lower(result),$0 + ) +}) +} + + + + /** + * Turn a Result into a NestedResult. If the argument is not a Result, + * returns None. + */ +open func nested(ix: UInt16) -> Argument? { + return try! FfiConverterOptionTypeArgument.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_argument_nested(self.uniffiClonePointer(), + FfiConverterUInt16.lower(ix),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeArgument: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = Argument + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Argument { + return Argument(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: Argument) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Argument { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: Argument, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeArgument_lift(_ pointer: UnsafeMutableRawPointer) throws -> Argument { + return try FfiConverterTypeArgument.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeArgument_lower(_ value: Argument) -> UnsafeMutableRawPointer { + return FfiConverterTypeArgument.lower(value) +} + + + + + + +public protocol BatchSendStatusProtocol: AnyObject, Sendable { + +} +open class BatchSendStatus: BatchSendStatusProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_batchsendstatus(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_batchsendstatus(pointer, $0) } + } + + + + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeBatchSendStatus: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = BatchSendStatus + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> BatchSendStatus { + return BatchSendStatus(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: BatchSendStatus) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> BatchSendStatus { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: BatchSendStatus, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeBatchSendStatus_lift(_ pointer: UnsafeMutableRawPointer) throws -> BatchSendStatus { + return try FfiConverterTypeBatchSendStatus.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeBatchSendStatus_lower(_ value: BatchSendStatus) -> UnsafeMutableRawPointer { + return FfiConverterTypeBatchSendStatus.lower(value) +} + + + + + + +/** + * 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 96OCTECT + * ``` + * + * 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. + */ +public protocol Bls12381PublicKeyProtocol: AnyObject, Sendable { + + func toBytes() -> Data + +} +/** + * 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 96OCTECT + * ``` + * + * 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. + */ +open class Bls12381PublicKey: Bls12381PublicKeyProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_bls12381publickey(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_bls12381publickey(pointer, $0) } + } + + +public static func fromBytes(bytes: Data)throws -> Bls12381PublicKey { + return try FfiConverterTypeBls12381PublicKey_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_bls12381publickey_from_bytes( + FfiConverterData.lower(bytes),$0 + ) +}) +} + +public static func fromStr(s: String)throws -> Bls12381PublicKey { + return try FfiConverterTypeBls12381PublicKey_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_bls12381publickey_from_str( + FfiConverterString.lower(s),$0 + ) +}) +} + +public static func generate() -> Bls12381PublicKey { + return try! FfiConverterTypeBls12381PublicKey_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_bls12381publickey_generate($0 + ) +}) +} + + + +open func toBytes() -> Data { + return try! FfiConverterData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_bls12381publickey_to_bytes(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeBls12381PublicKey: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = Bls12381PublicKey + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Bls12381PublicKey { + return Bls12381PublicKey(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: Bls12381PublicKey) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Bls12381PublicKey { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: Bls12381PublicKey, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeBls12381PublicKey_lift(_ pointer: UnsafeMutableRawPointer) throws -> Bls12381PublicKey { + return try FfiConverterTypeBls12381PublicKey.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeBls12381PublicKey_lower(_ value: Bls12381PublicKey) -> UnsafeMutableRawPointer { + return FfiConverterTypeBls12381PublicKey.lower(value) +} + + + + + + +/** + * 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 96OCTECT + * ``` + * + * 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. + */ +public protocol Bls12381SignatureProtocol: AnyObject, Sendable { + + func toBytes() -> Data + +} +/** + * 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 96OCTECT + * ``` + * + * 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. + */ +open class Bls12381Signature: Bls12381SignatureProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_bls12381signature(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_bls12381signature(pointer, $0) } + } + + +public static func fromBytes(bytes: Data)throws -> Bls12381Signature { + return try FfiConverterTypeBls12381Signature_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_bls12381signature_from_bytes( + FfiConverterData.lower(bytes),$0 + ) +}) +} + +public static func fromStr(s: String)throws -> Bls12381Signature { + return try FfiConverterTypeBls12381Signature_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_bls12381signature_from_str( + FfiConverterString.lower(s),$0 + ) +}) +} + +public static func generate() -> Bls12381Signature { + return try! FfiConverterTypeBls12381Signature_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_bls12381signature_generate($0 + ) +}) +} + + + +open func toBytes() -> Data { + return try! FfiConverterData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_bls12381signature_to_bytes(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeBls12381Signature: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = Bls12381Signature + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Bls12381Signature { + return Bls12381Signature(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: Bls12381Signature) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Bls12381Signature { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: Bls12381Signature, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeBls12381Signature_lift(_ pointer: UnsafeMutableRawPointer) throws -> Bls12381Signature { + return try FfiConverterTypeBls12381Signature.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeBls12381Signature_lower(_ value: Bls12381Signature) -> UnsafeMutableRawPointer { + return FfiConverterTypeBls12381Signature.lower(value) +} + + + + + + +/** + * 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 + * ``` + */ +public protocol Bn254FieldElementProtocol: AnyObject, Sendable { + + func padded() -> Data + + func unpadded() -> Data + +} +/** + * 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 + * ``` + */ +open class Bn254FieldElement: Bn254FieldElementProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_bn254fieldelement(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_bn254fieldelement(pointer, $0) } + } + + +public static func fromBytes(bytes: Data)throws -> Bn254FieldElement { + return try FfiConverterTypeBn254FieldElement_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_bn254fieldelement_from_bytes( + FfiConverterData.lower(bytes),$0 + ) +}) +} + +public static func fromStr(s: String)throws -> Bn254FieldElement { + return try FfiConverterTypeBn254FieldElement_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_bn254fieldelement_from_str( + FfiConverterString.lower(s),$0 + ) +}) +} + +public static func fromStrRadix10(s: String)throws -> Bn254FieldElement { + return try FfiConverterTypeBn254FieldElement_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_bn254fieldelement_from_str_radix_10( + FfiConverterString.lower(s),$0 + ) +}) +} + + + +open func padded() -> Data { + return try! FfiConverterData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_bn254fieldelement_padded(self.uniffiClonePointer(),$0 + ) +}) +} + +open func unpadded() -> Data { + return try! FfiConverterData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_bn254fieldelement_unpadded(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeBn254FieldElement: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = Bn254FieldElement + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Bn254FieldElement { + return Bn254FieldElement(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: Bn254FieldElement) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Bn254FieldElement { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: Bn254FieldElement, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeBn254FieldElement_lift(_ pointer: UnsafeMutableRawPointer) throws -> Bn254FieldElement { + return try FfiConverterTypeBn254FieldElement.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeBn254FieldElement_lower(_ value: Bn254FieldElement) -> UnsafeMutableRawPointer { + return FfiConverterTypeBn254FieldElement.lower(value) +} + + + + + + +/** + * 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) + * ``` + */ +public protocol CancelledTransactionProtocol: AnyObject, Sendable { + + func digest() -> TransactionDigest + + func versionAssignments() -> [VersionAssignment] + +} +/** + * 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) + * ``` + */ +open class CancelledTransaction: CancelledTransactionProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_cancelledtransaction(self.pointer, $0) } + } +public convenience init(digest: TransactionDigest, versionAssignments: [VersionAssignment]) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_cancelledtransaction_new( + FfiConverterTypeTransactionDigest_lower(digest), + FfiConverterSequenceTypeVersionAssignment.lower(versionAssignments),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_cancelledtransaction(pointer, $0) } + } + + + + +open func digest() -> TransactionDigest { + return try! FfiConverterTypeTransactionDigest_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_cancelledtransaction_digest(self.uniffiClonePointer(),$0 + ) +}) +} + +open func versionAssignments() -> [VersionAssignment] { + return try! FfiConverterSequenceTypeVersionAssignment.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_cancelledtransaction_version_assignments(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeCancelledTransaction: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = CancelledTransaction + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> CancelledTransaction { + return CancelledTransaction(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: CancelledTransaction) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CancelledTransaction { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: CancelledTransaction, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeCancelledTransaction_lift(_ pointer: UnsafeMutableRawPointer) throws -> CancelledTransaction { + return try FfiConverterTypeCancelledTransaction.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeCancelledTransaction_lower(_ value: CancelledTransaction) -> UnsafeMutableRawPointer { + return FfiConverterTypeCancelledTransaction.lower(value) +} + + + + + + +/** + * 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) + * ``` + */ +public protocol ChangeEpochProtocol: AnyObject, Sendable { + + /** + * The total amount of gas charged for computation during the epoch. + */ + func computationCharge() -> UInt64 + + /** + * The next (to become) epoch ID. + */ + func epoch() -> UInt64 + + /** + * Unix timestamp when epoch started + */ + func epochStartTimestampMs() -> UInt64 + + /** + * The non-refundable storage fee. + */ + func nonRefundableStorageFee() -> UInt64 + + /** + * The protocol version in effect in the new epoch. + */ + func protocolVersion() -> UInt64 + + /** + * The total amount of gas charged for storage during the epoch. + */ + func storageCharge() -> UInt64 + + /** + * The amount of storage rebate refunded to the txn senders. + */ + func storageRebate() -> UInt64 + + /** + * System packages (specifically framework and move stdlib) that are + * written before the new epoch starts. + */ + func systemPackages() -> [SystemPackage] + +} +/** + * 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) + * ``` + */ +open class ChangeEpoch: ChangeEpochProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_changeepoch(self.pointer, $0) } + } +public convenience init(epoch: UInt64, protocolVersion: UInt64, storageCharge: UInt64, computationCharge: UInt64, storageRebate: UInt64, nonRefundableStorageFee: UInt64, epochStartTimestampMs: UInt64, systemPackages: [SystemPackage]) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_changeepoch_new( + FfiConverterUInt64.lower(epoch), + FfiConverterUInt64.lower(protocolVersion), + FfiConverterUInt64.lower(storageCharge), + FfiConverterUInt64.lower(computationCharge), + FfiConverterUInt64.lower(storageRebate), + FfiConverterUInt64.lower(nonRefundableStorageFee), + FfiConverterUInt64.lower(epochStartTimestampMs), + FfiConverterSequenceTypeSystemPackage.lower(systemPackages),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_changeepoch(pointer, $0) } + } + + + + + /** + * The total amount of gas charged for computation during the epoch. + */ +open func computationCharge() -> UInt64 { + return try! FfiConverterUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_changeepoch_computation_charge(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * The next (to become) epoch ID. + */ +open func epoch() -> UInt64 { + return try! FfiConverterUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_changeepoch_epoch(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Unix timestamp when epoch started + */ +open func epochStartTimestampMs() -> UInt64 { + return try! FfiConverterUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_changeepoch_epoch_start_timestamp_ms(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * The non-refundable storage fee. + */ +open func nonRefundableStorageFee() -> UInt64 { + return try! FfiConverterUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_changeepoch_non_refundable_storage_fee(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * The protocol version in effect in the new epoch. + */ +open func protocolVersion() -> UInt64 { + return try! FfiConverterUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_changeepoch_protocol_version(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * The total amount of gas charged for storage during the epoch. + */ +open func storageCharge() -> UInt64 { + return try! FfiConverterUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_changeepoch_storage_charge(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * The amount of storage rebate refunded to the txn senders. + */ +open func storageRebate() -> UInt64 { + return try! FfiConverterUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_changeepoch_storage_rebate(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * System packages (specifically framework and move stdlib) that are + * written before the new epoch starts. + */ +open func systemPackages() -> [SystemPackage] { + return try! FfiConverterSequenceTypeSystemPackage.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_changeepoch_system_packages(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeChangeEpoch: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = ChangeEpoch + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> ChangeEpoch { + return ChangeEpoch(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: ChangeEpoch) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ChangeEpoch { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: ChangeEpoch, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeChangeEpoch_lift(_ pointer: UnsafeMutableRawPointer) throws -> ChangeEpoch { + return try FfiConverterTypeChangeEpoch.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeChangeEpoch_lower(_ value: ChangeEpoch) -> UnsafeMutableRawPointer { + return FfiConverterTypeChangeEpoch.lower(value) +} + + + + + + +/** + * 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) + * ``` + */ +public protocol ChangeEpochV2Protocol: AnyObject, Sendable { + + /** + * The total amount of gas charged for computation during the epoch. + */ + func computationCharge() -> UInt64 + + /** + * The total amount of gas burned for computation during the epoch. + */ + func computationChargeBurned() -> UInt64 + + /** + * The next (to become) epoch ID. + */ + func epoch() -> UInt64 + + /** + * Unix timestamp when epoch started + */ + func epochStartTimestampMs() -> UInt64 + + /** + * The non-refundable storage fee. + */ + func nonRefundableStorageFee() -> UInt64 + + /** + * The protocol version in effect in the new epoch. + */ + func protocolVersion() -> UInt64 + + /** + * The total amount of gas charged for storage during the epoch. + */ + func storageCharge() -> UInt64 + + /** + * The amount of storage rebate refunded to the txn senders. + */ + func storageRebate() -> UInt64 + + /** + * System packages (specifically framework and move stdlib) that are + * written before the new epoch starts. + */ + func systemPackages() -> [SystemPackage] + +} +/** + * 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) + * ``` + */ +open class ChangeEpochV2: ChangeEpochV2Protocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_changeepochv2(self.pointer, $0) } + } +public convenience init(epoch: UInt64, protocolVersion: UInt64, storageCharge: UInt64, computationCharge: UInt64, computationChargeBurned: UInt64, storageRebate: UInt64, nonRefundableStorageFee: UInt64, epochStartTimestampMs: UInt64, systemPackages: [SystemPackage]) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_changeepochv2_new( + FfiConverterUInt64.lower(epoch), + FfiConverterUInt64.lower(protocolVersion), + FfiConverterUInt64.lower(storageCharge), + FfiConverterUInt64.lower(computationCharge), + FfiConverterUInt64.lower(computationChargeBurned), + FfiConverterUInt64.lower(storageRebate), + FfiConverterUInt64.lower(nonRefundableStorageFee), + FfiConverterUInt64.lower(epochStartTimestampMs), + FfiConverterSequenceTypeSystemPackage.lower(systemPackages),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_changeepochv2(pointer, $0) } + } + + + + + /** + * The total amount of gas charged for computation during the epoch. + */ +open func computationCharge() -> UInt64 { + return try! FfiConverterUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_changeepochv2_computation_charge(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * The total amount of gas burned for computation during the epoch. + */ +open func computationChargeBurned() -> UInt64 { + return try! FfiConverterUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_changeepochv2_computation_charge_burned(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * The next (to become) epoch ID. + */ +open func epoch() -> UInt64 { + return try! FfiConverterUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_changeepochv2_epoch(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Unix timestamp when epoch started + */ +open func epochStartTimestampMs() -> UInt64 { + return try! FfiConverterUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_changeepochv2_epoch_start_timestamp_ms(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * The non-refundable storage fee. + */ +open func nonRefundableStorageFee() -> UInt64 { + return try! FfiConverterUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_changeepochv2_non_refundable_storage_fee(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * The protocol version in effect in the new epoch. + */ +open func protocolVersion() -> UInt64 { + return try! FfiConverterUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_changeepochv2_protocol_version(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * The total amount of gas charged for storage during the epoch. + */ +open func storageCharge() -> UInt64 { + return try! FfiConverterUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_changeepochv2_storage_charge(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * The amount of storage rebate refunded to the txn senders. + */ +open func storageRebate() -> UInt64 { + return try! FfiConverterUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_changeepochv2_storage_rebate(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * System packages (specifically framework and move stdlib) that are + * written before the new epoch starts. + */ +open func systemPackages() -> [SystemPackage] { + return try! FfiConverterSequenceTypeSystemPackage.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_changeepochv2_system_packages(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeChangeEpochV2: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = ChangeEpochV2 + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> ChangeEpochV2 { + return ChangeEpochV2(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: ChangeEpochV2) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ChangeEpochV2 { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: ChangeEpochV2, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeChangeEpochV2_lift(_ pointer: UnsafeMutableRawPointer) throws -> ChangeEpochV2 { + return try FfiConverterTypeChangeEpochV2.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeChangeEpochV2_lower(_ value: ChangeEpochV2) -> UnsafeMutableRawPointer { + return FfiConverterTypeChangeEpochV2.lower(value) +} + + + + + + +public protocol CheckpointCommitmentProtocol: AnyObject, Sendable { + + func asEcmhLiveObjectSetDigest() -> Digest + + func isEcmhLiveObjectSet() -> Bool + +} +open class CheckpointCommitment: CheckpointCommitmentProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_checkpointcommitment(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_checkpointcommitment(pointer, $0) } + } + + + + +open func asEcmhLiveObjectSetDigest() -> Digest { + return try! FfiConverterTypeDigest_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_checkpointcommitment_as_ecmh_live_object_set_digest(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isEcmhLiveObjectSet() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_checkpointcommitment_is_ecmh_live_object_set(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeCheckpointCommitment: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = CheckpointCommitment + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> CheckpointCommitment { + return CheckpointCommitment(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: CheckpointCommitment) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CheckpointCommitment { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: CheckpointCommitment, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeCheckpointCommitment_lift(_ pointer: UnsafeMutableRawPointer) throws -> CheckpointCommitment { + return try FfiConverterTypeCheckpointCommitment.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeCheckpointCommitment_lower(_ value: CheckpointCommitment) -> UnsafeMutableRawPointer { + return FfiConverterTypeCheckpointCommitment.lower(value) +} + + + + + + +public protocol CheckpointContentsDigestProtocol: AnyObject, Sendable { + + func toBase58() -> String + + func toBytes() -> Data + +} +open class CheckpointContentsDigest: CheckpointContentsDigestProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_checkpointcontentsdigest(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_checkpointcontentsdigest(pointer, $0) } + } + + +public static func fromBase58(base58: String)throws -> CheckpointContentsDigest { + return try FfiConverterTypeCheckpointContentsDigest_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_checkpointcontentsdigest_from_base58( + FfiConverterString.lower(base58),$0 + ) +}) +} + +public static func fromBytes(bytes: Data)throws -> CheckpointContentsDigest { + return try FfiConverterTypeCheckpointContentsDigest_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_checkpointcontentsdigest_from_bytes( + FfiConverterData.lower(bytes),$0 + ) +}) +} + +public static func generate() -> CheckpointContentsDigest { + return try! FfiConverterTypeCheckpointContentsDigest_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_checkpointcontentsdigest_generate($0 + ) +}) +} + + + +open func toBase58() -> String { + return try! FfiConverterString.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_checkpointcontentsdigest_to_base58(self.uniffiClonePointer(),$0 + ) +}) +} + +open func toBytes() -> Data { + return try! FfiConverterData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_checkpointcontentsdigest_to_bytes(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeCheckpointContentsDigest: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = CheckpointContentsDigest + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> CheckpointContentsDigest { + return CheckpointContentsDigest(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: CheckpointContentsDigest) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CheckpointContentsDigest { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: CheckpointContentsDigest, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeCheckpointContentsDigest_lift(_ pointer: UnsafeMutableRawPointer) throws -> CheckpointContentsDigest { + return try FfiConverterTypeCheckpointContentsDigest.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeCheckpointContentsDigest_lower(_ value: CheckpointContentsDigest) -> UnsafeMutableRawPointer { + return FfiConverterTypeCheckpointContentsDigest.lower(value) +} + + + + + + +public protocol CheckpointDigestProtocol: AnyObject, Sendable { + + func toBase58() -> String + + func toBytes() -> Data + +} +open class CheckpointDigest: CheckpointDigestProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_checkpointdigest(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_checkpointdigest(pointer, $0) } + } + + +public static func fromBase58(base58: String)throws -> CheckpointDigest { + return try FfiConverterTypeCheckpointDigest_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_checkpointdigest_from_base58( + FfiConverterString.lower(base58),$0 + ) +}) +} + +public static func fromBytes(bytes: Data)throws -> CheckpointDigest { + return try FfiConverterTypeCheckpointDigest_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_checkpointdigest_from_bytes( + FfiConverterData.lower(bytes),$0 + ) +}) +} + +public static func generate() -> CheckpointDigest { + return try! FfiConverterTypeCheckpointDigest_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_checkpointdigest_generate($0 + ) +}) +} + + + +open func toBase58() -> String { + return try! FfiConverterString.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_checkpointdigest_to_base58(self.uniffiClonePointer(),$0 + ) +}) +} + +open func toBytes() -> Data { + return try! FfiConverterData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_checkpointdigest_to_bytes(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeCheckpointDigest: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = CheckpointDigest + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> CheckpointDigest { + return CheckpointDigest(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: CheckpointDigest) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CheckpointDigest { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: CheckpointDigest, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeCheckpointDigest_lift(_ pointer: UnsafeMutableRawPointer) throws -> CheckpointDigest { + return try FfiConverterTypeCheckpointDigest.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeCheckpointDigest_lower(_ value: CheckpointDigest) -> UnsafeMutableRawPointer { + return FfiConverterTypeCheckpointDigest.lower(value) +} + + + + + + +/** + * 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) + * ``` + */ +public protocol CircomG1Protocol: AnyObject, Sendable { + +} +/** + * 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) + * ``` + */ +open class CircomG1: CircomG1Protocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_circomg1(self.pointer, $0) } + } +public convenience init(el0: Bn254FieldElement, el1: Bn254FieldElement, el2: Bn254FieldElement) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_circomg1_new( + FfiConverterTypeBn254FieldElement_lower(el0), + FfiConverterTypeBn254FieldElement_lower(el1), + FfiConverterTypeBn254FieldElement_lower(el2),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_circomg1(pointer, $0) } + } + + + + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeCircomG1: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = CircomG1 + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> CircomG1 { + return CircomG1(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: CircomG1) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CircomG1 { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: CircomG1, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeCircomG1_lift(_ pointer: UnsafeMutableRawPointer) throws -> CircomG1 { + return try FfiConverterTypeCircomG1.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeCircomG1_lower(_ value: CircomG1) -> UnsafeMutableRawPointer { + return FfiConverterTypeCircomG1.lower(value) +} + + + + + + +/** + * 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)) + * ``` + */ +public protocol CircomG2Protocol: AnyObject, Sendable { + +} +/** + * 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)) + * ``` + */ +open class CircomG2: CircomG2Protocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_circomg2(self.pointer, $0) } + } +public convenience init(el00: Bn254FieldElement, el01: Bn254FieldElement, el10: Bn254FieldElement, el11: Bn254FieldElement, el20: Bn254FieldElement, el21: Bn254FieldElement) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_circomg2_new( + FfiConverterTypeBn254FieldElement_lower(el00), + FfiConverterTypeBn254FieldElement_lower(el01), + FfiConverterTypeBn254FieldElement_lower(el10), + FfiConverterTypeBn254FieldElement_lower(el11), + FfiConverterTypeBn254FieldElement_lower(el20), + FfiConverterTypeBn254FieldElement_lower(el21),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_circomg2(pointer, $0) } + } + + + + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeCircomG2: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = CircomG2 + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> CircomG2 { + return CircomG2(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: CircomG2) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CircomG2 { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: CircomG2, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeCircomG2_lift(_ pointer: UnsafeMutableRawPointer) throws -> CircomG2 { + return try FfiConverterTypeCircomG2.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeCircomG2_lower(_ value: CircomG2) -> UnsafeMutableRawPointer { + return FfiConverterTypeCircomG2.lower(value) +} + + + + + + +public protocol CoinProtocol: AnyObject, Sendable { + + func balance() -> UInt64 + + func coinType() -> TypeTag + + func id() -> ObjectId + +} +open class Coin: CoinProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_coin(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_coin(pointer, $0) } + } + + +public static func tryFromObject(object: Object)throws -> Coin { + return try FfiConverterTypeCoin_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_coin_try_from_object( + FfiConverterTypeObject_lower(object),$0 + ) +}) +} + + + +open func balance() -> UInt64 { + return try! FfiConverterUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_coin_balance(self.uniffiClonePointer(),$0 + ) +}) +} + +open func coinType() -> TypeTag { + return try! FfiConverterTypeTypeTag_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_coin_coin_type(self.uniffiClonePointer(),$0 + ) +}) +} + +open func id() -> ObjectId { + return try! FfiConverterTypeObjectId_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_coin_id(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeCoin: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = Coin + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Coin { + return Coin(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: Coin) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Coin { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: Coin, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeCoin_lift(_ pointer: UnsafeMutableRawPointer) throws -> Coin { + return try FfiConverterTypeCoin.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeCoin_lower(_ value: Coin) -> UnsafeMutableRawPointer { + return FfiConverterTypeCoin.lower(value) +} + + + + + + +/** + * 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 + * ``` + */ +public protocol CommandProtocol: AnyObject, Sendable { + +} +/** + * 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 + * ``` + */ +open class Command: CommandProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_command(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_command(pointer, $0) } + } + + + /** + * Given n-values of the same type, it constructs a vector. For non objects + * or an empty vector, the type tag must be specified. + */ +public static func newMakeMoveVector(makeMoveVector: MakeMoveVector) -> Command { + return try! FfiConverterTypeCommand_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_command_new_make_move_vector( + FfiConverterTypeMakeMoveVector_lower(makeMoveVector),$0 + ) +}) +} + + /** + * It merges n-coins into the first coin + */ +public static func newMergeCoins(mergeCoins: MergeCoins) -> Command { + return try! FfiConverterTypeCommand_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_command_new_merge_coins( + FfiConverterTypeMergeCoins_lower(mergeCoins),$0 + ) +}) +} + + /** + * A call to either an entry or a public Move function + */ +public static func newMoveCall(moveCall: MoveCall) -> Command { + return try! FfiConverterTypeCommand_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_command_new_move_call( + FfiConverterTypeMoveCall_lower(moveCall),$0 + ) +}) +} + + /** + * Publishes a Move package. It takes the package bytes and a list of the + * package's transitive dependencies to link against on-chain. + */ +public static func newPublish(publish: Publish) -> Command { + return try! FfiConverterTypeCommand_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_command_new_publish( + FfiConverterTypePublish_lower(publish),$0 + ) +}) +} + + /** + * It splits off some amounts into a new coins with those amounts + */ +public static func newSplitCoins(splitCoins: SplitCoins) -> Command { + return try! FfiConverterTypeCommand_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_command_new_split_coins( + FfiConverterTypeSplitCoins_lower(splitCoins),$0 + ) +}) +} + + /** + * 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. + */ +public static func newTransferObjects(transferObjects: TransferObjects) -> Command { + return try! FfiConverterTypeCommand_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_command_new_transfer_objects( + FfiConverterTypeTransferObjects_lower(transferObjects),$0 + ) +}) +} + + /** + * 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. + */ +public static func newUpgrade(upgrade: Upgrade) -> Command { + return try! FfiConverterTypeCommand_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_command_new_upgrade( + FfiConverterTypeUpgrade_lower(upgrade),$0 + ) +}) +} + + + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeCommand: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = Command + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Command { + return Command(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: Command) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Command { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: Command, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeCommand_lift(_ pointer: UnsafeMutableRawPointer) throws -> Command { + return try FfiConverterTypeCommand.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeCommand_lower(_ value: Command) -> UnsafeMutableRawPointer { + return FfiConverterTypeCommand.lower(value) +} + + + + + + +public protocol ConsensusCommitDigestProtocol: AnyObject, Sendable { + + func toBase58() -> String + + func toBytes() -> Data + +} +open class ConsensusCommitDigest: ConsensusCommitDigestProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_consensuscommitdigest(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_consensuscommitdigest(pointer, $0) } + } + + +public static func fromBase58(base58: String)throws -> ConsensusCommitDigest { + return try FfiConverterTypeConsensusCommitDigest_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_consensuscommitdigest_from_base58( + FfiConverterString.lower(base58),$0 + ) +}) +} + +public static func fromBytes(bytes: Data)throws -> ConsensusCommitDigest { + return try FfiConverterTypeConsensusCommitDigest_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_consensuscommitdigest_from_bytes( + FfiConverterData.lower(bytes),$0 + ) +}) +} + +public static func generate() -> ConsensusCommitDigest { + return try! FfiConverterTypeConsensusCommitDigest_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_consensuscommitdigest_generate($0 + ) +}) +} + + + +open func toBase58() -> String { + return try! FfiConverterString.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_consensuscommitdigest_to_base58(self.uniffiClonePointer(),$0 + ) +}) +} + +open func toBytes() -> Data { + return try! FfiConverterData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_consensuscommitdigest_to_bytes(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeConsensusCommitDigest: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = ConsensusCommitDigest + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> ConsensusCommitDigest { + return ConsensusCommitDigest(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: ConsensusCommitDigest) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ConsensusCommitDigest { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: ConsensusCommitDigest, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeConsensusCommitDigest_lift(_ pointer: UnsafeMutableRawPointer) throws -> ConsensusCommitDigest { + return try FfiConverterTypeConsensusCommitDigest.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeConsensusCommitDigest_lower(_ value: ConsensusCommitDigest) -> UnsafeMutableRawPointer { + return FfiConverterTypeConsensusCommitDigest.lower(value) +} + + + + + + +/** + * 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 + * ``` + */ +public protocol ConsensusCommitPrologueV1Protocol: AnyObject, Sendable { + + /** + * Unix timestamp from consensus + */ + func commitTimestampMs() -> UInt64 + + /** + * Digest of consensus output + */ + func consensusCommitDigest() -> ConsensusCommitDigest + + /** + * Stores consensus handler determined shared object version assignments. + */ + func consensusDeterminedVersionAssignments() -> ConsensusDeterminedVersionAssignments + + /** + * Epoch of the commit prologue transaction + */ + func epoch() -> UInt64 + + /** + * Consensus round of the commit + */ + func round() -> UInt64 + + /** + * The sub DAG index of the consensus commit. This field will be populated + * if there are multiple consensus commits per round. + */ + func subDagIndex() -> UInt64? + +} +/** + * 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 + * ``` + */ +open class ConsensusCommitPrologueV1: ConsensusCommitPrologueV1Protocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_consensuscommitprologuev1(self.pointer, $0) } + } +public convenience init(epoch: UInt64, round: UInt64, subDagIndex: UInt64?, commitTimestampMs: UInt64, consensusCommitDigest: ConsensusCommitDigest, consensusDeterminedVersionAssignments: ConsensusDeterminedVersionAssignments) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_consensuscommitprologuev1_new( + FfiConverterUInt64.lower(epoch), + FfiConverterUInt64.lower(round), + FfiConverterOptionUInt64.lower(subDagIndex), + FfiConverterUInt64.lower(commitTimestampMs), + FfiConverterTypeConsensusCommitDigest_lower(consensusCommitDigest), + FfiConverterTypeConsensusDeterminedVersionAssignments_lower(consensusDeterminedVersionAssignments),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_consensuscommitprologuev1(pointer, $0) } + } + + + + + /** + * Unix timestamp from consensus + */ +open func commitTimestampMs() -> UInt64 { + return try! FfiConverterUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_commit_timestamp_ms(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Digest of consensus output + */ +open func consensusCommitDigest() -> ConsensusCommitDigest { + return try! FfiConverterTypeConsensusCommitDigest_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_consensus_commit_digest(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Stores consensus handler determined shared object version assignments. + */ +open func consensusDeterminedVersionAssignments() -> ConsensusDeterminedVersionAssignments { + return try! FfiConverterTypeConsensusDeterminedVersionAssignments_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_consensus_determined_version_assignments(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Epoch of the commit prologue transaction + */ +open func epoch() -> UInt64 { + return try! FfiConverterUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_epoch(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Consensus round of the commit + */ +open func round() -> UInt64 { + return try! FfiConverterUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_round(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * The sub DAG index of the consensus commit. This field will be populated + * if there are multiple consensus commits per round. + */ +open func subDagIndex() -> UInt64? { + return try! FfiConverterOptionUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_sub_dag_index(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeConsensusCommitPrologueV1: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = ConsensusCommitPrologueV1 + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> ConsensusCommitPrologueV1 { + return ConsensusCommitPrologueV1(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: ConsensusCommitPrologueV1) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ConsensusCommitPrologueV1 { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: ConsensusCommitPrologueV1, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeConsensusCommitPrologueV1_lift(_ pointer: UnsafeMutableRawPointer) throws -> ConsensusCommitPrologueV1 { + return try FfiConverterTypeConsensusCommitPrologueV1.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeConsensusCommitPrologueV1_lower(_ value: ConsensusCommitPrologueV1) -> UnsafeMutableRawPointer { + return FfiConverterTypeConsensusCommitPrologueV1.lower(value) +} + + + + + + +public protocol ConsensusDeterminedVersionAssignmentsProtocol: AnyObject, Sendable { + + func asCancelledTransactions() -> [CancelledTransaction] + + func asCancelledTransactionsOpt() -> [CancelledTransaction]? + + func isCancelledTransactions() -> Bool + +} +open class ConsensusDeterminedVersionAssignments: ConsensusDeterminedVersionAssignmentsProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_consensusdeterminedversionassignments(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_consensusdeterminedversionassignments(pointer, $0) } + } + + +public static func newCancelledTransactions(cancelledTransactions: [CancelledTransaction]) -> ConsensusDeterminedVersionAssignments { + return try! FfiConverterTypeConsensusDeterminedVersionAssignments_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_consensusdeterminedversionassignments_new_cancelled_transactions( + FfiConverterSequenceTypeCancelledTransaction.lower(cancelledTransactions),$0 + ) +}) +} + + + +open func asCancelledTransactions() -> [CancelledTransaction] { + return try! FfiConverterSequenceTypeCancelledTransaction.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_consensusdeterminedversionassignments_as_cancelled_transactions(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asCancelledTransactionsOpt() -> [CancelledTransaction]? { + return try! FfiConverterOptionSequenceTypeCancelledTransaction.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_consensusdeterminedversionassignments_as_cancelled_transactions_opt(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isCancelledTransactions() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_consensusdeterminedversionassignments_is_cancelled_transactions(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeConsensusDeterminedVersionAssignments: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = ConsensusDeterminedVersionAssignments + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> ConsensusDeterminedVersionAssignments { + return ConsensusDeterminedVersionAssignments(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: ConsensusDeterminedVersionAssignments) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ConsensusDeterminedVersionAssignments { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: ConsensusDeterminedVersionAssignments, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeConsensusDeterminedVersionAssignments_lift(_ pointer: UnsafeMutableRawPointer) throws -> ConsensusDeterminedVersionAssignments { + return try FfiConverterTypeConsensusDeterminedVersionAssignments.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeConsensusDeterminedVersionAssignments_lower(_ value: ConsensusDeterminedVersionAssignments) -> UnsafeMutableRawPointer { + return FfiConverterTypeConsensusDeterminedVersionAssignments.lower(value) +} + + + + + + +/** + * 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. + */ +public protocol DigestProtocol: AnyObject, Sendable { + + func toBase58() -> String + + func toBytes() -> Data + +} +/** + * 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. + */ +open class Digest: DigestProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_digest(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_digest(pointer, $0) } + } + + +public static func fromBase58(base58: String)throws -> Digest { + return try FfiConverterTypeDigest_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_digest_from_base58( + FfiConverterString.lower(base58),$0 + ) +}) +} + +public static func fromBytes(bytes: Data)throws -> Digest { + return try FfiConverterTypeDigest_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_digest_from_bytes( + FfiConverterData.lower(bytes),$0 + ) +}) +} + +public static func generate() -> Digest { + return try! FfiConverterTypeDigest_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_digest_generate($0 + ) +}) +} + + + +open func toBase58() -> String { + return try! FfiConverterString.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_digest_to_base58(self.uniffiClonePointer(),$0 + ) +}) +} + +open func toBytes() -> Data { + return try! FfiConverterData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_digest_to_bytes(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeDigest: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = Digest + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Digest { + return Digest(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: Digest) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Digest { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: Digest, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeDigest_lift(_ pointer: UnsafeMutableRawPointer) throws -> Digest { + return try FfiConverterTypeDigest.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeDigest_lower(_ value: Digest) -> UnsafeMutableRawPointer { + return FfiConverterTypeDigest.lower(value) +} + + + + + + +/** + * An ed25519 public key. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * ed25519-public-key = 32OCTECT + * ``` + */ +public protocol Ed25519PublicKeyProtocol: AnyObject, Sendable { + + func toBytes() -> Data + +} +/** + * An ed25519 public key. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * ed25519-public-key = 32OCTECT + * ``` + */ +open class Ed25519PublicKey: Ed25519PublicKeyProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_ed25519publickey(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_ed25519publickey(pointer, $0) } + } + + +public static func fromBytes(bytes: Data)throws -> Ed25519PublicKey { + return try FfiConverterTypeEd25519PublicKey_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_ed25519publickey_from_bytes( + FfiConverterData.lower(bytes),$0 + ) +}) +} + +public static func fromStr(s: String)throws -> Ed25519PublicKey { + return try FfiConverterTypeEd25519PublicKey_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_ed25519publickey_from_str( + FfiConverterString.lower(s),$0 + ) +}) +} + +public static func generate() -> Ed25519PublicKey { + return try! FfiConverterTypeEd25519PublicKey_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_ed25519publickey_generate($0 + ) +}) +} + + + +open func toBytes() -> Data { + return try! FfiConverterData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_ed25519publickey_to_bytes(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeEd25519PublicKey: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = Ed25519PublicKey + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Ed25519PublicKey { + return Ed25519PublicKey(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: Ed25519PublicKey) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Ed25519PublicKey { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: Ed25519PublicKey, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeEd25519PublicKey_lift(_ pointer: UnsafeMutableRawPointer) throws -> Ed25519PublicKey { + return try FfiConverterTypeEd25519PublicKey.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeEd25519PublicKey_lower(_ value: Ed25519PublicKey) -> UnsafeMutableRawPointer { + return FfiConverterTypeEd25519PublicKey.lower(value) +} + + + + + + +/** + * An ed25519 signature. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * ed25519-signature = 64OCTECT + * ``` + */ +public protocol Ed25519SignatureProtocol: AnyObject, Sendable { + + func toBytes() -> Data + +} +/** + * An ed25519 signature. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * ed25519-signature = 64OCTECT + * ``` + */ +open class Ed25519Signature: Ed25519SignatureProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_ed25519signature(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_ed25519signature(pointer, $0) } + } + + +public static func fromBytes(bytes: Data)throws -> Ed25519Signature { + return try FfiConverterTypeEd25519Signature_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_ed25519signature_from_bytes( + FfiConverterData.lower(bytes),$0 + ) +}) +} + +public static func fromStr(s: String)throws -> Ed25519Signature { + return try FfiConverterTypeEd25519Signature_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_ed25519signature_from_str( + FfiConverterString.lower(s),$0 + ) +}) +} + +public static func generate() -> Ed25519Signature { + return try! FfiConverterTypeEd25519Signature_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_ed25519signature_generate($0 + ) +}) +} + + + +open func toBytes() -> Data { + return try! FfiConverterData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_ed25519signature_to_bytes(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeEd25519Signature: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = Ed25519Signature + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Ed25519Signature { + return Ed25519Signature(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: Ed25519Signature) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Ed25519Signature { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: Ed25519Signature, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeEd25519Signature_lift(_ pointer: UnsafeMutableRawPointer) throws -> Ed25519Signature { + return try FfiConverterTypeEd25519Signature.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeEd25519Signature_lower(_ value: Ed25519Signature) -> UnsafeMutableRawPointer { + return FfiConverterTypeEd25519Signature.lower(value) +} + + + + + + +public protocol EffectsAuxiliaryDataDigestProtocol: AnyObject, Sendable { + + func toBase58() -> String + + func toBytes() -> Data + +} +open class EffectsAuxiliaryDataDigest: EffectsAuxiliaryDataDigestProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_effectsauxiliarydatadigest(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_effectsauxiliarydatadigest(pointer, $0) } + } + + +public static func fromBase58(base58: String)throws -> EffectsAuxiliaryDataDigest { + return try FfiConverterTypeEffectsAuxiliaryDataDigest_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_effectsauxiliarydatadigest_from_base58( + FfiConverterString.lower(base58),$0 + ) +}) +} + +public static func fromBytes(bytes: Data)throws -> EffectsAuxiliaryDataDigest { + return try FfiConverterTypeEffectsAuxiliaryDataDigest_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_effectsauxiliarydatadigest_from_bytes( + FfiConverterData.lower(bytes),$0 + ) +}) +} + +public static func generate() -> EffectsAuxiliaryDataDigest { + return try! FfiConverterTypeEffectsAuxiliaryDataDigest_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_effectsauxiliarydatadigest_generate($0 + ) +}) +} + + + +open func toBase58() -> String { + return try! FfiConverterString.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_effectsauxiliarydatadigest_to_base58(self.uniffiClonePointer(),$0 + ) +}) +} + +open func toBytes() -> Data { + return try! FfiConverterData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_effectsauxiliarydatadigest_to_bytes(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeEffectsAuxiliaryDataDigest: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = EffectsAuxiliaryDataDigest + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> EffectsAuxiliaryDataDigest { + return EffectsAuxiliaryDataDigest(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: EffectsAuxiliaryDataDigest) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> EffectsAuxiliaryDataDigest { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: EffectsAuxiliaryDataDigest, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeEffectsAuxiliaryDataDigest_lift(_ pointer: UnsafeMutableRawPointer) throws -> EffectsAuxiliaryDataDigest { + return try FfiConverterTypeEffectsAuxiliaryDataDigest.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeEffectsAuxiliaryDataDigest_lower(_ value: EffectsAuxiliaryDataDigest) -> UnsafeMutableRawPointer { + return FfiConverterTypeEffectsAuxiliaryDataDigest.lower(value) +} + + + + + + +/** + * 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 + * ``` + */ +public protocol EndOfEpochTransactionKindProtocol: AnyObject, Sendable { + +} +/** + * 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 + * ``` + */ +open class EndOfEpochTransactionKind: EndOfEpochTransactionKindProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_endofepochtransactionkind(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_endofepochtransactionkind(pointer, $0) } + } + + +public static func authenticatorStateCreate() -> EndOfEpochTransactionKind { + return try! FfiConverterTypeEndOfEpochTransactionKind_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_endofepochtransactionkind_authenticator_state_create($0 + ) +}) +} + +public static func authenticatorStateExpire(tx: AuthenticatorStateExpire) -> EndOfEpochTransactionKind { + return try! FfiConverterTypeEndOfEpochTransactionKind_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_endofepochtransactionkind_authenticator_state_expire( + FfiConverterTypeAuthenticatorStateExpire_lower(tx),$0 + ) +}) +} + +public static func changeEpoch(tx: ChangeEpoch) -> EndOfEpochTransactionKind { + return try! FfiConverterTypeEndOfEpochTransactionKind_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_endofepochtransactionkind_change_epoch( + FfiConverterTypeChangeEpoch_lower(tx),$0 + ) +}) +} + +public static func changeEpochV2(tx: ChangeEpochV2) -> EndOfEpochTransactionKind { + return try! FfiConverterTypeEndOfEpochTransactionKind_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_endofepochtransactionkind_change_epoch_v2( + FfiConverterTypeChangeEpochV2_lower(tx),$0 + ) +}) +} + + + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeEndOfEpochTransactionKind: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = EndOfEpochTransactionKind + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> EndOfEpochTransactionKind { + return EndOfEpochTransactionKind(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: EndOfEpochTransactionKind) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> EndOfEpochTransactionKind { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: EndOfEpochTransactionKind, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeEndOfEpochTransactionKind_lift(_ pointer: UnsafeMutableRawPointer) throws -> EndOfEpochTransactionKind { + return try FfiConverterTypeEndOfEpochTransactionKind.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeEndOfEpochTransactionKind_lower(_ value: EndOfEpochTransactionKind) -> UnsafeMutableRawPointer { + return FfiConverterTypeEndOfEpochTransactionKind.lower(value) +} + + + + + + +public protocol EpochProtocol: AnyObject, Sendable { + +} +open class Epoch: EpochProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_epoch(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_epoch(pointer, $0) } + } + + + + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeEpoch: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = Epoch + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Epoch { + return Epoch(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: Epoch) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Epoch { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: Epoch, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeEpoch_lift(_ pointer: UnsafeMutableRawPointer) throws -> Epoch { + return try FfiConverterTypeEpoch.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeEpoch_lower(_ value: Epoch) -> UnsafeMutableRawPointer { + return FfiConverterTypeEpoch.lower(value) +} + + + + + + +public protocol ExecutionTimeObservationProtocol: AnyObject, Sendable { + + func key() -> ExecutionTimeObservationKey + + func observations() -> [ValidatorExecutionTimeObservation] + +} +open class ExecutionTimeObservation: ExecutionTimeObservationProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_executiontimeobservation(self.pointer, $0) } + } +public convenience init(key: ExecutionTimeObservationKey, observations: [ValidatorExecutionTimeObservation]) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservation_new( + FfiConverterTypeExecutionTimeObservationKey_lower(key), + FfiConverterSequenceTypeValidatorExecutionTimeObservation.lower(observations),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_executiontimeobservation(pointer, $0) } + } + + + + +open func key() -> ExecutionTimeObservationKey { + return try! FfiConverterTypeExecutionTimeObservationKey_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_executiontimeobservation_key(self.uniffiClonePointer(),$0 + ) +}) +} + +open func observations() -> [ValidatorExecutionTimeObservation] { + return try! FfiConverterSequenceTypeValidatorExecutionTimeObservation.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_executiontimeobservation_observations(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeExecutionTimeObservation: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = ExecutionTimeObservation + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> ExecutionTimeObservation { + return ExecutionTimeObservation(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: ExecutionTimeObservation) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ExecutionTimeObservation { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: ExecutionTimeObservation, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeExecutionTimeObservation_lift(_ pointer: UnsafeMutableRawPointer) throws -> ExecutionTimeObservation { + return try FfiConverterTypeExecutionTimeObservation.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeExecutionTimeObservation_lower(_ value: ExecutionTimeObservation) -> UnsafeMutableRawPointer { + return FfiConverterTypeExecutionTimeObservation.lower(value) +} + + + + + + +/** + * 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) + * ``` + */ +public protocol ExecutionTimeObservationKeyProtocol: AnyObject, Sendable { + +} +/** + * 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) + * ``` + */ +open class ExecutionTimeObservationKey: ExecutionTimeObservationKeyProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_executiontimeobservationkey(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_executiontimeobservationkey(pointer, $0) } + } + + +public static func newMakeMoveVec() -> ExecutionTimeObservationKey { + return try! FfiConverterTypeExecutionTimeObservationKey_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_make_move_vec($0 + ) +}) +} + +public static func newMergeCoins() -> ExecutionTimeObservationKey { + return try! FfiConverterTypeExecutionTimeObservationKey_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_merge_coins($0 + ) +}) +} + +public static func newMoveEntryPoint(package: ObjectId, module: String, function: String, typeArguments: [TypeTag]) -> ExecutionTimeObservationKey { + return try! FfiConverterTypeExecutionTimeObservationKey_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_move_entry_point( + FfiConverterTypeObjectId_lower(package), + FfiConverterString.lower(module), + FfiConverterString.lower(function), + FfiConverterSequenceTypeTypeTag.lower(typeArguments),$0 + ) +}) +} + +public static func newPublish() -> ExecutionTimeObservationKey { + return try! FfiConverterTypeExecutionTimeObservationKey_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_publish($0 + ) +}) +} + +public static func newSplitCoins() -> ExecutionTimeObservationKey { + return try! FfiConverterTypeExecutionTimeObservationKey_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_split_coins($0 + ) +}) +} + +public static func newTransferObjects() -> ExecutionTimeObservationKey { + return try! FfiConverterTypeExecutionTimeObservationKey_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_transfer_objects($0 + ) +}) +} + +public static func newUpgrade() -> ExecutionTimeObservationKey { + return try! FfiConverterTypeExecutionTimeObservationKey_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_upgrade($0 + ) +}) +} + + + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeExecutionTimeObservationKey: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = ExecutionTimeObservationKey + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> ExecutionTimeObservationKey { + return ExecutionTimeObservationKey(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: ExecutionTimeObservationKey) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ExecutionTimeObservationKey { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: ExecutionTimeObservationKey, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeExecutionTimeObservationKey_lift(_ pointer: UnsafeMutableRawPointer) throws -> ExecutionTimeObservationKey { + return try FfiConverterTypeExecutionTimeObservationKey.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeExecutionTimeObservationKey_lower(_ value: ExecutionTimeObservationKey) -> UnsafeMutableRawPointer { + return FfiConverterTypeExecutionTimeObservationKey.lower(value) +} + + + + + + +/** + * 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) + * ) + * ``` + */ +public protocol ExecutionTimeObservationsProtocol: AnyObject, Sendable { + +} +/** + * 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) + * ) + * ``` + */ +open class ExecutionTimeObservations: ExecutionTimeObservationsProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_executiontimeobservations(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_executiontimeobservations(pointer, $0) } + } + + +public static func newV1(executionTimeObservations: [ExecutionTimeObservation]) -> ExecutionTimeObservations { + return try! FfiConverterTypeExecutionTimeObservations_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservations_new_v1( + FfiConverterSequenceTypeExecutionTimeObservation.lower(executionTimeObservations),$0 + ) +}) +} + + + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeExecutionTimeObservations: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = ExecutionTimeObservations + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> ExecutionTimeObservations { + return ExecutionTimeObservations(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: ExecutionTimeObservations) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ExecutionTimeObservations { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: ExecutionTimeObservations, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeExecutionTimeObservations_lift(_ pointer: UnsafeMutableRawPointer) throws -> ExecutionTimeObservations { + return try FfiConverterTypeExecutionTimeObservations.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeExecutionTimeObservations_lower(_ value: ExecutionTimeObservations) -> UnsafeMutableRawPointer { + return FfiConverterTypeExecutionTimeObservations.lower(value) +} + + + + + + +public protocol FaucetClientProtocol: AnyObject, Sendable { + + /** + * 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. + */ + func request(address: Address) async throws -> String? + + /** + * 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. + */ + func requestAndWait(address: Address) async throws -> FaucetReceipt? + + /** + * Check the faucet request status. + * + * Possible statuses are defined in: [`BatchSendStatusType`] + */ + func requestStatus(id: String) async throws -> BatchSendStatus? + +} +open class FaucetClient: FaucetClientProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_faucetclient(self.pointer, $0) } + } + /** + * 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/taks-uuid is used to check the status of the request + */ +public convenience init(faucetUrl: String) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_faucetclient_new( + FfiConverterString.lower(faucetUrl),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_faucetclient(pointer, $0) } + } + + + /** + * Set to devnet faucet. + */ +public static func devnet() -> FaucetClient { + return try! FfiConverterTypeFaucetClient_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_faucetclient_devnet($0 + ) +}) +} + + /** + * Set to local faucet. + */ +public static func local() -> FaucetClient { + return try! FfiConverterTypeFaucetClient_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_faucetclient_local($0 + ) +}) +} + + /** + * Set to testnet faucet. + */ +public static func testnet() -> FaucetClient { + return try! FfiConverterTypeFaucetClient_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_faucetclient_testnet($0 + ) +}) +} + + + + /** + * 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. + */ +open func request(address: Address)async throws -> String? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_faucetclient_request( + self.uniffiClonePointer(), + FfiConverterTypeAddress_lower(address) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionString.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * 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. + */ +open func requestAndWait(address: Address)async throws -> FaucetReceipt? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_faucetclient_request_and_wait( + self.uniffiClonePointer(), + FfiConverterTypeAddress_lower(address) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionTypeFaucetReceipt.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * Check the faucet request status. + * + * Possible statuses are defined in: [`BatchSendStatusType`] + */ +open func requestStatus(id: String)async throws -> BatchSendStatus? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_faucetclient_request_status( + self.uniffiClonePointer(), + FfiConverterString.lower(id) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionTypeBatchSendStatus.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeFaucetClient: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = FaucetClient + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> FaucetClient { + return FaucetClient(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: FaucetClient) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FaucetClient { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: FaucetClient, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeFaucetClient_lift(_ pointer: UnsafeMutableRawPointer) throws -> FaucetClient { + return try FfiConverterTypeFaucetClient.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeFaucetClient_lower(_ value: FaucetClient) -> UnsafeMutableRawPointer { + return FfiConverterTypeFaucetClient.lower(value) +} + + + + + + +public protocol FaucetReceiptProtocol: AnyObject, Sendable { + +} +open class FaucetReceipt: FaucetReceiptProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_faucetreceipt(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_faucetreceipt(pointer, $0) } + } + + + + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeFaucetReceipt: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = FaucetReceipt + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> FaucetReceipt { + return FaucetReceipt(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: FaucetReceipt) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FaucetReceipt { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: FaucetReceipt, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeFaucetReceipt_lift(_ pointer: UnsafeMutableRawPointer) throws -> FaucetReceipt { + return try FfiConverterTypeFaucetReceipt.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeFaucetReceipt_lower(_ value: FaucetReceipt) -> UnsafeMutableRawPointer { + return FfiConverterTypeFaucetReceipt.lower(value) +} + + + + + + +/** + * 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 + * ``` + */ +public protocol GenesisObjectProtocol: AnyObject, Sendable { + + func data() -> ObjectData + + func objectId() -> ObjectId + + func objectType() -> ObjectType + + func owner() -> Owner + + func version() -> UInt64 + +} +/** + * 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 + * ``` + */ +open class GenesisObject: GenesisObjectProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_genesisobject(self.pointer, $0) } + } +public convenience init(data: ObjectData, owner: Owner) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_genesisobject_new( + FfiConverterTypeObjectData_lower(data), + FfiConverterTypeOwner_lower(owner),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_genesisobject(pointer, $0) } + } + + + + +open func data() -> ObjectData { + return try! FfiConverterTypeObjectData_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_genesisobject_data(self.uniffiClonePointer(),$0 + ) +}) +} + +open func objectId() -> ObjectId { + return try! FfiConverterTypeObjectId_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_genesisobject_object_id(self.uniffiClonePointer(),$0 + ) +}) +} + +open func objectType() -> ObjectType { + return try! FfiConverterTypeObjectType_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_genesisobject_object_type(self.uniffiClonePointer(),$0 + ) +}) +} + +open func owner() -> Owner { + return try! FfiConverterTypeOwner_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_genesisobject_owner(self.uniffiClonePointer(),$0 + ) +}) +} + +open func version() -> UInt64 { + return try! FfiConverterUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_genesisobject_version(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeGenesisObject: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = GenesisObject + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> GenesisObject { + return GenesisObject(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: GenesisObject) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> GenesisObject { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: GenesisObject, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeGenesisObject_lift(_ pointer: UnsafeMutableRawPointer) throws -> GenesisObject { + return try FfiConverterTypeGenesisObject.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeGenesisObject_lower(_ value: GenesisObject) -> UnsafeMutableRawPointer { + return FfiConverterTypeGenesisObject.lower(value) +} + + + + + + +/** + * The genesis transaction + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * genesis-transaction = (vector genesis-object) + * ``` + */ +public protocol GenesisTransactionProtocol: AnyObject, Sendable { + + func events() -> [Event] + + func objects() -> [GenesisObject] + +} +/** + * The genesis transaction + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * genesis-transaction = (vector genesis-object) + * ``` + */ +open class GenesisTransaction: GenesisTransactionProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_genesistransaction(self.pointer, $0) } + } +public convenience init(objects: [GenesisObject], events: [Event]) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_genesistransaction_new( + FfiConverterSequenceTypeGenesisObject.lower(objects), + FfiConverterSequenceTypeEvent.lower(events),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_genesistransaction(pointer, $0) } + } + + + + +open func events() -> [Event] { + return try! FfiConverterSequenceTypeEvent.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_genesistransaction_events(self.uniffiClonePointer(),$0 + ) +}) +} + +open func objects() -> [GenesisObject] { + return try! FfiConverterSequenceTypeGenesisObject.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_genesistransaction_objects(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeGenesisTransaction: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = GenesisTransaction + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> GenesisTransaction { + return GenesisTransaction(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: GenesisTransaction) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> GenesisTransaction { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: GenesisTransaction, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeGenesisTransaction_lift(_ pointer: UnsafeMutableRawPointer) throws -> GenesisTransaction { + return try FfiConverterTypeGenesisTransaction.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeGenesisTransaction_lower(_ value: GenesisTransaction) -> UnsafeMutableRawPointer { + return FfiConverterTypeGenesisTransaction.lower(value) +} + + + + + + +public protocol GraphQlClientProtocol: AnyObject, Sendable { + + /** + * 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. + */ + func activeValidators(paginationFilter: PaginationFilter, epoch: UInt64?) async throws -> ValidatorPage + + /** + * 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. + */ + func balance(address: Address, coinType: String?) async throws -> UInt64? + + /** + * Get the chain identifier. + */ + func chainId() async throws -> String + + /** + * Get the [`CheckpointSummary`] for a given checkpoint digest or + * checkpoint id. If none is provided, it will use the last known + * checkpoint id. + */ + func checkpoint(digest: CheckpointContentsDigest?, seqNum: UInt64?) async throws -> CheckpointSummary? + + /** + * Get a page of [`CheckpointSummary`] for the provided parameters. + */ + func checkpoints(paginationFilter: PaginationFilter) async throws -> CheckpointSummaryPage + + /** + * Get the coin metadata for the coin type. + */ + func coinMetadata(coinType: String) async throws -> CoinMetadata? + + /** + * Get the list of coins for the specified address. + * + * If `coin_type` is not provided, it will default to `0x2::coin::Coin`, + * which will return all coins. For IOTA coin, pass in the coin type: + * `0x2::coin::Coin<0x2::iota::IOTA>`. + */ + func coins(owner: Address, paginationFilter: PaginationFilter, coinType: String?) async throws -> CoinPage + + /** + * 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. + */ + func dryRunTx(tx: Transaction, skipChecks: Bool?) async throws -> DryRunResult + + /** + * 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. + */ + func dryRunTxKind(txKind: TransactionKind, txMeta: TransactionMetadata, skipChecks: Bool?) async throws -> DryRunResult + + /** + * 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. + * + * # Example + * ```rust,ignore + * + * let client = iota_graphql_client::Client::new_devnet(); + * let address = Address::from_str("0x5").unwrap(); + * let df = client.dynamic_field_with_name(address, "u64", 2u64).await.unwrap(); + * + * # alternatively, pass in the bcs bytes + * let bcs = base64ct::Base64::decode_vec("AgAAAAAAAAA=").unwrap(); + * let df = client.dynamic_field(address, "u64", BcsName(bcs)).await.unwrap(); + * ``` + */ + func dynamicField(address: Address, typeTag: TypeTag, name: Value) async throws -> DynamicFieldOutput? + + /** + * Get a page of dynamic fields for the provided address. Note that this + * will also fetch dynamic fields on wrapped objects. + * + * This returns [`Page`] of [`DynamicFieldOutput`]s. + */ + func dynamicFields(address: Address, paginationFilter: PaginationFilter) async throws -> DynamicFieldOutputPage + + /** + * 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. + */ + func dynamicObjectField(address: Address, typeTag: TypeTag, name: Value) async throws -> DynamicFieldOutput? + + /** + * Return the epoch information for the provided epoch. If no epoch is + * provided, it will return the last known epoch. + */ + func epoch(epoch: UInt64?) async throws -> Epoch? + + /** + * 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). + */ + func epochTotalCheckpoints(epoch: UInt64?) async throws -> UInt64? + + /** + * 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). + */ + func epochTotalTransactionBlocks(epoch: UInt64?) async throws -> UInt64? + + /** + * Return a page of tuple (event, transaction digest) based on the + * (optional) event filter. + */ + func events(paginationFilter: PaginationFilter, filter: EventFilter?) async throws -> EventPage + + /** + * Execute a transaction. + */ + func executeTx(signatures: [UserSignature], tx: Transaction) async throws -> TransactionEffects? + + /** + * Return the sequence number of the latest checkpoint that has been + * executed. + */ + func latestCheckpointSequenceNumber() async throws -> UInt64? + + /** + * Lazily fetch the max page size + */ + func maxPageSize() async throws -> Int32 + + /** + * 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)`. + */ + func moveObjectContents(objectId: ObjectId, version: UInt64?) async throws -> Value? + + /** + * 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)`. + */ + func moveObjectContentsBcs(objectId: ObjectId, version: UInt64?) async throws -> Data? + + /** + * Return the normalized Move function data for the provided package, + * module, and function. + */ + func normalizedMoveFunction(package: String, module: String, function: String, version: UInt64?) async throws -> MoveFunction? + + /** + * Return the normalized Move module data for the provided module. + */ + func normalizedMoveModule(package: String, module: String, paginationFilterEnums: PaginationFilter, paginationFilterFriends: PaginationFilter, paginationFilterFunctions: PaginationFilter, paginationFilterStructs: PaginationFilter, version: UInt64?) async throws -> MoveModule? + + /** + * 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)`. + */ + func object(objectId: ObjectId, version: UInt64?) async throws -> Object? + + /** + * Return the object's bcs content [`Vec`] based on the provided + * [`Address`]. + */ + func objectBcs(objectId: ObjectId) async throws -> Data? + + /** + * 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. + * + * # Example + * + * ```rust,ignore + * let filter = ObjectFilter { + * type_tag: None, + * owner: Some(Address::from_str("test").unwrap().into()), + * object_ids: None, + * }; + * + * let owned_objects = client.objects(None, None, Some(filter), None, None).await; + * ``` + */ + func objects(paginationFilter: PaginationFilter, filter: ObjectFilter?) async throws -> ObjectPage + + /** + * 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). + */ + func package(address: Address, version: UInt64?) async throws -> MovePackage? + + /** + * 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. + */ + func packageLatest(address: Address) async throws -> MovePackage? + + /** + * 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. + */ + func packageVersions(address: Address, paginationFilter: PaginationFilter, afterVersion: UInt64?, beforeVersion: UInt64?) async throws -> MovePackagePage + + /** + * 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. + */ + func packages(paginationFilter: PaginationFilter, afterCheckpoint: UInt64?, beforeCheckpoint: UInt64?) async throws -> MovePackagePage + + /** + * Get the protocol configuration. + */ + func protocolConfig(version: UInt64?) async throws -> ProtocolConfigs? + + /** + * 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). + */ + func referenceGasPrice(epoch: UInt64?) async throws -> UInt64? + + /** + * Get the GraphQL service configuration, including complexity limits, read + * and mutation limits, supported versions, and others. + */ + func serviceConfig() async throws -> ServiceConfig + + /** + * Set the server address for the GraphQL GraphQL client. It should be a + * valid URL with a host and optionally a port number. + */ + func setRpcServer(server: String) async throws + + /** + * Get total supply for the coin type. + */ + func totalSupply(coinType: String) async throws -> UInt64? + + /** + * The total number of transaction blocks in the network by the end of the + * last known checkpoint. + */ + func totalTransactionBlocks() async throws -> UInt64? + + /** + * The total number of transaction blocks in the network by the end of the + * provided checkpoint digest. + */ + func totalTransactionBlocksByDigest(digest: CheckpointContentsDigest) async throws -> UInt64? + + /** + * The total number of transaction blocks in the network by the end of the + * provided checkpoint sequence number. + */ + func totalTransactionBlocksBySeqNum(seqNum: UInt64) async throws -> UInt64? + + /** + * Get a transaction by its digest. + */ + func transaction(digest: TransactionDigest) async throws -> SignedTransaction? + + /** + * Get a transaction's data and effects by its digest. + */ + func transactionDataEffects(digest: TransactionDigest) async throws -> TransactionDataEffects? + + /** + * Get a transaction's effects by its digest. + */ + func transactionEffects(digest: TransactionDigest) async throws -> TransactionEffects? + + /** + * Get a page of transactions based on the provided filters. + */ + func transactions(paginationFilter: PaginationFilter, filter: TransactionsFilter?) async throws -> SignedTransactionPage + + /** + * Get a page of transactions' data and effects based on the provided + * filters. + */ + func transactionsDataEffects(paginationFilter: PaginationFilter, filter: TransactionsFilter?) async throws -> TransactionDataEffectsPage + + /** + * Get a page of transactions' effects based on the provided filters. + */ + func transactionsEffects(paginationFilter: PaginationFilter, filter: TransactionsFilter?) async throws -> TransactionEffectsPage + +} +open class GraphQlClient: GraphQlClientProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_graphqlclient(self.pointer, $0) } + } + /** + * Create a new GraphQL client with the provided server address. + */ +public convenience init(server: String)throws { + let pointer = + try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_graphqlclient_new( + FfiConverterString.lower(server),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_graphqlclient(pointer, $0) } + } + + + /** + * Create a new GraphQL client connected to the `devnet` GraphQL server: + * {DEVNET_HOST}. + */ +public static func newDevnet() -> GraphQlClient { + return try! FfiConverterTypeGraphQLClient_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_graphqlclient_new_devnet($0 + ) +}) +} + + /** + * Create a new GraphQL client connected to the `localhost` GraphQL server: + * {DEFAULT_LOCAL_HOST}. + */ +public static func newLocalhost() -> GraphQlClient { + return try! FfiConverterTypeGraphQLClient_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_graphqlclient_new_localhost($0 + ) +}) +} + + /** + * Create a new GraphQL client connected to the `mainnet` GraphQL server: + * {MAINNET_HOST}. + */ +public static func newMainnet() -> GraphQlClient { + return try! FfiConverterTypeGraphQLClient_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_graphqlclient_new_mainnet($0 + ) +}) +} + + /** + * Create a new GraphQL client connected to the `testnet` GraphQL server: + * {TESTNET_HOST}. + */ +public static func newTestnet() -> GraphQlClient { + return try! FfiConverterTypeGraphQLClient_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_graphqlclient_new_testnet($0 + ) +}) +} + + + + /** + * 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. + */ +open func activeValidators(paginationFilter: PaginationFilter, epoch: UInt64? = nil)async throws -> ValidatorPage { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_active_validators( + self.uniffiClonePointer(), + FfiConverterTypePaginationFilter_lower(paginationFilter),FfiConverterOptionUInt64.lower(epoch) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterTypeValidatorPage_lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * 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. + */ +open func balance(address: Address, coinType: String? = nil)async throws -> UInt64? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_balance( + self.uniffiClonePointer(), + FfiConverterTypeAddress_lower(address),FfiConverterOptionString.lower(coinType) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionUInt64.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * Get the chain identifier. + */ +open func chainId()async throws -> String { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_chain_id( + self.uniffiClonePointer() + + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterString.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * Get the [`CheckpointSummary`] for a given checkpoint digest or + * checkpoint id. If none is provided, it will use the last known + * checkpoint id. + */ +open func checkpoint(digest: CheckpointContentsDigest? = nil, seqNum: UInt64? = nil)async throws -> CheckpointSummary? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_checkpoint( + self.uniffiClonePointer(), + FfiConverterOptionTypeCheckpointContentsDigest.lower(digest),FfiConverterOptionUInt64.lower(seqNum) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionTypeCheckpointSummary.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * Get a page of [`CheckpointSummary`] for the provided parameters. + */ +open func checkpoints(paginationFilter: PaginationFilter)async throws -> CheckpointSummaryPage { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_checkpoints( + self.uniffiClonePointer(), + FfiConverterTypePaginationFilter_lower(paginationFilter) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterTypeCheckpointSummaryPage_lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * Get the coin metadata for the coin type. + */ +open func coinMetadata(coinType: String)async throws -> CoinMetadata? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_coin_metadata( + self.uniffiClonePointer(), + FfiConverterString.lower(coinType) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionTypeCoinMetadata.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * Get the list of coins for the specified address. + * + * If `coin_type` is not provided, it will default to `0x2::coin::Coin`, + * which will return all coins. For IOTA coin, pass in the coin type: + * `0x2::coin::Coin<0x2::iota::IOTA>`. + */ +open func coins(owner: Address, paginationFilter: PaginationFilter, coinType: String? = nil)async throws -> CoinPage { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_coins( + self.uniffiClonePointer(), + FfiConverterTypeAddress_lower(owner),FfiConverterTypePaginationFilter_lower(paginationFilter),FfiConverterOptionString.lower(coinType) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterTypeCoinPage_lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * 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. + */ +open func dryRunTx(tx: Transaction, skipChecks: Bool? = nil)async throws -> DryRunResult { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_dry_run_tx( + self.uniffiClonePointer(), + FfiConverterTypeTransaction_lower(tx),FfiConverterOptionBool.lower(skipChecks) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterTypeDryRunResult_lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * 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. + */ +open func dryRunTxKind(txKind: TransactionKind, txMeta: TransactionMetadata, skipChecks: Bool? = nil)async throws -> DryRunResult { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_dry_run_tx_kind( + self.uniffiClonePointer(), + FfiConverterTypeTransactionKind_lower(txKind),FfiConverterTypeTransactionMetadata_lower(txMeta),FfiConverterOptionBool.lower(skipChecks) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterTypeDryRunResult_lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * 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. + * + * # Example + * ```rust,ignore + * + * let client = iota_graphql_client::Client::new_devnet(); + * let address = Address::from_str("0x5").unwrap(); + * let df = client.dynamic_field_with_name(address, "u64", 2u64).await.unwrap(); + * + * # alternatively, pass in the bcs bytes + * let bcs = base64ct::Base64::decode_vec("AgAAAAAAAAA=").unwrap(); + * let df = client.dynamic_field(address, "u64", BcsName(bcs)).await.unwrap(); + * ``` + */ +open func dynamicField(address: Address, typeTag: TypeTag, name: Value)async throws -> DynamicFieldOutput? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_dynamic_field( + self.uniffiClonePointer(), + FfiConverterTypeAddress_lower(address),FfiConverterTypeTypeTag_lower(typeTag),FfiConverterTypeValue_lower(name) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionTypeDynamicFieldOutput.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * Get a page of dynamic fields for the provided address. Note that this + * will also fetch dynamic fields on wrapped objects. + * + * This returns [`Page`] of [`DynamicFieldOutput`]s. + */ +open func dynamicFields(address: Address, paginationFilter: PaginationFilter)async throws -> DynamicFieldOutputPage { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_dynamic_fields( + self.uniffiClonePointer(), + FfiConverterTypeAddress_lower(address),FfiConverterTypePaginationFilter_lower(paginationFilter) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterTypeDynamicFieldOutputPage_lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * 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. + */ +open func dynamicObjectField(address: Address, typeTag: TypeTag, name: Value)async throws -> DynamicFieldOutput? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_dynamic_object_field( + self.uniffiClonePointer(), + FfiConverterTypeAddress_lower(address),FfiConverterTypeTypeTag_lower(typeTag),FfiConverterTypeValue_lower(name) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionTypeDynamicFieldOutput.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * Return the epoch information for the provided epoch. If no epoch is + * provided, it will return the last known epoch. + */ +open func epoch(epoch: UInt64? = nil)async throws -> Epoch? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_epoch( + self.uniffiClonePointer(), + FfiConverterOptionUInt64.lower(epoch) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionTypeEpoch.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * 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). + */ +open func epochTotalCheckpoints(epoch: UInt64? = nil)async throws -> UInt64? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_epoch_total_checkpoints( + self.uniffiClonePointer(), + FfiConverterOptionUInt64.lower(epoch) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionUInt64.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * 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). + */ +open func epochTotalTransactionBlocks(epoch: UInt64? = nil)async throws -> UInt64? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_epoch_total_transaction_blocks( + self.uniffiClonePointer(), + FfiConverterOptionUInt64.lower(epoch) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionUInt64.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * Return a page of tuple (event, transaction digest) based on the + * (optional) event filter. + */ +open func events(paginationFilter: PaginationFilter, filter: EventFilter? = nil)async throws -> EventPage { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_events( + self.uniffiClonePointer(), + FfiConverterTypePaginationFilter_lower(paginationFilter),FfiConverterOptionTypeEventFilter.lower(filter) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterTypeEventPage_lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * Execute a transaction. + */ +open func executeTx(signatures: [UserSignature], tx: Transaction)async throws -> TransactionEffects? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_execute_tx( + self.uniffiClonePointer(), + FfiConverterSequenceTypeUserSignature.lower(signatures),FfiConverterTypeTransaction_lower(tx) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionTypeTransactionEffects.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * Return the sequence number of the latest checkpoint that has been + * executed. + */ +open func latestCheckpointSequenceNumber()async throws -> UInt64? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_latest_checkpoint_sequence_number( + self.uniffiClonePointer() + + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionUInt64.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * Lazily fetch the max page size + */ +open func maxPageSize()async throws -> Int32 { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_max_page_size( + self.uniffiClonePointer() + + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_i32, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_i32, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_i32, + liftFunc: FfiConverterInt32.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * 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)`. + */ +open func moveObjectContents(objectId: ObjectId, version: UInt64? = nil)async throws -> Value? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_move_object_contents( + self.uniffiClonePointer(), + FfiConverterTypeObjectId_lower(objectId),FfiConverterOptionUInt64.lower(version) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionTypeValue.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * 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)`. + */ +open func moveObjectContentsBcs(objectId: ObjectId, version: UInt64? = nil)async throws -> Data? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_move_object_contents_bcs( + self.uniffiClonePointer(), + FfiConverterTypeObjectId_lower(objectId),FfiConverterOptionUInt64.lower(version) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionData.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * Return the normalized Move function data for the provided package, + * module, and function. + */ +open func normalizedMoveFunction(package: String, module: String, function: String, version: UInt64? = nil)async throws -> MoveFunction? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_normalized_move_function( + self.uniffiClonePointer(), + FfiConverterString.lower(package),FfiConverterString.lower(module),FfiConverterString.lower(function),FfiConverterOptionUInt64.lower(version) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionTypeMoveFunction.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * Return the normalized Move module data for the provided module. + */ +open func normalizedMoveModule(package: String, module: String, paginationFilterEnums: PaginationFilter, paginationFilterFriends: PaginationFilter, paginationFilterFunctions: PaginationFilter, paginationFilterStructs: PaginationFilter, version: UInt64? = nil)async throws -> MoveModule? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_normalized_move_module( + self.uniffiClonePointer(), + FfiConverterString.lower(package),FfiConverterString.lower(module),FfiConverterTypePaginationFilter_lower(paginationFilterEnums),FfiConverterTypePaginationFilter_lower(paginationFilterFriends),FfiConverterTypePaginationFilter_lower(paginationFilterFunctions),FfiConverterTypePaginationFilter_lower(paginationFilterStructs),FfiConverterOptionUInt64.lower(version) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionTypeMoveModule.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * 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)`. + */ +open func object(objectId: ObjectId, version: UInt64? = nil)async throws -> Object? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_object( + self.uniffiClonePointer(), + FfiConverterTypeObjectId_lower(objectId),FfiConverterOptionUInt64.lower(version) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionTypeObject.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * Return the object's bcs content [`Vec`] based on the provided + * [`Address`]. + */ +open func objectBcs(objectId: ObjectId)async throws -> Data? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_object_bcs( + self.uniffiClonePointer(), + FfiConverterTypeObjectId_lower(objectId) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionData.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * 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. + * + * # Example + * + * ```rust,ignore + * let filter = ObjectFilter { + * type_tag: None, + * owner: Some(Address::from_str("test").unwrap().into()), + * object_ids: None, + * }; + * + * let owned_objects = client.objects(None, None, Some(filter), None, None).await; + * ``` + */ +open func objects(paginationFilter: PaginationFilter, filter: ObjectFilter? = nil)async throws -> ObjectPage { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_objects( + self.uniffiClonePointer(), + FfiConverterTypePaginationFilter_lower(paginationFilter),FfiConverterOptionTypeObjectFilter.lower(filter) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterTypeObjectPage_lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * 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). + */ +open func package(address: Address, version: UInt64? = nil)async throws -> MovePackage? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_package( + self.uniffiClonePointer(), + FfiConverterTypeAddress_lower(address),FfiConverterOptionUInt64.lower(version) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionTypeMovePackage.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * 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. + */ +open func packageLatest(address: Address)async throws -> MovePackage? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_package_latest( + self.uniffiClonePointer(), + FfiConverterTypeAddress_lower(address) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionTypeMovePackage.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * 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. + */ +open func packageVersions(address: Address, paginationFilter: PaginationFilter, afterVersion: UInt64? = nil, beforeVersion: UInt64? = nil)async throws -> MovePackagePage { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_package_versions( + self.uniffiClonePointer(), + FfiConverterTypeAddress_lower(address),FfiConverterTypePaginationFilter_lower(paginationFilter),FfiConverterOptionUInt64.lower(afterVersion),FfiConverterOptionUInt64.lower(beforeVersion) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterTypeMovePackagePage_lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * 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. + */ +open func packages(paginationFilter: PaginationFilter, afterCheckpoint: UInt64? = nil, beforeCheckpoint: UInt64? = nil)async throws -> MovePackagePage { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_packages( + self.uniffiClonePointer(), + FfiConverterTypePaginationFilter_lower(paginationFilter),FfiConverterOptionUInt64.lower(afterCheckpoint),FfiConverterOptionUInt64.lower(beforeCheckpoint) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterTypeMovePackagePage_lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * Get the protocol configuration. + */ +open func protocolConfig(version: UInt64? = nil)async throws -> ProtocolConfigs? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_protocol_config( + self.uniffiClonePointer(), + FfiConverterOptionUInt64.lower(version) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionTypeProtocolConfigs.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * 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). + */ +open func referenceGasPrice(epoch: UInt64? = nil)async throws -> UInt64? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_reference_gas_price( + self.uniffiClonePointer(), + FfiConverterOptionUInt64.lower(epoch) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionUInt64.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * Get the GraphQL service configuration, including complexity limits, read + * and mutation limits, supported versions, and others. + */ +open func serviceConfig()async throws -> ServiceConfig { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_service_config( + self.uniffiClonePointer() + + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterTypeServiceConfig_lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * Set the server address for the GraphQL GraphQL client. It should be a + * valid URL with a host and optionally a port number. + */ +open func setRpcServer(server: String)async throws { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_set_rpc_server( + self.uniffiClonePointer(), + FfiConverterString.lower(server) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_void, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_void, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_void, + liftFunc: { $0 }, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * Get total supply for the coin type. + */ +open func totalSupply(coinType: String)async throws -> UInt64? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_total_supply( + self.uniffiClonePointer(), + FfiConverterString.lower(coinType) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionUInt64.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * The total number of transaction blocks in the network by the end of the + * last known checkpoint. + */ +open func totalTransactionBlocks()async throws -> UInt64? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_total_transaction_blocks( + self.uniffiClonePointer() + + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionUInt64.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * The total number of transaction blocks in the network by the end of the + * provided checkpoint digest. + */ +open func totalTransactionBlocksByDigest(digest: CheckpointContentsDigest)async throws -> UInt64? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_total_transaction_blocks_by_digest( + self.uniffiClonePointer(), + FfiConverterTypeCheckpointContentsDigest_lower(digest) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionUInt64.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * The total number of transaction blocks in the network by the end of the + * provided checkpoint sequence number. + */ +open func totalTransactionBlocksBySeqNum(seqNum: UInt64)async throws -> UInt64? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_total_transaction_blocks_by_seq_num( + self.uniffiClonePointer(), + FfiConverterUInt64.lower(seqNum) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionUInt64.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * Get a transaction by its digest. + */ +open func transaction(digest: TransactionDigest)async throws -> SignedTransaction? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_transaction( + self.uniffiClonePointer(), + FfiConverterTypeTransactionDigest_lower(digest) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionTypeSignedTransaction.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * Get a transaction's data and effects by its digest. + */ +open func transactionDataEffects(digest: TransactionDigest)async throws -> TransactionDataEffects? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_transaction_data_effects( + self.uniffiClonePointer(), + FfiConverterTypeTransactionDigest_lower(digest) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionTypeTransactionDataEffects.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * Get a transaction's effects by its digest. + */ +open func transactionEffects(digest: TransactionDigest)async throws -> TransactionEffects? { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_transaction_effects( + self.uniffiClonePointer(), + FfiConverterTypeTransactionDigest_lower(digest) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterOptionTypeTransactionEffects.lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * Get a page of transactions based on the provided filters. + */ +open func transactions(paginationFilter: PaginationFilter, filter: TransactionsFilter? = nil)async throws -> SignedTransactionPage { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_transactions( + self.uniffiClonePointer(), + FfiConverterTypePaginationFilter_lower(paginationFilter),FfiConverterOptionTypeTransactionsFilter.lower(filter) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterTypeSignedTransactionPage_lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * Get a page of transactions' data and effects based on the provided + * filters. + */ +open func transactionsDataEffects(paginationFilter: PaginationFilter, filter: TransactionsFilter? = nil)async throws -> TransactionDataEffectsPage { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_transactions_data_effects( + self.uniffiClonePointer(), + FfiConverterTypePaginationFilter_lower(paginationFilter),FfiConverterOptionTypeTransactionsFilter.lower(filter) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterTypeTransactionDataEffectsPage_lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + /** + * Get a page of transactions' effects based on the provided filters. + */ +open func transactionsEffects(paginationFilter: PaginationFilter, filter: TransactionsFilter? = nil)async throws -> TransactionEffectsPage { + return + try await uniffiRustCallAsync( + rustFutureFunc: { + uniffi_iota_sdk_ffi_fn_method_graphqlclient_transactions_effects( + self.uniffiClonePointer(), + FfiConverterTypePaginationFilter_lower(paginationFilter),FfiConverterOptionTypeTransactionsFilter.lower(filter) + ) + }, + pollFunc: ffi_iota_sdk_ffi_rust_future_poll_rust_buffer, + completeFunc: ffi_iota_sdk_ffi_rust_future_complete_rust_buffer, + freeFunc: ffi_iota_sdk_ffi_rust_future_free_rust_buffer, + liftFunc: FfiConverterTypeTransactionEffectsPage_lift, + errorHandler: FfiConverterTypeSdkFfiError_lift + ) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeGraphQLClient: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = GraphQlClient + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> GraphQlClient { + return GraphQlClient(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: GraphQlClient) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> GraphQlClient { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: GraphQlClient, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeGraphQLClient_lift(_ pointer: UnsafeMutableRawPointer) throws -> GraphQlClient { + return try FfiConverterTypeGraphQLClient.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeGraphQLClient_lower(_ value: GraphQlClient) -> UnsafeMutableRawPointer { + return FfiConverterTypeGraphQLClient.lower(value) +} + + + + + + +/** + * 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 + * ``` + */ +public protocol IdentifierProtocol: AnyObject, Sendable { + + func 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 + * ``` + */ +open class Identifier: IdentifierProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_identifier(self.pointer, $0) } + } +public convenience init(identifier: String)throws { + let pointer = + try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_identifier_new( + FfiConverterString.lower(identifier),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_identifier(pointer, $0) } + } + + + + +open func asStr() -> String { + return try! FfiConverterString.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_identifier_as_str(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeIdentifier: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = Identifier + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Identifier { + return Identifier(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: Identifier) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Identifier { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: Identifier, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeIdentifier_lift(_ pointer: UnsafeMutableRawPointer) throws -> Identifier { + return try FfiConverterTypeIdentifier.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeIdentifier_lower(_ value: Identifier) -> UnsafeMutableRawPointer { + return FfiConverterTypeIdentifier.lower(value) +} + + + + + + +/** + * 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 + * ``` + */ +public protocol InputProtocol: AnyObject, Sendable { + +} +/** + * 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 + * ``` + */ +open class Input: InputProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_input(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_input(pointer, $0) } + } + + + /** + * A move object that is either immutable or address owned + */ +public static func newImmutableOrOwned(objectRef: ObjectReference) -> Input { + return try! FfiConverterTypeInput_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_input_new_immutable_or_owned( + FfiConverterTypeObjectReference_lower(objectRef),$0 + ) +}) +} + + /** + * For normal operations this is required to be a move primitive type and + * not contain structs or objects. + */ +public static func newPure(value: Data) -> Input { + return try! FfiConverterTypeInput_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_input_new_pure( + FfiConverterData.lower(value),$0 + ) +}) +} + +public static func newReceiving(objectRef: ObjectReference) -> Input { + return try! FfiConverterTypeInput_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_input_new_receiving( + FfiConverterTypeObjectReference_lower(objectRef),$0 + ) +}) +} + + /** + * A move object whose owner is "Shared" + */ +public static func newShared(objectId: ObjectId, initialSharedVersion: UInt64, mutable: Bool) -> Input { + return try! FfiConverterTypeInput_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_input_new_shared( + FfiConverterTypeObjectId_lower(objectId), + FfiConverterUInt64.lower(initialSharedVersion), + FfiConverterBool.lower(mutable),$0 + ) +}) +} + + + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeInput: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = Input + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Input { + return Input(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: Input) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Input { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: Input, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeInput_lift(_ pointer: UnsafeMutableRawPointer) throws -> Input { + return try FfiConverterTypeInput.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeInput_lower(_ value: Input) -> UnsafeMutableRawPointer { + return FfiConverterTypeInput.lower(value) +} + + + + + + +/** + * 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) + * ``` + */ +public protocol MakeMoveVectorProtocol: AnyObject, Sendable { + + /** + * The set individual elements to build the vector with + */ + func elements() -> [Argument] + + /** + * 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. + */ + func typeTag() -> TypeTag? + +} +/** + * 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) + * ``` + */ +open class MakeMoveVector: MakeMoveVectorProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_makemovevector(self.pointer, $0) } + } +public convenience init(typeTag: TypeTag?, elements: [Argument]) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_makemovevector_new( + FfiConverterOptionTypeTypeTag.lower(typeTag), + FfiConverterSequenceTypeArgument.lower(elements),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_makemovevector(pointer, $0) } + } + + + + + /** + * The set individual elements to build the vector with + */ +open func elements() -> [Argument] { + return try! FfiConverterSequenceTypeArgument.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_makemovevector_elements(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * 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. + */ +open func typeTag() -> TypeTag? { + return try! FfiConverterOptionTypeTypeTag.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_makemovevector_type_tag(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMakeMoveVector: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = MakeMoveVector + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> MakeMoveVector { + return MakeMoveVector(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: MakeMoveVector) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MakeMoveVector { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: MakeMoveVector, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMakeMoveVector_lift(_ pointer: UnsafeMutableRawPointer) throws -> MakeMoveVector { + return try FfiConverterTypeMakeMoveVector.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMakeMoveVector_lower(_ value: MakeMoveVector) -> UnsafeMutableRawPointer { + return FfiConverterTypeMakeMoveVector.lower(value) +} + + + + + + +/** + * 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) + * ``` + */ +public protocol MergeCoinsProtocol: AnyObject, Sendable { + + /** + * Coin to merge coins into + */ + func 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` + */ + func coinsToMerge() -> [Argument] + +} +/** + * 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) + * ``` + */ +open class MergeCoins: MergeCoinsProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_mergecoins(self.pointer, $0) } + } +public convenience init(coin: Argument, coinsToMerge: [Argument]) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_mergecoins_new( + FfiConverterTypeArgument_lower(coin), + FfiConverterSequenceTypeArgument.lower(coinsToMerge),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_mergecoins(pointer, $0) } + } + + + + + /** + * Coin to merge coins into + */ +open func coin() -> Argument { + return try! FfiConverterTypeArgument_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_mergecoins_coin(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Set of coins to merge into `coin` + * + * All listed coins must be of the same type and be the same type as `coin` + */ +open func coinsToMerge() -> [Argument] { + return try! FfiConverterSequenceTypeArgument.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_mergecoins_coins_to_merge(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMergeCoins: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = MergeCoins + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> MergeCoins { + return MergeCoins(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: MergeCoins) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MergeCoins { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: MergeCoins, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMergeCoins_lift(_ pointer: UnsafeMutableRawPointer) throws -> MergeCoins { + return try FfiConverterTypeMergeCoins.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMergeCoins_lower(_ value: MergeCoins) -> UnsafeMutableRawPointer { + return FfiConverterTypeMergeCoins.lower(value) +} + + + + + + +/** + * 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 + * ``` + */ +public protocol MoveCallProtocol: AnyObject, Sendable { + + /** + * The arguments to the function. + */ + func arguments() -> [Argument] + + /** + * The function to be called. + */ + func function() -> Identifier + + /** + * The specific module in the package containing the function. + */ + func module() -> Identifier + + /** + * The package containing the module and function. + */ + func package() -> ObjectId + + /** + * The type arguments to the function. + */ + func typeArguments() -> [TypeTag] + +} +/** + * 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 + * ``` + */ +open class MoveCall: MoveCallProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_movecall(self.pointer, $0) } + } +public convenience init(package: ObjectId, module: Identifier, function: Identifier, typeArguments: [TypeTag], arguments: [Argument]) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_movecall_new( + FfiConverterTypeObjectId_lower(package), + FfiConverterTypeIdentifier_lower(module), + FfiConverterTypeIdentifier_lower(function), + FfiConverterSequenceTypeTypeTag.lower(typeArguments), + FfiConverterSequenceTypeArgument.lower(arguments),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_movecall(pointer, $0) } + } + + + + + /** + * The arguments to the function. + */ +open func arguments() -> [Argument] { + return try! FfiConverterSequenceTypeArgument.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_movecall_arguments(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * The function to be called. + */ +open func function() -> Identifier { + return try! FfiConverterTypeIdentifier_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_movecall_function(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * The specific module in the package containing the function. + */ +open func module() -> Identifier { + return try! FfiConverterTypeIdentifier_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_movecall_module(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * The package containing the module and function. + */ +open func package() -> ObjectId { + return try! FfiConverterTypeObjectId_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_movecall_package(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * The type arguments to the function. + */ +open func typeArguments() -> [TypeTag] { + return try! FfiConverterSequenceTypeTypeTag.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_movecall_type_arguments(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMoveCall: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = MoveCall + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> MoveCall { + return MoveCall(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: MoveCall) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MoveCall { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: MoveCall, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveCall_lift(_ pointer: UnsafeMutableRawPointer) throws -> MoveCall { + return try FfiConverterTypeMoveCall.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveCall_lower(_ value: MoveCall) -> UnsafeMutableRawPointer { + return FfiConverterTypeMoveCall.lower(value) +} + + + + + + +/** + * 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) + * ``` + */ +public protocol MovePackageProtocol: AnyObject, Sendable { + +} +/** + * 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) + * ``` + */ +open class MovePackage: MovePackageProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_movepackage(self.pointer, $0) } + } +public convenience init(id: ObjectId, version: UInt64, modules: [Identifier: Data], typeOriginTable: [TypeOrigin], linkageTable: [ObjectId: UpgradeInfo])throws { + let pointer = + try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_movepackage_new( + FfiConverterTypeObjectId_lower(id), + FfiConverterUInt64.lower(version), + FfiConverterDictionaryTypeIdentifierData.lower(modules), + FfiConverterSequenceTypeTypeOrigin.lower(typeOriginTable), + FfiConverterDictionaryTypeObjectIdTypeUpgradeInfo.lower(linkageTable),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_movepackage(pointer, $0) } + } + + + + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMovePackage: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = MovePackage + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> MovePackage { + return MovePackage(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: MovePackage) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MovePackage { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: MovePackage, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMovePackage_lift(_ pointer: UnsafeMutableRawPointer) throws -> MovePackage { + return try FfiConverterTypeMovePackage.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMovePackage_lower(_ value: MovePackage) -> UnsafeMutableRawPointer { + return FfiConverterTypeMovePackage.lower(value) +} + + + + + + +/** + * 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 [here](https://github.com/RoaringBitmap/RoaringFormatSpec) for the specification for the + * serialized format of RoaringBitmaps. + */ +public protocol MultisigAggregatedSignatureProtocol: AnyObject, Sendable { + + /** + * The bitmap that indicates which committee members provided their + * signature. + */ + func bitmap() -> UInt16 + + func committee() -> MultisigCommittee + + /** + * The list of signatures from committee members + */ + func signatures() -> [MultisigMemberSignature] + +} +/** + * 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 [here](https://github.com/RoaringBitmap/RoaringFormatSpec) for the specification for the + * serialized format of RoaringBitmaps. + */ +open class MultisigAggregatedSignature: MultisigAggregatedSignatureProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_multisigaggregatedsignature(self.pointer, $0) } + } + /** + * 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. + */ +public convenience init(committee: MultisigCommittee, signatures: [MultisigMemberSignature], bitmap: UInt16) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_multisigaggregatedsignature_new( + FfiConverterTypeMultisigCommittee_lower(committee), + FfiConverterSequenceTypeMultisigMemberSignature.lower(signatures), + FfiConverterUInt16.lower(bitmap),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_multisigaggregatedsignature(pointer, $0) } + } + + + + + /** + * The bitmap that indicates which committee members provided their + * signature. + */ +open func bitmap() -> UInt16 { + return try! FfiConverterUInt16.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigaggregatedsignature_bitmap(self.uniffiClonePointer(),$0 + ) +}) +} + +open func committee() -> MultisigCommittee { + return try! FfiConverterTypeMultisigCommittee_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigaggregatedsignature_committee(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * The list of signatures from committee members + */ +open func signatures() -> [MultisigMemberSignature] { + return try! FfiConverterSequenceTypeMultisigMemberSignature.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigaggregatedsignature_signatures(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMultisigAggregatedSignature: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = MultisigAggregatedSignature + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> MultisigAggregatedSignature { + return MultisigAggregatedSignature(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: MultisigAggregatedSignature) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MultisigAggregatedSignature { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: MultisigAggregatedSignature, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigAggregatedSignature_lift(_ pointer: UnsafeMutableRawPointer) throws -> MultisigAggregatedSignature { + return try FfiConverterTypeMultisigAggregatedSignature.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigAggregatedSignature_lower(_ value: MultisigAggregatedSignature) -> UnsafeMutableRawPointer { + return FfiConverterTypeMultisigAggregatedSignature.lower(value) +} + + + + + + +/** + * A multisig committee + * + * A `MultisigCommittee` is a set of members who collectively control a single + * `Address` on the IOTA blockchain. The number of required signautres 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 + * ``` + */ +public protocol MultisigCommitteeProtocol: AnyObject, Sendable { + + /** + * 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 + */ + func isValid() -> Bool + + /** + * The members of the committee + */ + func members() -> [MultisigMember] + + /** + * Return the flag for this signature scheme + */ + func scheme() -> SignatureScheme + + /** + * The total signature weight required to authorize a transaction for the + * address corresponding to this `MultisigCommittee`. + */ + func threshold() -> UInt16 + +} +/** + * A multisig committee + * + * A `MultisigCommittee` is a set of members who collectively control a single + * `Address` on the IOTA blockchain. The number of required signautres 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 + * ``` + */ +open class MultisigCommittee: MultisigCommitteeProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_multisigcommittee(self.pointer, $0) } + } + /** + * 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. + */ +public convenience init(members: [MultisigMember], threshold: UInt16) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_multisigcommittee_new( + FfiConverterSequenceTypeMultisigMember.lower(members), + FfiConverterUInt16.lower(threshold),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_multisigcommittee(pointer, $0) } + } + + + + + /** + * 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 + */ +open func isValid() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigcommittee_is_valid(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * The members of the committee + */ +open func members() -> [MultisigMember] { + return try! FfiConverterSequenceTypeMultisigMember.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigcommittee_members(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Return the flag for this signature scheme + */ +open func scheme() -> SignatureScheme { + return try! FfiConverterTypeSignatureScheme_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigcommittee_scheme(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * The total signature weight required to authorize a transaction for the + * address corresponding to this `MultisigCommittee`. + */ +open func threshold() -> UInt16 { + return try! FfiConverterUInt16.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigcommittee_threshold(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMultisigCommittee: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = MultisigCommittee + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> MultisigCommittee { + return MultisigCommittee(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: MultisigCommittee) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MultisigCommittee { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: MultisigCommittee, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigCommittee_lift(_ pointer: UnsafeMutableRawPointer) throws -> MultisigCommittee { + return try FfiConverterTypeMultisigCommittee.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigCommittee_lower(_ value: MultisigCommittee) -> UnsafeMutableRawPointer { + return FfiConverterTypeMultisigCommittee.lower(value) +} + + + + + + +/** + * 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 + * ``` + */ +public protocol MultisigMemberProtocol: AnyObject, Sendable { + + /** + * This member's public key. + */ + func publicKey() -> MultisigMemberPublicKey + + /** + * Weight of this member's signature. + */ + func weight() -> UInt8 + +} +/** + * 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 + * ``` + */ +open class MultisigMember: MultisigMemberProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_multisigmember(self.pointer, $0) } + } + /** + * Construct a new member from a `MultisigMemberPublicKey` and a `weight`. + */ +public convenience init(publicKey: MultisigMemberPublicKey, weight: UInt8) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_multisigmember_new( + FfiConverterTypeMultisigMemberPublicKey_lower(publicKey), + FfiConverterUInt8.lower(weight),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_multisigmember(pointer, $0) } + } + + + + + /** + * This member's public key. + */ +open func publicKey() -> MultisigMemberPublicKey { + return try! FfiConverterTypeMultisigMemberPublicKey_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigmember_public_key(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Weight of this member's signature. + */ +open func weight() -> UInt8 { + return try! FfiConverterUInt8.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigmember_weight(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMultisigMember: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = MultisigMember + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> MultisigMember { + return MultisigMember(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: MultisigMember) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MultisigMember { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: MultisigMember, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigMember_lift(_ pointer: UnsafeMutableRawPointer) throws -> MultisigMember { + return try FfiConverterTypeMultisigMember.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigMember_lower(_ value: MultisigMember) -> UnsafeMutableRawPointer { + return FfiConverterTypeMultisigMember.lower(value) +} + + + + + + +public protocol MultisigMemberPublicKeyProtocol: AnyObject, Sendable { + + func asEd25519() -> Ed25519PublicKey + + func asEd25519Opt() -> Ed25519PublicKey? + + func asSecp256k1() -> Secp256k1PublicKey + + func asSecp256k1Opt() -> Secp256k1PublicKey? + + func asSecp256r1() -> Secp256r1PublicKey + + func asSecp256r1Opt() -> Secp256r1PublicKey? + + func asZklogin() -> ZkLoginPublicIdentifier + + func asZkloginOpt() -> ZkLoginPublicIdentifier? + + func isEd25519() -> Bool + + func isSecp256k1() -> Bool + + func isSecp256r1() -> Bool + + func isZklogin() -> Bool + +} +open class MultisigMemberPublicKey: MultisigMemberPublicKeyProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_multisigmemberpublickey(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_multisigmemberpublickey(pointer, $0) } + } + + + + +open func asEd25519() -> Ed25519PublicKey { + return try! FfiConverterTypeEd25519PublicKey_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_ed25519(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asEd25519Opt() -> Ed25519PublicKey? { + return try! FfiConverterOptionTypeEd25519PublicKey.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_ed25519_opt(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asSecp256k1() -> Secp256k1PublicKey { + return try! FfiConverterTypeSecp256k1PublicKey_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_secp256k1(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asSecp256k1Opt() -> Secp256k1PublicKey? { + return try! FfiConverterOptionTypeSecp256k1PublicKey.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_secp256k1_opt(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asSecp256r1() -> Secp256r1PublicKey { + return try! FfiConverterTypeSecp256r1PublicKey_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_secp256r1(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asSecp256r1Opt() -> Secp256r1PublicKey? { + return try! FfiConverterOptionTypeSecp256r1PublicKey.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_secp256r1_opt(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asZklogin() -> ZkLoginPublicIdentifier { + return try! FfiConverterTypeZkLoginPublicIdentifier_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_zklogin(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asZkloginOpt() -> ZkLoginPublicIdentifier? { + return try! FfiConverterOptionTypeZkLoginPublicIdentifier.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_zklogin_opt(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isEd25519() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_is_ed25519(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isSecp256k1() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_is_secp256k1(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isSecp256r1() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_is_secp256r1(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isZklogin() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_is_zklogin(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMultisigMemberPublicKey: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = MultisigMemberPublicKey + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> MultisigMemberPublicKey { + return MultisigMemberPublicKey(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: MultisigMemberPublicKey) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MultisigMemberPublicKey { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: MultisigMemberPublicKey, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigMemberPublicKey_lift(_ pointer: UnsafeMutableRawPointer) throws -> MultisigMemberPublicKey { + return try FfiConverterTypeMultisigMemberPublicKey.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigMemberPublicKey_lower(_ value: MultisigMemberPublicKey) -> UnsafeMutableRawPointer { + return FfiConverterTypeMultisigMemberPublicKey.lower(value) +} + + + + + + +/** + * 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 + * ``` + */ +public protocol MultisigMemberSignatureProtocol: AnyObject, Sendable { + + func asEd25519() -> Ed25519Signature + + func asEd25519Opt() -> Ed25519Signature? + + func asSecp256k1() -> Secp256k1Signature + + func asSecp256k1Opt() -> Secp256k1Signature? + + func asSecp256r1() -> Secp256r1Signature + + func asSecp256r1Opt() -> Secp256r1Signature? + + func asZklogin() -> ZkLoginAuthenticator + + func asZkloginOpt() -> ZkLoginAuthenticator? + + func isEd25519() -> Bool + + func isSecp256k1() -> Bool + + func isSecp256r1() -> Bool + + func isZklogin() -> Bool + +} +/** + * 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 + * ``` + */ +open class MultisigMemberSignature: MultisigMemberSignatureProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_multisigmembersignature(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_multisigmembersignature(pointer, $0) } + } + + + + +open func asEd25519() -> Ed25519Signature { + return try! FfiConverterTypeEd25519Signature_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_ed25519(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asEd25519Opt() -> Ed25519Signature? { + return try! FfiConverterOptionTypeEd25519Signature.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_ed25519_opt(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asSecp256k1() -> Secp256k1Signature { + return try! FfiConverterTypeSecp256k1Signature_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_secp256k1(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asSecp256k1Opt() -> Secp256k1Signature? { + return try! FfiConverterOptionTypeSecp256k1Signature.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_secp256k1_opt(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asSecp256r1() -> Secp256r1Signature { + return try! FfiConverterTypeSecp256r1Signature_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_secp256r1(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asSecp256r1Opt() -> Secp256r1Signature? { + return try! FfiConverterOptionTypeSecp256r1Signature.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_secp256r1_opt(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asZklogin() -> ZkLoginAuthenticator { + return try! FfiConverterTypeZkLoginAuthenticator_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_zklogin(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asZkloginOpt() -> ZkLoginAuthenticator? { + return try! FfiConverterOptionTypeZkLoginAuthenticator.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_zklogin_opt(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isEd25519() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_is_ed25519(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isSecp256k1() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_is_secp256k1(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isSecp256r1() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_is_secp256r1(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isZklogin() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_is_zklogin(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMultisigMemberSignature: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = MultisigMemberSignature + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> MultisigMemberSignature { + return MultisigMemberSignature(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: MultisigMemberSignature) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MultisigMemberSignature { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: MultisigMemberSignature, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigMemberSignature_lift(_ pointer: UnsafeMutableRawPointer) throws -> MultisigMemberSignature { + return try FfiConverterTypeMultisigMemberSignature.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMultisigMemberSignature_lower(_ value: MultisigMemberSignature) -> UnsafeMutableRawPointer { + return FfiConverterTypeMultisigMemberSignature.lower(value) +} + + + + + + +/** + * 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 + * ``` + */ +public protocol ObjectProtocol: AnyObject, Sendable { + + /** + * Try to interpret this object as a move struct + */ + func asStruct() -> MoveStruct? + + /** + * Return this object's data + */ + func data() -> ObjectData + + /** + * Return this object's id + */ + func objectId() -> ObjectId + + /** + * Return this object's type + */ + func objectType() -> ObjectType + + /** + * Return this object's owner + */ + func owner() -> Owner + + /** + * Return the digest of the transaction that last modified this object + */ + func previousTransaction() -> TransactionDigest + + /** + * Return the storage rebate locked in this object + * + * Storage rebates are credited to the gas coin used in a transaction that + * deletes this object. + */ + func storageRebate() -> UInt64 + + /** + * Return this object's version + */ + func version() -> UInt64 + +} +/** + * 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 + * ``` + */ +open class Object: ObjectProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_object(self.pointer, $0) } + } +public convenience init(data: ObjectData, owner: Owner, previousTransaction: TransactionDigest, storageRebate: UInt64) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_object_new( + FfiConverterTypeObjectData_lower(data), + FfiConverterTypeOwner_lower(owner), + FfiConverterTypeTransactionDigest_lower(previousTransaction), + FfiConverterUInt64.lower(storageRebate),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_object(pointer, $0) } + } + + + + + /** + * Try to interpret this object as a move struct + */ +open func asStruct() -> MoveStruct? { + return try! FfiConverterOptionTypeMoveStruct.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_object_as_struct(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Return this object's data + */ +open func data() -> ObjectData { + return try! FfiConverterTypeObjectData_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_object_data(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Return this object's id + */ +open func objectId() -> ObjectId { + return try! FfiConverterTypeObjectId_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_object_object_id(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Return this object's type + */ +open func objectType() -> ObjectType { + return try! FfiConverterTypeObjectType_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_object_object_type(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Return this object's owner + */ +open func owner() -> Owner { + return try! FfiConverterTypeOwner_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_object_owner(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Return the digest of the transaction that last modified this object + */ +open func previousTransaction() -> TransactionDigest { + return try! FfiConverterTypeTransactionDigest_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_object_previous_transaction(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Return the storage rebate locked in this object + * + * Storage rebates are credited to the gas coin used in a transaction that + * deletes this object. + */ +open func storageRebate() -> UInt64 { + return try! FfiConverterUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_object_storage_rebate(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Return this object's version + */ +open func version() -> UInt64 { + return try! FfiConverterUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_object_version(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeObject: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = Object + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Object { + return Object(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: Object) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Object { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: Object, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeObject_lift(_ pointer: UnsafeMutableRawPointer) throws -> Object { + return try FfiConverterTypeObject.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeObject_lower(_ value: Object) -> UnsafeMutableRawPointer { + return FfiConverterTypeObject.lower(value) +} + + + + + + +public protocol ObjectDataProtocol: AnyObject, Sendable { + + /** + * Try to interpret this object as a `MovePackage` + */ + func asPackageOpt() -> MovePackage? + + /** + * Try to interpret this object as a `MoveStruct` + */ + func asStructOpt() -> MoveStruct? + + /** + * Return whether this object is a `MovePackage` + */ + func isPackage() -> Bool + + /** + * Return whether this object is a `MoveStruct` + */ + func isStruct() -> Bool + +} +open class ObjectData: ObjectDataProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_objectdata(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_objectdata(pointer, $0) } + } + + + /** + * Create an `ObjectData` from `MovePackage` + */ +public static func newMovePackage(movePackage: MovePackage) -> ObjectData { + return try! FfiConverterTypeObjectData_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_objectdata_new_move_package( + FfiConverterTypeMovePackage_lower(movePackage),$0 + ) +}) +} + + /** + * Create an `ObjectData` from a `MoveStruct` + */ +public static func newMoveStruct(moveStruct: MoveStruct) -> ObjectData { + return try! FfiConverterTypeObjectData_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_objectdata_new_move_struct( + FfiConverterTypeMoveStruct_lower(moveStruct),$0 + ) +}) +} + + + + /** + * Try to interpret this object as a `MovePackage` + */ +open func asPackageOpt() -> MovePackage? { + return try! FfiConverterOptionTypeMovePackage.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_objectdata_as_package_opt(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Try to interpret this object as a `MoveStruct` + */ +open func asStructOpt() -> MoveStruct? { + return try! FfiConverterOptionTypeMoveStruct.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_objectdata_as_struct_opt(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Return whether this object is a `MovePackage` + */ +open func isPackage() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_objectdata_is_package(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Return whether this object is a `MoveStruct` + */ +open func isStruct() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_objectdata_is_struct(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeObjectData: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = ObjectData + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> ObjectData { + return ObjectData(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: ObjectData) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ObjectData { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: ObjectData, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeObjectData_lift(_ pointer: UnsafeMutableRawPointer) throws -> ObjectData { + return try FfiConverterTypeObjectData.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeObjectData_lower(_ value: ObjectData) -> UnsafeMutableRawPointer { + return FfiConverterTypeObjectData.lower(value) +} + + + + + + +public protocol ObjectDigestProtocol: AnyObject, Sendable { + + func toBase58() -> String + + func toBytes() -> Data + +} +open class ObjectDigest: ObjectDigestProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_objectdigest(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_objectdigest(pointer, $0) } + } + + +public static func fromBase58(base58: String)throws -> ObjectDigest { + return try FfiConverterTypeObjectDigest_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_objectdigest_from_base58( + FfiConverterString.lower(base58),$0 + ) +}) +} + +public static func fromBytes(bytes: Data)throws -> ObjectDigest { + return try FfiConverterTypeObjectDigest_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_objectdigest_from_bytes( + FfiConverterData.lower(bytes),$0 + ) +}) +} + +public static func generate() -> ObjectDigest { + return try! FfiConverterTypeObjectDigest_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_objectdigest_generate($0 + ) +}) +} + + + +open func toBase58() -> String { + return try! FfiConverterString.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_objectdigest_to_base58(self.uniffiClonePointer(),$0 + ) +}) +} + +open func toBytes() -> Data { + return try! FfiConverterData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_objectdigest_to_bytes(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeObjectDigest: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = ObjectDigest + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> ObjectDigest { + return ObjectDigest(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: ObjectDigest) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ObjectDigest { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: ObjectDigest, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeObjectDigest_lift(_ pointer: UnsafeMutableRawPointer) throws -> ObjectDigest { + return try FfiConverterTypeObjectDigest.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeObjectDigest_lower(_ value: ObjectDigest) -> UnsafeMutableRawPointer { + return FfiConverterTypeObjectDigest.lower(value) +} + + + + + + +/** + * 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 + * ``` + */ +public protocol ObjectIdProtocol: AnyObject, Sendable { + + func toAddress() -> Address + + func toBytes() -> Data + + func toHex() -> 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 + * ``` + */ +open class ObjectId: ObjectIdProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_objectid(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_objectid(pointer, $0) } + } + + +public static func fromBytes(bytes: Data)throws -> ObjectId { + return try FfiConverterTypeObjectId_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_objectid_from_bytes( + FfiConverterData.lower(bytes),$0 + ) +}) +} + +public static func fromHex(hex: String)throws -> ObjectId { + return try FfiConverterTypeObjectId_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_objectid_from_hex( + FfiConverterString.lower(hex),$0 + ) +}) +} + + + +open func toAddress() -> Address { + return try! FfiConverterTypeAddress_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_objectid_to_address(self.uniffiClonePointer(),$0 + ) +}) +} + +open func toBytes() -> Data { + return try! FfiConverterData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_objectid_to_bytes(self.uniffiClonePointer(),$0 + ) +}) +} + +open func toHex() -> String { + return try! FfiConverterString.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_objectid_to_hex(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeObjectId: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = ObjectId + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> ObjectId { + return ObjectId(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: ObjectId) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ObjectId { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: ObjectId, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeObjectId_lift(_ pointer: UnsafeMutableRawPointer) throws -> ObjectId { + return try FfiConverterTypeObjectId.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeObjectId_lower(_ value: ObjectId) -> UnsafeMutableRawPointer { + return FfiConverterTypeObjectId.lower(value) +} + + + + + + +public protocol ObjectTypeProtocol: AnyObject, Sendable { + + func asStructOpt() -> StructTag? + + func isPackage() -> Bool + + func isStruct() -> Bool + +} +open class ObjectType: ObjectTypeProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_objecttype(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_objecttype(pointer, $0) } + } + + +public static func newPackage() -> ObjectType { + return try! FfiConverterTypeObjectType_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_objecttype_new_package($0 + ) +}) +} + +public static func newStruct(structTag: StructTag) -> ObjectType { + return try! FfiConverterTypeObjectType_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_objecttype_new_struct( + FfiConverterTypeStructTag_lower(structTag),$0 + ) +}) +} + + + +open func asStructOpt() -> StructTag? { + return try! FfiConverterOptionTypeStructTag.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_objecttype_as_struct_opt(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isPackage() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_objecttype_is_package(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isStruct() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_objecttype_is_struct(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeObjectType: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = ObjectType + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> ObjectType { + return ObjectType(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: ObjectType) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ObjectType { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: ObjectType, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeObjectType_lift(_ pointer: UnsafeMutableRawPointer) throws -> ObjectType { + return try FfiConverterTypeObjectType.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeObjectType_lower(_ value: ObjectType) -> UnsafeMutableRawPointer { + return FfiConverterTypeObjectType.lower(value) +} + + + + + + +public protocol OwnerProtocol: AnyObject, Sendable { + + func asAddressOpt() -> Address? + + func asObjectOpt() -> ObjectId? + + func asSharedOpt() -> UInt64? + + func isAddress() -> Bool + + func isImmutable() -> Bool + + func isObject() -> Bool + + func isShared() -> Bool + +} +open class Owner: OwnerProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_owner(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_owner(pointer, $0) } + } + + +public static func newAddress(address: Address) -> Owner { + return try! FfiConverterTypeOwner_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_owner_new_address( + FfiConverterTypeAddress_lower(address),$0 + ) +}) +} + +public static func newImmutable() -> Owner { + return try! FfiConverterTypeOwner_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_owner_new_immutable($0 + ) +}) +} + +public static func newObject(id: ObjectId) -> Owner { + return try! FfiConverterTypeOwner_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_owner_new_object( + FfiConverterTypeObjectId_lower(id),$0 + ) +}) +} + +public static func newShared(version: UInt64) -> Owner { + return try! FfiConverterTypeOwner_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_owner_new_shared( + FfiConverterUInt64.lower(version),$0 + ) +}) +} + + + +open func asAddressOpt() -> Address? { + return try! FfiConverterOptionTypeAddress.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_owner_as_address_opt(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asObjectOpt() -> ObjectId? { + return try! FfiConverterOptionTypeObjectId.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_owner_as_object_opt(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asSharedOpt() -> UInt64? { + return try! FfiConverterOptionUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_owner_as_shared_opt(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isAddress() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_owner_is_address(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isImmutable() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_owner_is_immutable(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isObject() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_owner_is_object(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isShared() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_owner_is_shared(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeOwner: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = Owner + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Owner { + return Owner(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: Owner) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Owner { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: Owner, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeOwner_lift(_ pointer: UnsafeMutableRawPointer) throws -> Owner { + return try FfiConverterTypeOwner.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeOwner_lower(_ value: Owner) -> UnsafeMutableRawPointer { + return FfiConverterTypeOwner.lower(value) +} + + + + + + +/** + * 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 [CollectedClientData](https://www.w3.org/TR/webauthn-2/#dictdef-collectedclientdata) 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. + */ +public protocol PasskeyAuthenticatorProtocol: AnyObject, Sendable { + + /** + * Opaque authenticator data for this passkey signature. + * + * See [Authenticator Data](https://www.w3.org/TR/webauthn-2/#sctn-authenticator-data) for + * more information on this field. + */ + func authenticatorData() -> Data + + /** + * The parsed challenge message for this passkey signature. + * + * This is parsed by decoding the base64url data from the + * `client_data_json.challenge` field. + */ + func challenge() -> Data + + /** + * Structured, unparsed, JSON for this passkey signature. + * + * See [CollectedClientData](https://www.w3.org/TR/webauthn-2/#dictdef-collectedclientdata) + * for more information on this field. + */ + func clientDataJson() -> String + + /** + * The passkey signature. + */ + func 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 [CollectedClientData](https://www.w3.org/TR/webauthn-2/#dictdef-collectedclientdata) 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. + */ +open class PasskeyAuthenticator: PasskeyAuthenticatorProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_passkeyauthenticator(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_passkeyauthenticator(pointer, $0) } + } + + + + + /** + * Opaque authenticator data for this passkey signature. + * + * See [Authenticator Data](https://www.w3.org/TR/webauthn-2/#sctn-authenticator-data) for + * more information on this field. + */ +open func authenticatorData() -> Data { + return try! FfiConverterData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_authenticator_data(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * The parsed challenge message for this passkey signature. + * + * This is parsed by decoding the base64url data from the + * `client_data_json.challenge` field. + */ +open func challenge() -> Data { + return try! FfiConverterData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_challenge(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Structured, unparsed, JSON for this passkey signature. + * + * See [CollectedClientData](https://www.w3.org/TR/webauthn-2/#dictdef-collectedclientdata) + * for more information on this field. + */ +open func clientDataJson() -> String { + return try! FfiConverterString.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_client_data_json(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * The passkey signature. + */ +open func signature() -> SimpleSignature { + return try! FfiConverterTypeSimpleSignature_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_signature(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypePasskeyAuthenticator: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = PasskeyAuthenticator + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> PasskeyAuthenticator { + return PasskeyAuthenticator(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: PasskeyAuthenticator) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PasskeyAuthenticator { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: PasskeyAuthenticator, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypePasskeyAuthenticator_lift(_ pointer: UnsafeMutableRawPointer) throws -> PasskeyAuthenticator { + return try FfiConverterTypePasskeyAuthenticator.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypePasskeyAuthenticator_lower(_ value: PasskeyAuthenticator) -> UnsafeMutableRawPointer { + return FfiConverterTypePasskeyAuthenticator.lower(value) +} + + + + + + +/** + * 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) + * ``` + */ +public protocol ProgrammableTransactionProtocol: AnyObject, Sendable { + + /** + * The commands to be executed sequentially. A failure in any command will + * result in the failure of the entire transaction. + */ + func commands() -> [Command] + + /** + * Input objects or primitive values + */ + func inputs() -> [Input] + +} +/** + * 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) + * ``` + */ +open class ProgrammableTransaction: ProgrammableTransactionProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_programmabletransaction(self.pointer, $0) } + } +public convenience init(inputs: [Input], commands: [Command]) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_programmabletransaction_new( + FfiConverterSequenceTypeInput.lower(inputs), + FfiConverterSequenceTypeCommand.lower(commands),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_programmabletransaction(pointer, $0) } + } + + + + + /** + * The commands to be executed sequentially. A failure in any command will + * result in the failure of the entire transaction. + */ +open func commands() -> [Command] { + return try! FfiConverterSequenceTypeCommand.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_programmabletransaction_commands(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Input objects or primitive values + */ +open func inputs() -> [Input] { + return try! FfiConverterSequenceTypeInput.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_programmabletransaction_inputs(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeProgrammableTransaction: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = ProgrammableTransaction + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> ProgrammableTransaction { + return ProgrammableTransaction(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: ProgrammableTransaction) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ProgrammableTransaction { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: ProgrammableTransaction, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeProgrammableTransaction_lift(_ pointer: UnsafeMutableRawPointer) throws -> ProgrammableTransaction { + return try FfiConverterTypeProgrammableTransaction.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeProgrammableTransaction_lower(_ value: ProgrammableTransaction) -> UnsafeMutableRawPointer { + return FfiConverterTypeProgrammableTransaction.lower(value) +} + + + + + + +/** + * 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 + * ``` + */ +public protocol PublishProtocol: AnyObject, Sendable { + + /** + * Set of packages that the to-be published package depends on + */ + func dependencies() -> [ObjectId] + + /** + * The serialized move modules + */ + func modules() -> [Data] + +} +/** + * 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 + * ``` + */ +open class Publish: PublishProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_publish(self.pointer, $0) } + } +public convenience init(modules: [Data], dependencies: [ObjectId]) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_publish_new( + FfiConverterSequenceData.lower(modules), + FfiConverterSequenceTypeObjectId.lower(dependencies),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_publish(pointer, $0) } + } + + + + + /** + * Set of packages that the to-be published package depends on + */ +open func dependencies() -> [ObjectId] { + return try! FfiConverterSequenceTypeObjectId.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_publish_dependencies(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * The serialized move modules + */ +open func modules() -> [Data] { + return try! FfiConverterSequenceData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_publish_modules(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypePublish: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = Publish + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Publish { + return Publish(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: Publish) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Publish { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: Publish, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypePublish_lift(_ pointer: UnsafeMutableRawPointer) throws -> Publish { + return try FfiConverterTypePublish.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypePublish_lower(_ value: Publish) -> UnsafeMutableRawPointer { + return FfiConverterTypePublish.lower(value) +} + + + + + + +/** + * A secp256k1 signature. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * secp256k1-signature = 64OCTECT + * ``` + */ +public protocol Secp256k1PublicKeyProtocol: AnyObject, Sendable { + + func toBytes() -> Data + +} +/** + * A secp256k1 signature. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * secp256k1-signature = 64OCTECT + * ``` + */ +open class Secp256k1PublicKey: Secp256k1PublicKeyProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_secp256k1publickey(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_secp256k1publickey(pointer, $0) } + } + + +public static func fromBytes(bytes: Data)throws -> Secp256k1PublicKey { + return try FfiConverterTypeSecp256k1PublicKey_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_secp256k1publickey_from_bytes( + FfiConverterData.lower(bytes),$0 + ) +}) +} + +public static func fromStr(s: String)throws -> Secp256k1PublicKey { + return try FfiConverterTypeSecp256k1PublicKey_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_secp256k1publickey_from_str( + FfiConverterString.lower(s),$0 + ) +}) +} + +public static func generate() -> Secp256k1PublicKey { + return try! FfiConverterTypeSecp256k1PublicKey_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_secp256k1publickey_generate($0 + ) +}) +} + + + +open func toBytes() -> Data { + return try! FfiConverterData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_secp256k1publickey_to_bytes(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeSecp256k1PublicKey: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = Secp256k1PublicKey + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Secp256k1PublicKey { + return Secp256k1PublicKey(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: Secp256k1PublicKey) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Secp256k1PublicKey { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: Secp256k1PublicKey, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSecp256k1PublicKey_lift(_ pointer: UnsafeMutableRawPointer) throws -> Secp256k1PublicKey { + return try FfiConverterTypeSecp256k1PublicKey.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSecp256k1PublicKey_lower(_ value: Secp256k1PublicKey) -> UnsafeMutableRawPointer { + return FfiConverterTypeSecp256k1PublicKey.lower(value) +} + + + + + + +/** + * A secp256k1 public key. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * secp256k1-public-key = 33OCTECT + * ``` + */ +public protocol Secp256k1SignatureProtocol: AnyObject, Sendable { + + func toBytes() -> Data + +} +/** + * A secp256k1 public key. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * secp256k1-public-key = 33OCTECT + * ``` + */ +open class Secp256k1Signature: Secp256k1SignatureProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_secp256k1signature(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_secp256k1signature(pointer, $0) } + } + + +public static func fromBytes(bytes: Data)throws -> Secp256k1Signature { + return try FfiConverterTypeSecp256k1Signature_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_secp256k1signature_from_bytes( + FfiConverterData.lower(bytes),$0 + ) +}) +} + +public static func fromStr(s: String)throws -> Secp256k1Signature { + return try FfiConverterTypeSecp256k1Signature_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_secp256k1signature_from_str( + FfiConverterString.lower(s),$0 + ) +}) +} + +public static func generate() -> Secp256k1Signature { + return try! FfiConverterTypeSecp256k1Signature_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_secp256k1signature_generate($0 + ) +}) +} + + + +open func toBytes() -> Data { + return try! FfiConverterData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_secp256k1signature_to_bytes(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeSecp256k1Signature: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = Secp256k1Signature + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Secp256k1Signature { + return Secp256k1Signature(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: Secp256k1Signature) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Secp256k1Signature { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: Secp256k1Signature, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSecp256k1Signature_lift(_ pointer: UnsafeMutableRawPointer) throws -> Secp256k1Signature { + return try FfiConverterTypeSecp256k1Signature.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSecp256k1Signature_lower(_ value: Secp256k1Signature) -> UnsafeMutableRawPointer { + return FfiConverterTypeSecp256k1Signature.lower(value) +} + + + + + + +/** + * A secp256r1 signature. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * secp256r1-signature = 64OCTECT + * ``` + */ +public protocol Secp256r1PublicKeyProtocol: AnyObject, Sendable { + + func toBytes() -> Data + +} +/** + * A secp256r1 signature. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * secp256r1-signature = 64OCTECT + * ``` + */ +open class Secp256r1PublicKey: Secp256r1PublicKeyProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_secp256r1publickey(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_secp256r1publickey(pointer, $0) } + } + + +public static func fromBytes(bytes: Data)throws -> Secp256r1PublicKey { + return try FfiConverterTypeSecp256r1PublicKey_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_secp256r1publickey_from_bytes( + FfiConverterData.lower(bytes),$0 + ) +}) +} + +public static func fromStr(s: String)throws -> Secp256r1PublicKey { + return try FfiConverterTypeSecp256r1PublicKey_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_secp256r1publickey_from_str( + FfiConverterString.lower(s),$0 + ) +}) +} + +public static func generate() -> Secp256r1PublicKey { + return try! FfiConverterTypeSecp256r1PublicKey_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_secp256r1publickey_generate($0 + ) +}) +} + + + +open func toBytes() -> Data { + return try! FfiConverterData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_secp256r1publickey_to_bytes(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeSecp256r1PublicKey: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = Secp256r1PublicKey + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Secp256r1PublicKey { + return Secp256r1PublicKey(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: Secp256r1PublicKey) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Secp256r1PublicKey { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: Secp256r1PublicKey, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSecp256r1PublicKey_lift(_ pointer: UnsafeMutableRawPointer) throws -> Secp256r1PublicKey { + return try FfiConverterTypeSecp256r1PublicKey.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSecp256r1PublicKey_lower(_ value: Secp256r1PublicKey) -> UnsafeMutableRawPointer { + return FfiConverterTypeSecp256r1PublicKey.lower(value) +} + + + + + + +/** + * A secp256r1 public key. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * secp256r1-public-key = 33OCTECT + * ``` + */ +public protocol Secp256r1SignatureProtocol: AnyObject, Sendable { + + func toBytes() -> Data + +} +/** + * A secp256r1 public key. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * secp256r1-public-key = 33OCTECT + * ``` + */ +open class Secp256r1Signature: Secp256r1SignatureProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_secp256r1signature(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_secp256r1signature(pointer, $0) } + } + + +public static func fromBytes(bytes: Data)throws -> Secp256r1Signature { + return try FfiConverterTypeSecp256r1Signature_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_secp256r1signature_from_bytes( + FfiConverterData.lower(bytes),$0 + ) +}) +} + +public static func fromStr(s: String)throws -> Secp256r1Signature { + return try FfiConverterTypeSecp256r1Signature_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_secp256r1signature_from_str( + FfiConverterString.lower(s),$0 + ) +}) +} + +public static func generate() -> Secp256r1Signature { + return try! FfiConverterTypeSecp256r1Signature_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_secp256r1signature_generate($0 + ) +}) +} + + + +open func toBytes() -> Data { + return try! FfiConverterData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_secp256r1signature_to_bytes(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeSecp256r1Signature: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = Secp256r1Signature + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Secp256r1Signature { + return Secp256r1Signature(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: Secp256r1Signature) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Secp256r1Signature { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: Secp256r1Signature, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSecp256r1Signature_lift(_ pointer: UnsafeMutableRawPointer) throws -> Secp256r1Signature { + return try FfiConverterTypeSecp256r1Signature.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSecp256r1Signature_lower(_ value: Secp256r1Signature) -> UnsafeMutableRawPointer { + return FfiConverterTypeSecp256r1Signature.lower(value) +} + + + + + + +/** + * 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. + */ +public protocol SimpleSignatureProtocol: AnyObject, Sendable { + + func ed25519PubKey() -> Ed25519PublicKey + + func ed25519PubKeyOpt() -> Ed25519PublicKey? + + func ed25519Sig() -> Ed25519Signature + + func ed25519SigOpt() -> Ed25519Signature? + + func isEd25519() -> Bool + + func isSecp256k1() -> Bool + + func isSecp256r1() -> Bool + + func scheme() -> SignatureScheme + + func secp256k1PubKey() -> Secp256k1PublicKey + + func secp256k1PubKeyOpt() -> Secp256k1PublicKey? + + func secp256k1Sig() -> Secp256k1Signature + + func secp256k1SigOpt() -> Secp256k1Signature? + + func secp256r1PubKey() -> Secp256r1PublicKey + + func secp256r1PubKeyOpt() -> Secp256r1PublicKey? + + func secp256r1Sig() -> Secp256r1Signature + + func secp256r1SigOpt() -> Secp256r1Signature? + + func toBytes() -> Data + +} +/** + * 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. + */ +open class SimpleSignature: SimpleSignatureProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_simplesignature(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_simplesignature(pointer, $0) } + } + + + + +open func ed25519PubKey() -> Ed25519PublicKey { + return try! FfiConverterTypeEd25519PublicKey_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_simplesignature_ed25519_pub_key(self.uniffiClonePointer(),$0 + ) +}) +} + +open func ed25519PubKeyOpt() -> Ed25519PublicKey? { + return try! FfiConverterOptionTypeEd25519PublicKey.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_simplesignature_ed25519_pub_key_opt(self.uniffiClonePointer(),$0 + ) +}) +} + +open func ed25519Sig() -> Ed25519Signature { + return try! FfiConverterTypeEd25519Signature_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_simplesignature_ed25519_sig(self.uniffiClonePointer(),$0 + ) +}) +} + +open func ed25519SigOpt() -> Ed25519Signature? { + return try! FfiConverterOptionTypeEd25519Signature.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_simplesignature_ed25519_sig_opt(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isEd25519() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_simplesignature_is_ed25519(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isSecp256k1() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_simplesignature_is_secp256k1(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isSecp256r1() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_simplesignature_is_secp256r1(self.uniffiClonePointer(),$0 + ) +}) +} + +open func scheme() -> SignatureScheme { + return try! FfiConverterTypeSignatureScheme_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_simplesignature_scheme(self.uniffiClonePointer(),$0 + ) +}) +} + +open func secp256k1PubKey() -> Secp256k1PublicKey { + return try! FfiConverterTypeSecp256k1PublicKey_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256k1_pub_key(self.uniffiClonePointer(),$0 + ) +}) +} + +open func secp256k1PubKeyOpt() -> Secp256k1PublicKey? { + return try! FfiConverterOptionTypeSecp256k1PublicKey.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256k1_pub_key_opt(self.uniffiClonePointer(),$0 + ) +}) +} + +open func secp256k1Sig() -> Secp256k1Signature { + return try! FfiConverterTypeSecp256k1Signature_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256k1_sig(self.uniffiClonePointer(),$0 + ) +}) +} + +open func secp256k1SigOpt() -> Secp256k1Signature? { + return try! FfiConverterOptionTypeSecp256k1Signature.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256k1_sig_opt(self.uniffiClonePointer(),$0 + ) +}) +} + +open func secp256r1PubKey() -> Secp256r1PublicKey { + return try! FfiConverterTypeSecp256r1PublicKey_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256r1_pub_key(self.uniffiClonePointer(),$0 + ) +}) +} + +open func secp256r1PubKeyOpt() -> Secp256r1PublicKey? { + return try! FfiConverterOptionTypeSecp256r1PublicKey.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256r1_pub_key_opt(self.uniffiClonePointer(),$0 + ) +}) +} + +open func secp256r1Sig() -> Secp256r1Signature { + return try! FfiConverterTypeSecp256r1Signature_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256r1_sig(self.uniffiClonePointer(),$0 + ) +}) +} + +open func secp256r1SigOpt() -> Secp256r1Signature? { + return try! FfiConverterOptionTypeSecp256r1Signature.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256r1_sig_opt(self.uniffiClonePointer(),$0 + ) +}) +} + +open func toBytes() -> Data { + return try! FfiConverterData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_simplesignature_to_bytes(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeSimpleSignature: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = SimpleSignature + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> SimpleSignature { + return SimpleSignature(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: SimpleSignature) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SimpleSignature { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: SimpleSignature, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSimpleSignature_lift(_ pointer: UnsafeMutableRawPointer) throws -> SimpleSignature { + return try FfiConverterTypeSimpleSignature.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSimpleSignature_lower(_ value: SimpleSignature) -> UnsafeMutableRawPointer { + return FfiConverterTypeSimpleSignature.lower(value) +} + + + + + + +/** + * 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) + * ``` + */ +public protocol SplitCoinsProtocol: AnyObject, Sendable { + + /** + * The amounts to split off + */ + func amounts() -> [Argument] + + /** + * The coin to split + */ + func 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) + * ``` + */ +open class SplitCoins: SplitCoinsProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_splitcoins(self.pointer, $0) } + } +public convenience init(coin: Argument, amounts: [Argument]) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_splitcoins_new( + FfiConverterTypeArgument_lower(coin), + FfiConverterSequenceTypeArgument.lower(amounts),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_splitcoins(pointer, $0) } + } + + + + + /** + * The amounts to split off + */ +open func amounts() -> [Argument] { + return try! FfiConverterSequenceTypeArgument.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_splitcoins_amounts(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * The coin to split + */ +open func coin() -> Argument { + return try! FfiConverterTypeArgument_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_splitcoins_coin(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeSplitCoins: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = SplitCoins + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> SplitCoins { + return SplitCoins(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: SplitCoins) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SplitCoins { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: SplitCoins, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSplitCoins_lift(_ pointer: UnsafeMutableRawPointer) throws -> SplitCoins { + return try FfiConverterTypeSplitCoins.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSplitCoins_lower(_ value: SplitCoins) -> UnsafeMutableRawPointer { + return FfiConverterTypeSplitCoins.lower(value) +} + + + + + + +/** + * 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 + * ``` + */ +public protocol StructTagProtocol: AnyObject, Sendable { + + func address() -> Address + + /** + * Checks if this is a Coin type + */ + func coinType() -> TypeTag + + /** + * Checks if this is a Coin type + */ + func coinTypeOpt() -> TypeTag? + +} +/** + * 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 + * ``` + */ +open class StructTag: StructTagProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_structtag(self.pointer, $0) } + } +public convenience init(address: Address, module: Identifier, name: Identifier, typeParams: [TypeTag]) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_structtag_new( + FfiConverterTypeAddress_lower(address), + FfiConverterTypeIdentifier_lower(module), + FfiConverterTypeIdentifier_lower(name), + FfiConverterSequenceTypeTypeTag.lower(typeParams),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_structtag(pointer, $0) } + } + + +public static func coin(typeTag: TypeTag) -> StructTag { + return try! FfiConverterTypeStructTag_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_structtag_coin( + FfiConverterTypeTypeTag_lower(typeTag),$0 + ) +}) +} + +public static func gasCoin() -> StructTag { + return try! FfiConverterTypeStructTag_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_structtag_gas_coin($0 + ) +}) +} + +public static func stakedIota() -> StructTag { + return try! FfiConverterTypeStructTag_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_structtag_staked_iota($0 + ) +}) +} + + + +open func address() -> Address { + return try! FfiConverterTypeAddress_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_structtag_address(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Checks if this is a Coin type + */ +open func coinType() -> TypeTag { + return try! FfiConverterTypeTypeTag_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_structtag_coin_type(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Checks if this is a Coin type + */ +open func coinTypeOpt() -> TypeTag? { + return try! FfiConverterOptionTypeTypeTag.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_structtag_coin_type_opt(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeStructTag: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = StructTag + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> StructTag { + return StructTag(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: StructTag) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> StructTag { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: StructTag, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeStructTag_lift(_ pointer: UnsafeMutableRawPointer) throws -> StructTag { + return try FfiConverterTypeStructTag.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeStructTag_lower(_ value: StructTag) -> UnsafeMutableRawPointer { + return FfiConverterTypeStructTag.lower(value) +} + + + + + + +/** + * 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 + * ``` + */ +public protocol SystemPackageProtocol: AnyObject, Sendable { + + func dependencies() -> [ObjectId] + + func modules() -> [Data] + + func version() -> UInt64 + +} +/** + * 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 + * ``` + */ +open class SystemPackage: SystemPackageProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_systempackage(self.pointer, $0) } + } +public convenience init(version: UInt64, modules: [Data], dependencies: [ObjectId]) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_systempackage_new( + FfiConverterUInt64.lower(version), + FfiConverterSequenceData.lower(modules), + FfiConverterSequenceTypeObjectId.lower(dependencies),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_systempackage(pointer, $0) } + } + + + + +open func dependencies() -> [ObjectId] { + return try! FfiConverterSequenceTypeObjectId.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_systempackage_dependencies(self.uniffiClonePointer(),$0 + ) +}) +} + +open func modules() -> [Data] { + return try! FfiConverterSequenceData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_systempackage_modules(self.uniffiClonePointer(),$0 + ) +}) +} + +open func version() -> UInt64 { + return try! FfiConverterUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_systempackage_version(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeSystemPackage: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = SystemPackage + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> SystemPackage { + return SystemPackage(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: SystemPackage) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SystemPackage { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: SystemPackage, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSystemPackage_lift(_ pointer: UnsafeMutableRawPointer) throws -> SystemPackage { + return try FfiConverterTypeSystemPackage.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSystemPackage_lower(_ value: SystemPackage) -> UnsafeMutableRawPointer { + return FfiConverterTypeSystemPackage.lower(value) +} + + + + + + +/** + * 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 + * ``` + */ +public protocol TransactionProtocol: AnyObject, Sendable { + + func expiration() -> TransactionExpiration + + func gasPayment() -> GasPayment + + func kind() -> TransactionKind + + func sender() -> Address + +} +/** + * 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 + * ``` + */ +open class Transaction: TransactionProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_transaction(self.pointer, $0) } + } +public convenience init(kind: TransactionKind, sender: Address, gasPayment: GasPayment, expiration: TransactionExpiration) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_transaction_new( + FfiConverterTypeTransactionKind_lower(kind), + FfiConverterTypeAddress_lower(sender), + FfiConverterTypeGasPayment_lower(gasPayment), + FfiConverterTypeTransactionExpiration_lower(expiration),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_transaction(pointer, $0) } + } + + + + +open func expiration() -> TransactionExpiration { + return try! FfiConverterTypeTransactionExpiration_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_transaction_expiration(self.uniffiClonePointer(),$0 + ) +}) +} + +open func gasPayment() -> GasPayment { + return try! FfiConverterTypeGasPayment_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_transaction_gas_payment(self.uniffiClonePointer(),$0 + ) +}) +} + +open func kind() -> TransactionKind { + return try! FfiConverterTypeTransactionKind_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_transaction_kind(self.uniffiClonePointer(),$0 + ) +}) +} + +open func sender() -> Address { + return try! FfiConverterTypeAddress_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_transaction_sender(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeTransaction: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = Transaction + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Transaction { + return Transaction(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: Transaction) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Transaction { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: Transaction, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransaction_lift(_ pointer: UnsafeMutableRawPointer) throws -> Transaction { + return try FfiConverterTypeTransaction.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransaction_lower(_ value: Transaction) -> UnsafeMutableRawPointer { + return FfiConverterTypeTransaction.lower(value) +} + + + + + + +public protocol TransactionDigestProtocol: AnyObject, Sendable { + + func toBase58() -> String + + func toBytes() -> Data + +} +open class TransactionDigest: TransactionDigestProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_transactiondigest(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_transactiondigest(pointer, $0) } + } + + +public static func fromBase58(base58: String)throws -> TransactionDigest { + return try FfiConverterTypeTransactionDigest_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_transactiondigest_from_base58( + FfiConverterString.lower(base58),$0 + ) +}) +} + +public static func fromBytes(bytes: Data)throws -> TransactionDigest { + return try FfiConverterTypeTransactionDigest_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_transactiondigest_from_bytes( + FfiConverterData.lower(bytes),$0 + ) +}) +} + +public static func generate() -> TransactionDigest { + return try! FfiConverterTypeTransactionDigest_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_transactiondigest_generate($0 + ) +}) +} + + + +open func toBase58() -> String { + return try! FfiConverterString.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_transactiondigest_to_base58(self.uniffiClonePointer(),$0 + ) +}) +} + +open func toBytes() -> Data { + return try! FfiConverterData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_transactiondigest_to_bytes(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeTransactionDigest: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = TransactionDigest + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> TransactionDigest { + return TransactionDigest(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: TransactionDigest) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TransactionDigest { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: TransactionDigest, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionDigest_lift(_ pointer: UnsafeMutableRawPointer) throws -> TransactionDigest { + return try FfiConverterTypeTransactionDigest.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionDigest_lower(_ value: TransactionDigest) -> UnsafeMutableRawPointer { + return FfiConverterTypeTransactionDigest.lower(value) +} + + + + + + +public protocol TransactionEffectsProtocol: AnyObject, Sendable { + + func asV1() -> TransactionEffectsV1 + + func isV1() -> Bool + +} +open class TransactionEffects: TransactionEffectsProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_transactioneffects(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_transactioneffects(pointer, $0) } + } + + +public static func newV1(effects: TransactionEffectsV1) -> TransactionEffects { + return try! FfiConverterTypeTransactionEffects_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_transactioneffects_new_v1( + FfiConverterTypeTransactionEffectsV1_lower(effects),$0 + ) +}) +} + + + +open func asV1() -> TransactionEffectsV1 { + return try! FfiConverterTypeTransactionEffectsV1_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_transactioneffects_as_v1(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isV1() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_transactioneffects_is_v1(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeTransactionEffects: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = TransactionEffects + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> TransactionEffects { + return TransactionEffects(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: TransactionEffects) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TransactionEffects { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: TransactionEffects, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionEffects_lift(_ pointer: UnsafeMutableRawPointer) throws -> TransactionEffects { + return try FfiConverterTypeTransactionEffects.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionEffects_lower(_ value: TransactionEffects) -> UnsafeMutableRawPointer { + return FfiConverterTypeTransactionEffects.lower(value) +} + + + + + + +public protocol TransactionEffectsDigestProtocol: AnyObject, Sendable { + + func toBase58() -> String + + func toBytes() -> Data + +} +open class TransactionEffectsDigest: TransactionEffectsDigestProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_transactioneffectsdigest(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_transactioneffectsdigest(pointer, $0) } + } + + +public static func fromBase58(base58: String)throws -> TransactionEffectsDigest { + return try FfiConverterTypeTransactionEffectsDigest_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_transactioneffectsdigest_from_base58( + FfiConverterString.lower(base58),$0 + ) +}) +} + +public static func fromBytes(bytes: Data)throws -> TransactionEffectsDigest { + return try FfiConverterTypeTransactionEffectsDigest_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_transactioneffectsdigest_from_bytes( + FfiConverterData.lower(bytes),$0 + ) +}) +} + +public static func generate() -> TransactionEffectsDigest { + return try! FfiConverterTypeTransactionEffectsDigest_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_transactioneffectsdigest_generate($0 + ) +}) +} + + + +open func toBase58() -> String { + return try! FfiConverterString.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_transactioneffectsdigest_to_base58(self.uniffiClonePointer(),$0 + ) +}) +} + +open func toBytes() -> Data { + return try! FfiConverterData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_transactioneffectsdigest_to_bytes(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeTransactionEffectsDigest: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = TransactionEffectsDigest + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> TransactionEffectsDigest { + return TransactionEffectsDigest(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: TransactionEffectsDigest) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TransactionEffectsDigest { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: TransactionEffectsDigest, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionEffectsDigest_lift(_ pointer: UnsafeMutableRawPointer) throws -> TransactionEffectsDigest { + return try FfiConverterTypeTransactionEffectsDigest.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionEffectsDigest_lower(_ value: TransactionEffectsDigest) -> UnsafeMutableRawPointer { + return FfiConverterTypeTransactionEffectsDigest.lower(value) +} + + + + + + +public protocol TransactionEventsDigestProtocol: AnyObject, Sendable { + + func toBase58() -> String + + func toBytes() -> Data + +} +open class TransactionEventsDigest: TransactionEventsDigestProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_transactioneventsdigest(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_transactioneventsdigest(pointer, $0) } + } + + +public static func fromBase58(base58: String)throws -> TransactionEventsDigest { + return try FfiConverterTypeTransactionEventsDigest_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_transactioneventsdigest_from_base58( + FfiConverterString.lower(base58),$0 + ) +}) +} + +public static func fromBytes(bytes: Data)throws -> TransactionEventsDigest { + return try FfiConverterTypeTransactionEventsDigest_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_transactioneventsdigest_from_bytes( + FfiConverterData.lower(bytes),$0 + ) +}) +} + +public static func generate() -> TransactionEventsDigest { + return try! FfiConverterTypeTransactionEventsDigest_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_transactioneventsdigest_generate($0 + ) +}) +} + + + +open func toBase58() -> String { + return try! FfiConverterString.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_transactioneventsdigest_to_base58(self.uniffiClonePointer(),$0 + ) +}) +} + +open func toBytes() -> Data { + return try! FfiConverterData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_transactioneventsdigest_to_bytes(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeTransactionEventsDigest: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = TransactionEventsDigest + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> TransactionEventsDigest { + return TransactionEventsDigest(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: TransactionEventsDigest) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TransactionEventsDigest { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: TransactionEventsDigest, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionEventsDigest_lift(_ pointer: UnsafeMutableRawPointer) throws -> TransactionEventsDigest { + return try FfiConverterTypeTransactionEventsDigest.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionEventsDigest_lower(_ value: TransactionEventsDigest) -> UnsafeMutableRawPointer { + return FfiConverterTypeTransactionEventsDigest.lower(value) +} + + + + + + +/** + * 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 + * ``` + */ +public protocol TransactionKindProtocol: AnyObject, Sendable { + +} +/** + * 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 + * ``` + */ +open class TransactionKind: TransactionKindProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_transactionkind(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_transactionkind(pointer, $0) } + } + + +public static func authenticatorStateUpdateV1(tx: AuthenticatorStateUpdateV1) -> TransactionKind { + return try! FfiConverterTypeTransactionKind_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_transactionkind_authenticator_state_update_v1( + FfiConverterTypeAuthenticatorStateUpdateV1_lower(tx),$0 + ) +}) +} + +public static func consensusCommitPrologueV1(tx: ConsensusCommitPrologueV1) -> TransactionKind { + return try! FfiConverterTypeTransactionKind_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_transactionkind_consensus_commit_prologue_v1( + FfiConverterTypeConsensusCommitPrologueV1_lower(tx),$0 + ) +}) +} + +public static func endOfEpoch(tx: [EndOfEpochTransactionKind]) -> TransactionKind { + return try! FfiConverterTypeTransactionKind_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_transactionkind_end_of_epoch( + FfiConverterSequenceTypeEndOfEpochTransactionKind.lower(tx),$0 + ) +}) +} + +public static func genesis(tx: GenesisTransaction) -> TransactionKind { + return try! FfiConverterTypeTransactionKind_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_transactionkind_genesis( + FfiConverterTypeGenesisTransaction_lower(tx),$0 + ) +}) +} + +public static func programmableTransaction(tx: ProgrammableTransaction) -> TransactionKind { + return try! FfiConverterTypeTransactionKind_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_transactionkind_programmable_transaction( + FfiConverterTypeProgrammableTransaction_lower(tx),$0 + ) +}) +} + +public static func randomnessStateUpdate(tx: RandomnessStateUpdate) -> TransactionKind { + return try! FfiConverterTypeTransactionKind_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_transactionkind_randomness_state_update( + FfiConverterTypeRandomnessStateUpdate_lower(tx),$0 + ) +}) +} + + + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeTransactionKind: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = TransactionKind + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> TransactionKind { + return TransactionKind(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: TransactionKind) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TransactionKind { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: TransactionKind, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionKind_lift(_ pointer: UnsafeMutableRawPointer) throws -> TransactionKind { + return try FfiConverterTypeTransactionKind.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionKind_lower(_ value: TransactionKind) -> UnsafeMutableRawPointer { + return FfiConverterTypeTransactionKind.lower(value) +} + + + + + + +/** + * 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 + * ``` + */ +public protocol TransferObjectsProtocol: AnyObject, Sendable { + + /** + * The address to transfer ownership to + */ + func address() -> Argument + + /** + * Set of objects to transfer + */ + func objects() -> [Argument] + +} +/** + * 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 + * ``` + */ +open class TransferObjects: TransferObjectsProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_transferobjects(self.pointer, $0) } + } +public convenience init(objects: [Argument], address: Argument) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_transferobjects_new( + FfiConverterSequenceTypeArgument.lower(objects), + FfiConverterTypeArgument_lower(address),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_transferobjects(pointer, $0) } + } + + + + + /** + * The address to transfer ownership to + */ +open func address() -> Argument { + return try! FfiConverterTypeArgument_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_transferobjects_address(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Set of objects to transfer + */ +open func objects() -> [Argument] { + return try! FfiConverterSequenceTypeArgument.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_transferobjects_objects(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeTransferObjects: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = TransferObjects + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> TransferObjects { + return TransferObjects(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: TransferObjects) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TransferObjects { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: TransferObjects, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransferObjects_lift(_ pointer: UnsafeMutableRawPointer) throws -> TransferObjects { + return try FfiConverterTypeTransferObjects.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransferObjects_lower(_ value: TransferObjects) -> UnsafeMutableRawPointer { + return FfiConverterTypeTransferObjects.lower(value) +} + + + + + + +/** + * 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 + * ``` + */ +public protocol TypeTagProtocol: AnyObject, Sendable { + + func asStructTag() -> StructTag + + func asStructTagOpt() -> StructTag? + + func asVectorTypeTag() -> TypeTag + + func asVectorTypeTagOpt() -> TypeTag? + + func isAddress() -> Bool + + func isBool() -> Bool + + func isSigner() -> Bool + + func isStruct() -> Bool + + func isU128() -> Bool + + func isU16() -> Bool + + func isU256() -> Bool + + func isU32() -> Bool + + func isU64() -> Bool + + func isU8() -> Bool + + func isVector() -> Bool + +} +/** + * 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 + * ``` + */ +open class TypeTag: TypeTagProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_typetag(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_typetag(pointer, $0) } + } + + +public static func address() -> TypeTag { + return try! FfiConverterTypeTypeTag_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_typetag_address($0 + ) +}) +} + +public static func bool() -> TypeTag { + return try! FfiConverterTypeTypeTag_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_typetag_bool($0 + ) +}) +} + +public static func signer() -> TypeTag { + return try! FfiConverterTypeTypeTag_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_typetag_signer($0 + ) +}) +} + +public static func structTag(structTag: StructTag) -> TypeTag { + return try! FfiConverterTypeTypeTag_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_typetag_struct_tag( + FfiConverterTypeStructTag_lower(structTag),$0 + ) +}) +} + +public static func u128() -> TypeTag { + return try! FfiConverterTypeTypeTag_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_typetag_u128($0 + ) +}) +} + +public static func u16() -> TypeTag { + return try! FfiConverterTypeTypeTag_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_typetag_u16($0 + ) +}) +} + +public static func u256() -> TypeTag { + return try! FfiConverterTypeTypeTag_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_typetag_u256($0 + ) +}) +} + +public static func u32() -> TypeTag { + return try! FfiConverterTypeTypeTag_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_typetag_u32($0 + ) +}) +} + +public static func u64() -> TypeTag { + return try! FfiConverterTypeTypeTag_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_typetag_u64($0 + ) +}) +} + +public static func u8() -> TypeTag { + return try! FfiConverterTypeTypeTag_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_typetag_u8($0 + ) +}) +} + +public static func vector(typeTag: TypeTag) -> TypeTag { + return try! FfiConverterTypeTypeTag_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_typetag_vector( + FfiConverterTypeTypeTag_lower(typeTag),$0 + ) +}) +} + + + +open func asStructTag() -> StructTag { + return try! FfiConverterTypeStructTag_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_typetag_as_struct_tag(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asStructTagOpt() -> StructTag? { + return try! FfiConverterOptionTypeStructTag.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_typetag_as_struct_tag_opt(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asVectorTypeTag() -> TypeTag { + return try! FfiConverterTypeTypeTag_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_typetag_as_vector_type_tag(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asVectorTypeTagOpt() -> TypeTag? { + return try! FfiConverterOptionTypeTypeTag.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_typetag_as_vector_type_tag_opt(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isAddress() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_typetag_is_address(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isBool() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_typetag_is_bool(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isSigner() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_typetag_is_signer(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isStruct() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_typetag_is_struct(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isU128() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_typetag_is_u128(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isU16() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_typetag_is_u16(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isU256() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_typetag_is_u256(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isU32() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_typetag_is_u32(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isU64() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_typetag_is_u64(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isU8() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_typetag_is_u8(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isVector() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_typetag_is_vector(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeTypeTag: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = TypeTag + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> TypeTag { + return TypeTag(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: TypeTag) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TypeTag { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: TypeTag, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTypeTag_lift(_ pointer: UnsafeMutableRawPointer) throws -> TypeTag { + return try FfiConverterTypeTypeTag.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTypeTag_lower(_ value: TypeTag) -> UnsafeMutableRawPointer { + return FfiConverterTypeTypeTag.lower(value) +} + + + + + + +/** + * 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 + * ``` + */ +public protocol UpgradeProtocol: AnyObject, Sendable { + + /** + * Set of packages that the to-be published package depends on + */ + func dependencies() -> [ObjectId] + + /** + * The serialized move modules + */ + func modules() -> [Data] + + /** + * Package id of the package to upgrade + */ + func package() -> ObjectId + + /** + * Ticket authorizing the upgrade + */ + func 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 + * ``` + */ +open class Upgrade: UpgradeProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_upgrade(self.pointer, $0) } + } +public convenience init(modules: [Data], dependencies: [ObjectId], package: ObjectId, ticket: Argument) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_upgrade_new( + FfiConverterSequenceData.lower(modules), + FfiConverterSequenceTypeObjectId.lower(dependencies), + FfiConverterTypeObjectId_lower(package), + FfiConverterTypeArgument_lower(ticket),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_upgrade(pointer, $0) } + } + + + + + /** + * Set of packages that the to-be published package depends on + */ +open func dependencies() -> [ObjectId] { + return try! FfiConverterSequenceTypeObjectId.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_upgrade_dependencies(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * The serialized move modules + */ +open func modules() -> [Data] { + return try! FfiConverterSequenceData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_upgrade_modules(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Package id of the package to upgrade + */ +open func package() -> ObjectId { + return try! FfiConverterTypeObjectId_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_upgrade_package(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Ticket authorizing the upgrade + */ +open func ticket() -> Argument { + return try! FfiConverterTypeArgument_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_upgrade_ticket(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeUpgrade: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = Upgrade + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Upgrade { + return Upgrade(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: Upgrade) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Upgrade { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: Upgrade, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeUpgrade_lift(_ pointer: UnsafeMutableRawPointer) throws -> Upgrade { + return try FfiConverterTypeUpgrade.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeUpgrade_lower(_ value: Upgrade) -> UnsafeMutableRawPointer { + return FfiConverterTypeUpgrade.lower(value) +} + + + + + + +/** + * 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 + * ``` + * + * 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. + */ +public protocol UserSignatureProtocol: AnyObject, Sendable { + + func asMultisig() -> MultisigAggregatedSignature + + func asMultisigOpt() -> MultisigAggregatedSignature? + + func asPasskey() -> PasskeyAuthenticator + + func asPasskeyOpt() -> PasskeyAuthenticator? + + func asSimple() -> SimpleSignature + + func asSimpleOpt() -> SimpleSignature? + + func asZklogin() -> ZkLoginAuthenticator + + func asZkloginOpt() -> ZkLoginAuthenticator? + + func isMultisig() -> Bool + + func isPasskey() -> Bool + + func isSimple() -> Bool + + func isZklogin() -> Bool + + /** + * Return the flag for this signature scheme + */ + func scheme() -> SignatureScheme + + func toBase64() -> String + + func toBytes() -> Data + +} +/** + * 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 + * ``` + * + * 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. + */ +open class UserSignature: UserSignatureProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_usersignature(self.pointer, $0) } + } + // No primary constructor declared for this class. + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_usersignature(pointer, $0) } + } + + +public static func fromBase64(base64: String)throws -> UserSignature { + return try FfiConverterTypeUserSignature_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_usersignature_from_base64( + FfiConverterString.lower(base64),$0 + ) +}) +} + +public static func fromBytes(bytes: Data)throws -> UserSignature { + return try FfiConverterTypeUserSignature_lift(try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_usersignature_from_bytes( + FfiConverterData.lower(bytes),$0 + ) +}) +} + + + +open func asMultisig() -> MultisigAggregatedSignature { + return try! FfiConverterTypeMultisigAggregatedSignature_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_usersignature_as_multisig(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asMultisigOpt() -> MultisigAggregatedSignature? { + return try! FfiConverterOptionTypeMultisigAggregatedSignature.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_usersignature_as_multisig_opt(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asPasskey() -> PasskeyAuthenticator { + return try! FfiConverterTypePasskeyAuthenticator_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_usersignature_as_passkey(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asPasskeyOpt() -> PasskeyAuthenticator? { + return try! FfiConverterOptionTypePasskeyAuthenticator.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_usersignature_as_passkey_opt(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asSimple() -> SimpleSignature { + return try! FfiConverterTypeSimpleSignature_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_usersignature_as_simple(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asSimpleOpt() -> SimpleSignature? { + return try! FfiConverterOptionTypeSimpleSignature.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_usersignature_as_simple_opt(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asZklogin() -> ZkLoginAuthenticator { + return try! FfiConverterTypeZkLoginAuthenticator_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_usersignature_as_zklogin(self.uniffiClonePointer(),$0 + ) +}) +} + +open func asZkloginOpt() -> ZkLoginAuthenticator? { + return try! FfiConverterOptionTypeZkLoginAuthenticator.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_usersignature_as_zklogin_opt(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isMultisig() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_usersignature_is_multisig(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isPasskey() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_usersignature_is_passkey(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isSimple() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_usersignature_is_simple(self.uniffiClonePointer(),$0 + ) +}) +} + +open func isZklogin() -> Bool { + return try! FfiConverterBool.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_usersignature_is_zklogin(self.uniffiClonePointer(),$0 + ) +}) +} + + /** + * Return the flag for this signature scheme + */ +open func scheme() -> SignatureScheme { + return try! FfiConverterTypeSignatureScheme_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_usersignature_scheme(self.uniffiClonePointer(),$0 + ) +}) +} + +open func toBase64() -> String { + return try! FfiConverterString.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_usersignature_to_base64(self.uniffiClonePointer(),$0 + ) +}) +} + +open func toBytes() -> Data { + return try! FfiConverterData.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_usersignature_to_bytes(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeUserSignature: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = UserSignature + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> UserSignature { + return UserSignature(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: UserSignature) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UserSignature { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: UserSignature, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeUserSignature_lift(_ pointer: UnsafeMutableRawPointer) throws -> UserSignature { + return try FfiConverterTypeUserSignature.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeUserSignature_lower(_ value: UserSignature) -> UnsafeMutableRawPointer { + return FfiConverterTypeUserSignature.lower(value) +} + + + + + + +/** + * 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 + * ``` + */ +public protocol ValidatorExecutionTimeObservationProtocol: AnyObject, Sendable { + + func duration() -> TimeInterval + + func 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 + * ``` + */ +open class ValidatorExecutionTimeObservation: ValidatorExecutionTimeObservationProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_validatorexecutiontimeobservation(self.pointer, $0) } + } +public convenience init(validator: Bls12381PublicKey, duration: TimeInterval) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_validatorexecutiontimeobservation_new( + FfiConverterTypeBls12381PublicKey_lower(validator), + FfiConverterDuration.lower(duration),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_validatorexecutiontimeobservation(pointer, $0) } + } + + + + +open func duration() -> TimeInterval { + return try! FfiConverterDuration.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_validatorexecutiontimeobservation_duration(self.uniffiClonePointer(),$0 + ) +}) +} + +open func validator() -> Bls12381PublicKey { + return try! FfiConverterTypeBls12381PublicKey_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_validatorexecutiontimeobservation_validator(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeValidatorExecutionTimeObservation: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = ValidatorExecutionTimeObservation + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> ValidatorExecutionTimeObservation { + return ValidatorExecutionTimeObservation(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: ValidatorExecutionTimeObservation) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ValidatorExecutionTimeObservation { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: ValidatorExecutionTimeObservation, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeValidatorExecutionTimeObservation_lift(_ pointer: UnsafeMutableRawPointer) throws -> ValidatorExecutionTimeObservation { + return try FfiConverterTypeValidatorExecutionTimeObservation.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeValidatorExecutionTimeObservation_lower(_ value: ValidatorExecutionTimeObservation) -> UnsafeMutableRawPointer { + return FfiConverterTypeValidatorExecutionTimeObservation.lower(value) +} + + + + + + +/** + * 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 + * ``` + */ +public protocol VersionAssignmentProtocol: AnyObject, Sendable { + + func objectId() -> ObjectId + + func version() -> UInt64 + +} +/** + * 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 + * ``` + */ +open class VersionAssignment: VersionAssignmentProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_versionassignment(self.pointer, $0) } + } +public convenience init(objectId: ObjectId, version: UInt64) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_versionassignment_new( + FfiConverterTypeObjectId_lower(objectId), + FfiConverterUInt64.lower(version),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_versionassignment(pointer, $0) } + } + + + + +open func objectId() -> ObjectId { + return try! FfiConverterTypeObjectId_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_versionassignment_object_id(self.uniffiClonePointer(),$0 + ) +}) +} + +open func version() -> UInt64 { + return try! FfiConverterUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_versionassignment_version(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeVersionAssignment: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = VersionAssignment + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> VersionAssignment { + return VersionAssignment(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: VersionAssignment) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> VersionAssignment { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: VersionAssignment, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeVersionAssignment_lift(_ pointer: UnsafeMutableRawPointer) throws -> VersionAssignment { + return try FfiConverterTypeVersionAssignment.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeVersionAssignment_lower(_ value: VersionAssignment) -> UnsafeMutableRawPointer { + return FfiConverterTypeVersionAssignment.lower(value) +} + + + + + + +/** + * 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. + */ +public protocol ZkLoginAuthenticatorProtocol: AnyObject, Sendable { + + func inputs() -> ZkLoginInputs + + func maxEpoch() -> UInt64 + + func 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. + */ +open class ZkLoginAuthenticator: ZkLoginAuthenticatorProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_zkloginauthenticator(self.pointer, $0) } + } +public convenience init(inputs: ZkLoginInputs, maxEpoch: UInt64, signature: SimpleSignature) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_zkloginauthenticator_new( + FfiConverterTypeZkLoginInputs_lower(inputs), + FfiConverterUInt64.lower(maxEpoch), + FfiConverterTypeSimpleSignature_lower(signature),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_zkloginauthenticator(pointer, $0) } + } + + + + +open func inputs() -> ZkLoginInputs { + return try! FfiConverterTypeZkLoginInputs_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_zkloginauthenticator_inputs(self.uniffiClonePointer(),$0 + ) +}) +} + +open func maxEpoch() -> UInt64 { + return try! FfiConverterUInt64.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_zkloginauthenticator_max_epoch(self.uniffiClonePointer(),$0 + ) +}) +} + +open func signature() -> SimpleSignature { + return try! FfiConverterTypeSimpleSignature_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_zkloginauthenticator_signature(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeZkLoginAuthenticator: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = ZkLoginAuthenticator + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> ZkLoginAuthenticator { + return ZkLoginAuthenticator(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: ZkLoginAuthenticator) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ZkLoginAuthenticator { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: ZkLoginAuthenticator, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeZkLoginAuthenticator_lift(_ pointer: UnsafeMutableRawPointer) throws -> ZkLoginAuthenticator { + return try FfiConverterTypeZkLoginAuthenticator.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeZkLoginAuthenticator_lower(_ value: ZkLoginAuthenticator) -> UnsafeMutableRawPointer { + return FfiConverterTypeZkLoginAuthenticator.lower(value) +} + + + + + + +/** + * 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 + * ``` + */ +public protocol ZkLoginInputsProtocol: AnyObject, Sendable { + + func addressSeed() -> Bn254FieldElement + + func headerBase64() -> String + + func issBase64Details() -> ZkLoginClaim + + func proofPoints() -> ZkLoginProof + +} +/** + * 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 + * ``` + */ +open class ZkLoginInputs: ZkLoginInputsProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_zklogininputs(self.pointer, $0) } + } +public convenience init(proofPoints: ZkLoginProof, issBase64Details: ZkLoginClaim, headerBase64: String, addressSeed: Bn254FieldElement) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_zklogininputs_new( + FfiConverterTypeZkLoginProof_lower(proofPoints), + FfiConverterTypeZkLoginClaim_lower(issBase64Details), + FfiConverterString.lower(headerBase64), + FfiConverterTypeBn254FieldElement_lower(addressSeed),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_zklogininputs(pointer, $0) } + } + + + + +open func addressSeed() -> Bn254FieldElement { + return try! FfiConverterTypeBn254FieldElement_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_zklogininputs_address_seed(self.uniffiClonePointer(),$0 + ) +}) +} + +open func headerBase64() -> String { + return try! FfiConverterString.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_zklogininputs_header_base64(self.uniffiClonePointer(),$0 + ) +}) +} + +open func issBase64Details() -> ZkLoginClaim { + return try! FfiConverterTypeZkLoginClaim_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_zklogininputs_iss_base64_details(self.uniffiClonePointer(),$0 + ) +}) +} + +open func proofPoints() -> ZkLoginProof { + return try! FfiConverterTypeZkLoginProof_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_zklogininputs_proof_points(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeZkLoginInputs: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = ZkLoginInputs + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> ZkLoginInputs { + return ZkLoginInputs(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: ZkLoginInputs) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ZkLoginInputs { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: ZkLoginInputs, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeZkLoginInputs_lift(_ pointer: UnsafeMutableRawPointer) throws -> ZkLoginInputs { + return try FfiConverterTypeZkLoginInputs.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeZkLoginInputs_lower(_ value: ZkLoginInputs) -> UnsafeMutableRawPointer { + return FfiConverterTypeZkLoginInputs.lower(value) +} + + + + + + +/** + * 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 + * ``` + */ +public protocol ZkLoginProofProtocol: AnyObject, Sendable { + + func a() -> CircomG1 + + func b() -> CircomG2 + + func 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 + * ``` + */ +open class ZkLoginProof: ZkLoginProofProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_zkloginproof(self.pointer, $0) } + } +public convenience init(a: CircomG1, b: CircomG2, c: CircomG1) { + let pointer = + try! rustCall() { + uniffi_iota_sdk_ffi_fn_constructor_zkloginproof_new( + FfiConverterTypeCircomG1_lower(a), + FfiConverterTypeCircomG2_lower(b), + FfiConverterTypeCircomG1_lower(c),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_zkloginproof(pointer, $0) } + } + + + + +open func a() -> CircomG1 { + return try! FfiConverterTypeCircomG1_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_zkloginproof_a(self.uniffiClonePointer(),$0 + ) +}) +} + +open func b() -> CircomG2 { + return try! FfiConverterTypeCircomG2_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_zkloginproof_b(self.uniffiClonePointer(),$0 + ) +}) +} + +open func c() -> CircomG1 { + return try! FfiConverterTypeCircomG1_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_zkloginproof_c(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeZkLoginProof: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = ZkLoginProof + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> ZkLoginProof { + return ZkLoginProof(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: ZkLoginProof) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ZkLoginProof { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: ZkLoginProof, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeZkLoginProof_lift(_ pointer: UnsafeMutableRawPointer) throws -> ZkLoginProof { + return try FfiConverterTypeZkLoginProof.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeZkLoginProof_lower(_ value: ZkLoginProof) -> UnsafeMutableRawPointer { + return FfiConverterTypeZkLoginProof.lower(value) +} + + + + + + +/** + * 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) + * ``` + * + * [`Address`]: crate::Address + */ +public protocol ZkLoginPublicIdentifierProtocol: AnyObject, Sendable { + + func addressSeed() -> Bn254FieldElement + + func 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) + * ``` + * + * [`Address`]: crate::Address + */ +open class ZkLoginPublicIdentifier: ZkLoginPublicIdentifierProtocol, @unchecked Sendable { + fileprivate let pointer: UnsafeMutableRawPointer! + + /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public struct NoPointer { + public init() {} + } + + // TODO: We'd like this to be `private` but for Swifty reasons, + // we can't implement `FfiConverter` without making this `required` and we can't + // make it `required` without making it `public`. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) { + self.pointer = pointer + } + + // This constructor can be used to instantiate a fake object. + // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject]. + // + // - Warning: + // Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash. +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public init(noPointer: NoPointer) { + self.pointer = nil + } + +#if swift(>=5.8) + @_documentation(visibility: private) +#endif + public func uniffiClonePointer() -> UnsafeMutableRawPointer { + return try! rustCall { uniffi_iota_sdk_ffi_fn_clone_zkloginpublicidentifier(self.pointer, $0) } + } +public convenience init(iss: String, addressSeed: Bn254FieldElement)throws { + let pointer = + try rustCallWithError(FfiConverterTypeSdkFfiError_lift) { + uniffi_iota_sdk_ffi_fn_constructor_zkloginpublicidentifier_new( + FfiConverterString.lower(iss), + FfiConverterTypeBn254FieldElement_lower(addressSeed),$0 + ) +} + self.init(unsafeFromRawPointer: pointer) +} + + deinit { + guard let pointer = pointer else { + return + } + + try! rustCall { uniffi_iota_sdk_ffi_fn_free_zkloginpublicidentifier(pointer, $0) } + } + + + + +open func addressSeed() -> Bn254FieldElement { + return try! FfiConverterTypeBn254FieldElement_lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_zkloginpublicidentifier_address_seed(self.uniffiClonePointer(),$0 + ) +}) +} + +open func iss() -> String { + return try! FfiConverterString.lift(try! rustCall() { + uniffi_iota_sdk_ffi_fn_method_zkloginpublicidentifier_iss(self.uniffiClonePointer(),$0 + ) +}) +} + + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeZkLoginPublicIdentifier: FfiConverter { + + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = ZkLoginPublicIdentifier + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> ZkLoginPublicIdentifier { + return ZkLoginPublicIdentifier(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: ZkLoginPublicIdentifier) -> UnsafeMutableRawPointer { + return value.uniffiClonePointer() + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ZkLoginPublicIdentifier { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: ZkLoginPublicIdentifier, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeZkLoginPublicIdentifier_lift(_ pointer: UnsafeMutableRawPointer) throws -> ZkLoginPublicIdentifier { + return try FfiConverterTypeZkLoginPublicIdentifier.lift(pointer) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeZkLoginPublicIdentifier_lower(_ value: ZkLoginPublicIdentifier) -> UnsafeMutableRawPointer { + return FfiConverterTypeZkLoginPublicIdentifier.lower(value) +} + + + + +/** + * A new Jwk + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * active-jwk = jwk-id jwk u64 + * ``` + */ +public struct ActiveJwk { + /** + * Identifier used to uniquely identify a Jwk + */ + public var jwkId: JwkId + /** + * The Jwk + */ + public var jwk: Jwk + /** + * Most recent epoch in which the jwk was validated + */ + public var epoch: UInt64 + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Identifier used to uniquely identify a Jwk + */jwkId: JwkId, + /** + * The Jwk + */jwk: Jwk, + /** + * Most recent epoch in which the jwk was validated + */epoch: UInt64) { + self.jwkId = jwkId + self.jwk = jwk + self.epoch = epoch + } +} + +#if compiler(>=6) +extension ActiveJwk: Sendable {} +#endif + + +extension ActiveJwk: Equatable, Hashable { + public static func ==(lhs: ActiveJwk, rhs: ActiveJwk) -> Bool { + if lhs.jwkId != rhs.jwkId { + return false + } + if lhs.jwk != rhs.jwk { + return false + } + if lhs.epoch != rhs.epoch { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(jwkId) + hasher.combine(jwk) + hasher.combine(epoch) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeActiveJwk: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ActiveJwk { + return + try ActiveJwk( + jwkId: FfiConverterTypeJwkId.read(from: &buf), + jwk: FfiConverterTypeJwk.read(from: &buf), + epoch: FfiConverterUInt64.read(from: &buf) + ) + } + + public static func write(_ value: ActiveJwk, into buf: inout [UInt8]) { + FfiConverterTypeJwkId.write(value.jwkId, into: &buf) + FfiConverterTypeJwk.write(value.jwk, into: &buf) + FfiConverterUInt64.write(value.epoch, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeActiveJwk_lift(_ buf: RustBuffer) throws -> ActiveJwk { + return try FfiConverterTypeActiveJwk.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeActiveJwk_lower(_ value: ActiveJwk) -> RustBuffer { + return FfiConverterTypeActiveJwk.lower(value) +} + + +/** + * Expire old JWKs + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * authenticator-state-expire = u64 u64 + * ``` + */ +public struct AuthenticatorStateExpire { + /** + * Expire JWKs that have a lower epoch than this + */ + public var minEpoch: UInt64 + /** + * The initial version of the authenticator object that it was shared at. + */ + public var authenticatorObjInitialSharedVersion: UInt64 + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Expire JWKs that have a lower epoch than this + */minEpoch: UInt64, + /** + * The initial version of the authenticator object that it was shared at. + */authenticatorObjInitialSharedVersion: UInt64) { + self.minEpoch = minEpoch + self.authenticatorObjInitialSharedVersion = authenticatorObjInitialSharedVersion + } +} + +#if compiler(>=6) +extension AuthenticatorStateExpire: Sendable {} +#endif + + +extension AuthenticatorStateExpire: Equatable, Hashable { + public static func ==(lhs: AuthenticatorStateExpire, rhs: AuthenticatorStateExpire) -> Bool { + if lhs.minEpoch != rhs.minEpoch { + return false + } + if lhs.authenticatorObjInitialSharedVersion != rhs.authenticatorObjInitialSharedVersion { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(minEpoch) + hasher.combine(authenticatorObjInitialSharedVersion) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeAuthenticatorStateExpire: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AuthenticatorStateExpire { + return + try AuthenticatorStateExpire( + minEpoch: FfiConverterUInt64.read(from: &buf), + authenticatorObjInitialSharedVersion: FfiConverterUInt64.read(from: &buf) + ) + } + + public static func write(_ value: AuthenticatorStateExpire, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.minEpoch, into: &buf) + FfiConverterUInt64.write(value.authenticatorObjInitialSharedVersion, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAuthenticatorStateExpire_lift(_ buf: RustBuffer) throws -> AuthenticatorStateExpire { + return try FfiConverterTypeAuthenticatorStateExpire.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAuthenticatorStateExpire_lower(_ value: AuthenticatorStateExpire) -> RustBuffer { + return FfiConverterTypeAuthenticatorStateExpire.lower(value) +} + + +/** + * 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 + * ``` + */ +public struct AuthenticatorStateUpdateV1 { + /** + * Epoch of the authenticator state update transaction + */ + public var epoch: UInt64 + /** + * Consensus round of the authenticator state update + */ + public var round: UInt64 + /** + * newly active jwks + */ + public var newActiveJwks: [ActiveJwk] + public var authenticatorObjInitialSharedVersion: UInt64 + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Epoch of the authenticator state update transaction + */epoch: UInt64, + /** + * Consensus round of the authenticator state update + */round: UInt64, + /** + * newly active jwks + */newActiveJwks: [ActiveJwk], authenticatorObjInitialSharedVersion: UInt64) { + self.epoch = epoch + self.round = round + self.newActiveJwks = newActiveJwks + self.authenticatorObjInitialSharedVersion = authenticatorObjInitialSharedVersion + } +} + +#if compiler(>=6) +extension AuthenticatorStateUpdateV1: Sendable {} +#endif + + +extension AuthenticatorStateUpdateV1: Equatable, Hashable { + public static func ==(lhs: AuthenticatorStateUpdateV1, rhs: AuthenticatorStateUpdateV1) -> Bool { + if lhs.epoch != rhs.epoch { + return false + } + if lhs.round != rhs.round { + return false + } + if lhs.newActiveJwks != rhs.newActiveJwks { + return false + } + if lhs.authenticatorObjInitialSharedVersion != rhs.authenticatorObjInitialSharedVersion { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(epoch) + hasher.combine(round) + hasher.combine(newActiveJwks) + hasher.combine(authenticatorObjInitialSharedVersion) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeAuthenticatorStateUpdateV1: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AuthenticatorStateUpdateV1 { + return + try AuthenticatorStateUpdateV1( + epoch: FfiConverterUInt64.read(from: &buf), + round: FfiConverterUInt64.read(from: &buf), + newActiveJwks: FfiConverterSequenceTypeActiveJwk.read(from: &buf), + authenticatorObjInitialSharedVersion: FfiConverterUInt64.read(from: &buf) + ) + } + + public static func write(_ value: AuthenticatorStateUpdateV1, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.epoch, into: &buf) + FfiConverterUInt64.write(value.round, into: &buf) + FfiConverterSequenceTypeActiveJwk.write(value.newActiveJwks, into: &buf) + FfiConverterUInt64.write(value.authenticatorObjInitialSharedVersion, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAuthenticatorStateUpdateV1_lift(_ buf: RustBuffer) throws -> AuthenticatorStateUpdateV1 { + return try FfiConverterTypeAuthenticatorStateUpdateV1.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeAuthenticatorStateUpdateV1_lower(_ value: AuthenticatorStateUpdateV1) -> RustBuffer { + return FfiConverterTypeAuthenticatorStateUpdateV1.lower(value) +} + + +/** + * 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 + * ``` + */ +public struct ChangedObject { + /** + * Id of the object + */ + public var objectId: ObjectId + /** + * State of the object in the store prior to this transaction. + */ + public var inputState: ObjectIn + /** + * State of the object in the store after this transaction. + */ + public var 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. + */ + public var idOperation: IdOperation + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * 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) { + self.objectId = objectId + self.inputState = inputState + self.outputState = outputState + self.idOperation = idOperation + } +} + +#if compiler(>=6) +extension ChangedObject: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeChangedObject: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ChangedObject { + return + try ChangedObject( + objectId: FfiConverterTypeObjectId.read(from: &buf), + inputState: FfiConverterTypeObjectIn.read(from: &buf), + outputState: FfiConverterTypeObjectOut.read(from: &buf), + idOperation: FfiConverterTypeIdOperation.read(from: &buf) + ) + } + + public static func write(_ value: ChangedObject, into buf: inout [UInt8]) { + FfiConverterTypeObjectId.write(value.objectId, into: &buf) + FfiConverterTypeObjectIn.write(value.inputState, into: &buf) + FfiConverterTypeObjectOut.write(value.outputState, into: &buf) + FfiConverterTypeIdOperation.write(value.idOperation, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeChangedObject_lift(_ buf: RustBuffer) throws -> ChangedObject { + return try FfiConverterTypeChangedObject.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeChangedObject_lower(_ value: ChangedObject) -> RustBuffer { + return FfiConverterTypeChangedObject.lower(value) +} + + +/** + * 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 + * ``` + */ +public struct CheckpointSummary { + /** + * Epoch that this checkpoint belongs to. + */ + public var epoch: UInt64 + /** + * The height of this checkpoint. + */ + public var sequenceNumber: UInt64 + /** + * Total number of transactions committed since genesis, including those in + * this checkpoint. + */ + public var networkTotalTransactions: UInt64 + /** + * The hash of the `CheckpointContents` for this checkpoint. + */ + public var contentDigest: CheckpointContentsDigest + /** + * The hash of the previous `CheckpointSummary`. + * + * This will be only be `None` for the first, or genesis checkpoint. + */ + public var previousDigest: CheckpointDigest? + /** + * The running total gas costs of all transactions included in the current + * epoch so far until this checkpoint. + */ + public var epochRollingGasCostSummary: GasCostSummary + /** + * 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 + */ + public var timestampMs: UInt64 + /** + * Commitments to checkpoint-specific state. + */ + public var checkpointCommitments: [CheckpointCommitment] + /** + * Extra data only present in the final checkpoint of an epoch. + */ + public var endOfEpochData: EndOfEpochData? + /** + * 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. + */ + public var versionSpecificData: Data + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Epoch that this checkpoint belongs to. + */epoch: UInt64, + /** + * The height of this checkpoint. + */sequenceNumber: UInt64, + /** + * Total number of transactions committed since genesis, including those in + * this checkpoint. + */networkTotalTransactions: UInt64, + /** + * The hash of the `CheckpointContents` for this checkpoint. + */contentDigest: CheckpointContentsDigest, + /** + * The hash of the previous `CheckpointSummary`. + * + * This will be only be `None` for the first, or genesis checkpoint. + */previousDigest: CheckpointDigest?, + /** + * The running total gas costs of all transactions included in the current + * epoch so far until this checkpoint. + */epochRollingGasCostSummary: GasCostSummary, + /** + * 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: UInt64, + /** + * Commitments to checkpoint-specific state. + */checkpointCommitments: [CheckpointCommitment], + /** + * Extra data only present in the final checkpoint of an epoch. + */endOfEpochData: EndOfEpochData?, + /** + * 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: Data) { + self.epoch = epoch + self.sequenceNumber = sequenceNumber + self.networkTotalTransactions = networkTotalTransactions + self.contentDigest = contentDigest + self.previousDigest = previousDigest + self.epochRollingGasCostSummary = epochRollingGasCostSummary + self.timestampMs = timestampMs + self.checkpointCommitments = checkpointCommitments + self.endOfEpochData = endOfEpochData + self.versionSpecificData = versionSpecificData + } +} + +#if compiler(>=6) +extension CheckpointSummary: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeCheckpointSummary: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CheckpointSummary { + return + try CheckpointSummary( + epoch: FfiConverterUInt64.read(from: &buf), + sequenceNumber: FfiConverterUInt64.read(from: &buf), + networkTotalTransactions: FfiConverterUInt64.read(from: &buf), + contentDigest: FfiConverterTypeCheckpointContentsDigest.read(from: &buf), + previousDigest: FfiConverterOptionTypeCheckpointDigest.read(from: &buf), + epochRollingGasCostSummary: FfiConverterTypeGasCostSummary.read(from: &buf), + timestampMs: FfiConverterUInt64.read(from: &buf), + checkpointCommitments: FfiConverterSequenceTypeCheckpointCommitment.read(from: &buf), + endOfEpochData: FfiConverterOptionTypeEndOfEpochData.read(from: &buf), + versionSpecificData: FfiConverterData.read(from: &buf) + ) + } + + public static func write(_ value: CheckpointSummary, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.epoch, into: &buf) + FfiConverterUInt64.write(value.sequenceNumber, into: &buf) + FfiConverterUInt64.write(value.networkTotalTransactions, into: &buf) + FfiConverterTypeCheckpointContentsDigest.write(value.contentDigest, into: &buf) + FfiConverterOptionTypeCheckpointDigest.write(value.previousDigest, into: &buf) + FfiConverterTypeGasCostSummary.write(value.epochRollingGasCostSummary, into: &buf) + FfiConverterUInt64.write(value.timestampMs, into: &buf) + FfiConverterSequenceTypeCheckpointCommitment.write(value.checkpointCommitments, into: &buf) + FfiConverterOptionTypeEndOfEpochData.write(value.endOfEpochData, into: &buf) + FfiConverterData.write(value.versionSpecificData, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeCheckpointSummary_lift(_ buf: RustBuffer) throws -> CheckpointSummary { + return try FfiConverterTypeCheckpointSummary.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeCheckpointSummary_lower(_ value: CheckpointSummary) -> RustBuffer { + return FfiConverterTypeCheckpointSummary.lower(value) +} + + +/** + * A page of items returned by the GraphQL server. + */ +public struct CheckpointSummaryPage { + /** + * Information about the page, such as the cursor and whether there are + * more pages. + */ + public var pageInfo: PageInfo + /** + * The data returned by the server. + */ + public var data: [CheckpointSummary] + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Information about the page, such as the cursor and whether there are + * more pages. + */pageInfo: PageInfo, + /** + * The data returned by the server. + */data: [CheckpointSummary]) { + self.pageInfo = pageInfo + self.data = data + } +} + +#if compiler(>=6) +extension CheckpointSummaryPage: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeCheckpointSummaryPage: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CheckpointSummaryPage { + return + try CheckpointSummaryPage( + pageInfo: FfiConverterTypePageInfo.read(from: &buf), + data: FfiConverterSequenceTypeCheckpointSummary.read(from: &buf) + ) + } + + public static func write(_ value: CheckpointSummaryPage, into buf: inout [UInt8]) { + FfiConverterTypePageInfo.write(value.pageInfo, into: &buf) + FfiConverterSequenceTypeCheckpointSummary.write(value.data, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeCheckpointSummaryPage_lift(_ buf: RustBuffer) throws -> CheckpointSummaryPage { + return try FfiConverterTypeCheckpointSummaryPage.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeCheckpointSummaryPage_lower(_ value: CheckpointSummaryPage) -> RustBuffer { + return FfiConverterTypeCheckpointSummaryPage.lower(value) +} + + +/** + * The coin metadata associated with the given coin type. + */ +public struct CoinMetadata { + /** + * The number of decimal places used to represent the token. + */ + public var decimals: Int32? + /** + * Optional description of the token, provided by the creator of the token. + */ + public var description: String? + /** + * Icon URL of the coin. + */ + public var iconUrl: String? + /** + * Full, official name of the token. + */ + public var name: String? + /** + * The token's identifying abbreviation. + */ + public var symbol: String? + /** + * The overall quantity of tokens that will be issued. + */ + public var supply: BigInt? + /** + * Version of the token. + */ + public var version: UInt64 + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * The number of decimal places used to represent the token. + */decimals: Int32? = nil, + /** + * Optional description of the token, provided by the creator of the token. + */description: String? = nil, + /** + * Icon URL of the coin. + */iconUrl: String? = nil, + /** + * Full, official name of the token. + */name: String? = nil, + /** + * The token's identifying abbreviation. + */symbol: String? = nil, + /** + * The overall quantity of tokens that will be issued. + */supply: BigInt? = nil, + /** + * Version of the token. + */version: UInt64) { + self.decimals = decimals + self.description = description + self.iconUrl = iconUrl + self.name = name + self.symbol = symbol + self.supply = supply + self.version = version + } +} + +#if compiler(>=6) +extension CoinMetadata: Sendable {} +#endif + + +extension CoinMetadata: Equatable, Hashable { + public static func ==(lhs: CoinMetadata, rhs: CoinMetadata) -> Bool { + if lhs.decimals != rhs.decimals { + return false + } + if lhs.description != rhs.description { + return false + } + if lhs.iconUrl != rhs.iconUrl { + return false + } + if lhs.name != rhs.name { + return false + } + if lhs.symbol != rhs.symbol { + return false + } + if lhs.supply != rhs.supply { + return false + } + if lhs.version != rhs.version { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(decimals) + hasher.combine(description) + hasher.combine(iconUrl) + hasher.combine(name) + hasher.combine(symbol) + hasher.combine(supply) + hasher.combine(version) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeCoinMetadata: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CoinMetadata { + return + try CoinMetadata( + decimals: FfiConverterOptionInt32.read(from: &buf), + description: FfiConverterOptionString.read(from: &buf), + iconUrl: FfiConverterOptionString.read(from: &buf), + name: FfiConverterOptionString.read(from: &buf), + symbol: FfiConverterOptionString.read(from: &buf), + supply: FfiConverterOptionTypeBigInt.read(from: &buf), + version: FfiConverterUInt64.read(from: &buf) + ) + } + + public static func write(_ value: CoinMetadata, into buf: inout [UInt8]) { + FfiConverterOptionInt32.write(value.decimals, into: &buf) + FfiConverterOptionString.write(value.description, into: &buf) + FfiConverterOptionString.write(value.iconUrl, into: &buf) + FfiConverterOptionString.write(value.name, into: &buf) + FfiConverterOptionString.write(value.symbol, into: &buf) + FfiConverterOptionTypeBigInt.write(value.supply, into: &buf) + FfiConverterUInt64.write(value.version, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeCoinMetadata_lift(_ buf: RustBuffer) throws -> CoinMetadata { + return try FfiConverterTypeCoinMetadata.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeCoinMetadata_lower(_ value: CoinMetadata) -> RustBuffer { + return FfiConverterTypeCoinMetadata.lower(value) +} + + +/** + * A page of items returned by the GraphQL server. + */ +public struct CoinPage { + /** + * Information about the page, such as the cursor and whether there are + * more pages. + */ + public var pageInfo: PageInfo + /** + * The data returned by the server. + */ + public var data: [Coin] + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Information about the page, such as the cursor and whether there are + * more pages. + */pageInfo: PageInfo, + /** + * The data returned by the server. + */data: [Coin]) { + self.pageInfo = pageInfo + self.data = data + } +} + +#if compiler(>=6) +extension CoinPage: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeCoinPage: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CoinPage { + return + try CoinPage( + pageInfo: FfiConverterTypePageInfo.read(from: &buf), + data: FfiConverterSequenceTypeCoin.read(from: &buf) + ) + } + + public static func write(_ value: CoinPage, into buf: inout [UInt8]) { + FfiConverterTypePageInfo.write(value.pageInfo, into: &buf) + FfiConverterSequenceTypeCoin.write(value.data, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeCoinPage_lift(_ buf: RustBuffer) throws -> CoinPage { + return try FfiConverterTypeCoinPage.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeCoinPage_lower(_ value: CoinPage) -> RustBuffer { + return FfiConverterTypeCoinPage.lower(value) +} + + +/** + * The result of a dry run, which includes the effects of the transaction and + * any errors that may have occurred. + */ +public struct DryRunResult { + public var effects: TransactionEffects? + public var error: String? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(effects: TransactionEffects?, error: String?) { + self.effects = effects + self.error = error + } +} + +#if compiler(>=6) +extension DryRunResult: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeDryRunResult: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> DryRunResult { + return + try DryRunResult( + effects: FfiConverterOptionTypeTransactionEffects.read(from: &buf), + error: FfiConverterOptionString.read(from: &buf) + ) + } + + public static func write(_ value: DryRunResult, into buf: inout [UInt8]) { + FfiConverterOptionTypeTransactionEffects.write(value.effects, into: &buf) + FfiConverterOptionString.write(value.error, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeDryRunResult_lift(_ buf: RustBuffer) throws -> DryRunResult { + return try FfiConverterTypeDryRunResult.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeDryRunResult_lower(_ value: DryRunResult) -> RustBuffer { + return FfiConverterTypeDryRunResult.lower(value) +} + + +/** + * The name part of a dynamic field, including its type, bcs, and json + * representation. + */ +public struct DynamicFieldName { + /** + * The type name of this dynamic field name + */ + public var typeTag: TypeTag + /** + * The bcs bytes of this dynamic field name + */ + public var bcs: Data + /** + * The json representation of the dynamic field name + */ + public var json: Value? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * The type name of this dynamic field name + */typeTag: TypeTag, + /** + * The bcs bytes of this dynamic field name + */bcs: Data, + /** + * The json representation of the dynamic field name + */json: Value?) { + self.typeTag = typeTag + self.bcs = bcs + self.json = json + } +} + +#if compiler(>=6) +extension DynamicFieldName: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeDynamicFieldName: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> DynamicFieldName { + return + try DynamicFieldName( + typeTag: FfiConverterTypeTypeTag.read(from: &buf), + bcs: FfiConverterData.read(from: &buf), + json: FfiConverterOptionTypeValue.read(from: &buf) + ) + } + + public static func write(_ value: DynamicFieldName, into buf: inout [UInt8]) { + FfiConverterTypeTypeTag.write(value.typeTag, into: &buf) + FfiConverterData.write(value.bcs, into: &buf) + FfiConverterOptionTypeValue.write(value.json, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeDynamicFieldName_lift(_ buf: RustBuffer) throws -> DynamicFieldName { + return try FfiConverterTypeDynamicFieldName.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeDynamicFieldName_lower(_ value: DynamicFieldName) -> RustBuffer { + return FfiConverterTypeDynamicFieldName.lower(value) +} + + +/** + * The output of a dynamic field query, that includes the name, value, and + * value's json representation. + */ +public struct DynamicFieldOutput { + /** + * The name of the dynamic field + */ + public var name: DynamicFieldName + /** + * The dynamic field value typename and bcs + */ + public var value: DynamicFieldValue? + /** + * The json representation of the dynamic field value object + */ + public var valueAsJson: Value? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * 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: Value?) { + self.name = name + self.value = value + self.valueAsJson = valueAsJson + } +} + +#if compiler(>=6) +extension DynamicFieldOutput: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeDynamicFieldOutput: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> DynamicFieldOutput { + return + try DynamicFieldOutput( + name: FfiConverterTypeDynamicFieldName.read(from: &buf), + value: FfiConverterOptionTypeDynamicFieldValue.read(from: &buf), + valueAsJson: FfiConverterOptionTypeValue.read(from: &buf) + ) + } + + public static func write(_ value: DynamicFieldOutput, into buf: inout [UInt8]) { + FfiConverterTypeDynamicFieldName.write(value.name, into: &buf) + FfiConverterOptionTypeDynamicFieldValue.write(value.value, into: &buf) + FfiConverterOptionTypeValue.write(value.valueAsJson, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeDynamicFieldOutput_lift(_ buf: RustBuffer) throws -> DynamicFieldOutput { + return try FfiConverterTypeDynamicFieldOutput.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeDynamicFieldOutput_lower(_ value: DynamicFieldOutput) -> RustBuffer { + return FfiConverterTypeDynamicFieldOutput.lower(value) +} + + +/** + * A page of items returned by the GraphQL server. + */ +public struct DynamicFieldOutputPage { + /** + * Information about the page, such as the cursor and whether there are + * more pages. + */ + public var pageInfo: PageInfo + /** + * The data returned by the server. + */ + public var data: [DynamicFieldOutput] + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Information about the page, such as the cursor and whether there are + * more pages. + */pageInfo: PageInfo, + /** + * The data returned by the server. + */data: [DynamicFieldOutput]) { + self.pageInfo = pageInfo + self.data = data + } +} + +#if compiler(>=6) +extension DynamicFieldOutputPage: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeDynamicFieldOutputPage: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> DynamicFieldOutputPage { + return + try DynamicFieldOutputPage( + pageInfo: FfiConverterTypePageInfo.read(from: &buf), + data: FfiConverterSequenceTypeDynamicFieldOutput.read(from: &buf) + ) + } + + public static func write(_ value: DynamicFieldOutputPage, into buf: inout [UInt8]) { + FfiConverterTypePageInfo.write(value.pageInfo, into: &buf) + FfiConverterSequenceTypeDynamicFieldOutput.write(value.data, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeDynamicFieldOutputPage_lift(_ buf: RustBuffer) throws -> DynamicFieldOutputPage { + return try FfiConverterTypeDynamicFieldOutputPage.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeDynamicFieldOutputPage_lower(_ value: DynamicFieldOutputPage) -> RustBuffer { + return FfiConverterTypeDynamicFieldOutputPage.lower(value) +} + + +/** + * The value part of a dynamic field. + */ +public struct DynamicFieldValue { + public var typeTag: TypeTag + public var bcs: Data + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(typeTag: TypeTag, bcs: Data) { + self.typeTag = typeTag + self.bcs = bcs + } +} + +#if compiler(>=6) +extension DynamicFieldValue: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeDynamicFieldValue: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> DynamicFieldValue { + return + try DynamicFieldValue( + typeTag: FfiConverterTypeTypeTag.read(from: &buf), + bcs: FfiConverterData.read(from: &buf) + ) + } + + public static func write(_ value: DynamicFieldValue, into buf: inout [UInt8]) { + FfiConverterTypeTypeTag.write(value.typeTag, into: &buf) + FfiConverterData.write(value.bcs, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeDynamicFieldValue_lift(_ buf: RustBuffer) throws -> DynamicFieldValue { + return try FfiConverterTypeDynamicFieldValue.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeDynamicFieldValue_lower(_ value: DynamicFieldValue) -> RustBuffer { + return FfiConverterTypeDynamicFieldValue.lower(value) +} + + +public struct EndOfEpochData { + public var nextEpochCommittee: [ValidatorCommitteeMember] + public var nextEpochProtocolVersion: UInt64 + public var epochCommitments: [CheckpointCommitment] + public var epochSupplyChange: Int64 + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(nextEpochCommittee: [ValidatorCommitteeMember], nextEpochProtocolVersion: UInt64, epochCommitments: [CheckpointCommitment], epochSupplyChange: Int64) { + self.nextEpochCommittee = nextEpochCommittee + self.nextEpochProtocolVersion = nextEpochProtocolVersion + self.epochCommitments = epochCommitments + self.epochSupplyChange = epochSupplyChange + } +} + +#if compiler(>=6) +extension EndOfEpochData: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeEndOfEpochData: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> EndOfEpochData { + return + try EndOfEpochData( + nextEpochCommittee: FfiConverterSequenceTypeValidatorCommitteeMember.read(from: &buf), + nextEpochProtocolVersion: FfiConverterUInt64.read(from: &buf), + epochCommitments: FfiConverterSequenceTypeCheckpointCommitment.read(from: &buf), + epochSupplyChange: FfiConverterInt64.read(from: &buf) + ) + } + + public static func write(_ value: EndOfEpochData, into buf: inout [UInt8]) { + FfiConverterSequenceTypeValidatorCommitteeMember.write(value.nextEpochCommittee, into: &buf) + FfiConverterUInt64.write(value.nextEpochProtocolVersion, into: &buf) + FfiConverterSequenceTypeCheckpointCommitment.write(value.epochCommitments, into: &buf) + FfiConverterInt64.write(value.epochSupplyChange, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeEndOfEpochData_lift(_ buf: RustBuffer) throws -> EndOfEpochData { + return try FfiConverterTypeEndOfEpochData.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeEndOfEpochData_lower(_ value: EndOfEpochData) -> RustBuffer { + return FfiConverterTypeEndOfEpochData.lower(value) +} + + +/** + * A page of items returned by the GraphQL server. + */ +public struct EpochPage { + /** + * Information about the page, such as the cursor and whether there are + * more pages. + */ + public var pageInfo: PageInfo + /** + * The data returned by the server. + */ + public var data: [Epoch] + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Information about the page, such as the cursor and whether there are + * more pages. + */pageInfo: PageInfo, + /** + * The data returned by the server. + */data: [Epoch]) { + self.pageInfo = pageInfo + self.data = data + } +} + +#if compiler(>=6) +extension EpochPage: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeEpochPage: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> EpochPage { + return + try EpochPage( + pageInfo: FfiConverterTypePageInfo.read(from: &buf), + data: FfiConverterSequenceTypeEpoch.read(from: &buf) + ) + } + + public static func write(_ value: EpochPage, into buf: inout [UInt8]) { + FfiConverterTypePageInfo.write(value.pageInfo, into: &buf) + FfiConverterSequenceTypeEpoch.write(value.data, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeEpochPage_lift(_ buf: RustBuffer) throws -> EpochPage { + return try FfiConverterTypeEpochPage.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeEpochPage_lower(_ value: EpochPage) -> RustBuffer { + return FfiConverterTypeEpochPage.lower(value) +} + + +/** + * 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 + * ``` + */ +public struct Event { + /** + * Package id of the top-level function invoked by a MoveCall command which + * triggered this event to be emitted. + */ + public var packageId: ObjectId + /** + * Module name of the top-level function invoked by a MoveCall command + * which triggered this event to be emitted. + */ + public var module: String + /** + * Address of the account that sent the transaction where this event was + * emitted. + */ + public var sender: Address + /** + * The type of the event emitted + */ + public var type: String + /** + * BCS serialized bytes of the event + */ + public var contents: Data + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * 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: Data) { + self.packageId = packageId + self.module = module + self.sender = sender + self.type = type + self.contents = contents + } +} + +#if compiler(>=6) +extension Event: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeEvent: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Event { + return + try Event( + packageId: FfiConverterTypeObjectId.read(from: &buf), + module: FfiConverterString.read(from: &buf), + sender: FfiConverterTypeAddress.read(from: &buf), + type: FfiConverterString.read(from: &buf), + contents: FfiConverterData.read(from: &buf) + ) + } + + public static func write(_ value: Event, into buf: inout [UInt8]) { + FfiConverterTypeObjectId.write(value.packageId, into: &buf) + FfiConverterString.write(value.module, into: &buf) + FfiConverterTypeAddress.write(value.sender, into: &buf) + FfiConverterString.write(value.type, into: &buf) + FfiConverterData.write(value.contents, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeEvent_lift(_ buf: RustBuffer) throws -> Event { + return try FfiConverterTypeEvent.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeEvent_lower(_ value: Event) -> RustBuffer { + return FfiConverterTypeEvent.lower(value) +} + + +public struct EventFilter { + public var emittingModule: String? + public var eventType: String? + public var sender: Address? + public var transactionDigest: String? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(emittingModule: String? = nil, eventType: String? = nil, sender: Address? = nil, transactionDigest: String? = nil) { + self.emittingModule = emittingModule + self.eventType = eventType + self.sender = sender + self.transactionDigest = transactionDigest + } +} + +#if compiler(>=6) +extension EventFilter: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeEventFilter: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> EventFilter { + return + try EventFilter( + emittingModule: FfiConverterOptionString.read(from: &buf), + eventType: FfiConverterOptionString.read(from: &buf), + sender: FfiConverterOptionTypeAddress.read(from: &buf), + transactionDigest: FfiConverterOptionString.read(from: &buf) + ) + } + + public static func write(_ value: EventFilter, into buf: inout [UInt8]) { + FfiConverterOptionString.write(value.emittingModule, into: &buf) + FfiConverterOptionString.write(value.eventType, into: &buf) + FfiConverterOptionTypeAddress.write(value.sender, into: &buf) + FfiConverterOptionString.write(value.transactionDigest, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeEventFilter_lift(_ buf: RustBuffer) throws -> EventFilter { + return try FfiConverterTypeEventFilter.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeEventFilter_lower(_ value: EventFilter) -> RustBuffer { + return FfiConverterTypeEventFilter.lower(value) +} + + +/** + * A page of items returned by the GraphQL server. + */ +public struct EventPage { + /** + * Information about the page, such as the cursor and whether there are + * more pages. + */ + public var pageInfo: PageInfo + /** + * The data returned by the server. + */ + public var data: [Event] + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Information about the page, such as the cursor and whether there are + * more pages. + */pageInfo: PageInfo, + /** + * The data returned by the server. + */data: [Event]) { + self.pageInfo = pageInfo + self.data = data + } +} + +#if compiler(>=6) +extension EventPage: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeEventPage: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> EventPage { + return + try EventPage( + pageInfo: FfiConverterTypePageInfo.read(from: &buf), + data: FfiConverterSequenceTypeEvent.read(from: &buf) + ) + } + + public static func write(_ value: EventPage, into buf: inout [UInt8]) { + FfiConverterTypePageInfo.write(value.pageInfo, into: &buf) + FfiConverterSequenceTypeEvent.write(value.data, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeEventPage_lift(_ buf: RustBuffer) throws -> EventPage { + return try FfiConverterTypeEventPage.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeEventPage_lower(_ value: EventPage) -> RustBuffer { + return FfiConverterTypeEventPage.lower(value) +} + + +public struct GqlAddress { + public var address: Address + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(address: Address) { + self.address = address + } +} + +#if compiler(>=6) +extension GqlAddress: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeGQLAddress: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> GqlAddress { + return + try GqlAddress( + address: FfiConverterTypeAddress.read(from: &buf) + ) + } + + public static func write(_ value: GqlAddress, into buf: inout [UInt8]) { + FfiConverterTypeAddress.write(value.address, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeGQLAddress_lift(_ buf: RustBuffer) throws -> GqlAddress { + return try FfiConverterTypeGQLAddress.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeGQLAddress_lower(_ value: GqlAddress) -> RustBuffer { + return FfiConverterTypeGQLAddress.lower(value) +} + + +public struct GasCostSummary { + public var computationCost: UInt64 + public var computationCostBurned: UInt64 + public var storageCost: UInt64 + public var storageRebate: UInt64 + public var nonRefundableStorageFee: UInt64 + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(computationCost: UInt64, computationCostBurned: UInt64, storageCost: UInt64, storageRebate: UInt64, nonRefundableStorageFee: UInt64) { + self.computationCost = computationCost + self.computationCostBurned = computationCostBurned + self.storageCost = storageCost + self.storageRebate = storageRebate + self.nonRefundableStorageFee = nonRefundableStorageFee + } +} + +#if compiler(>=6) +extension GasCostSummary: Sendable {} +#endif + + +extension GasCostSummary: Equatable, Hashable { + public static func ==(lhs: GasCostSummary, rhs: GasCostSummary) -> Bool { + if lhs.computationCost != rhs.computationCost { + return false + } + if lhs.computationCostBurned != rhs.computationCostBurned { + return false + } + if lhs.storageCost != rhs.storageCost { + return false + } + if lhs.storageRebate != rhs.storageRebate { + return false + } + if lhs.nonRefundableStorageFee != rhs.nonRefundableStorageFee { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(computationCost) + hasher.combine(computationCostBurned) + hasher.combine(storageCost) + hasher.combine(storageRebate) + hasher.combine(nonRefundableStorageFee) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeGasCostSummary: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> GasCostSummary { + return + try GasCostSummary( + computationCost: FfiConverterUInt64.read(from: &buf), + computationCostBurned: FfiConverterUInt64.read(from: &buf), + storageCost: FfiConverterUInt64.read(from: &buf), + storageRebate: FfiConverterUInt64.read(from: &buf), + nonRefundableStorageFee: FfiConverterUInt64.read(from: &buf) + ) + } + + public static func write(_ value: GasCostSummary, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.computationCost, into: &buf) + FfiConverterUInt64.write(value.computationCostBurned, into: &buf) + FfiConverterUInt64.write(value.storageCost, into: &buf) + FfiConverterUInt64.write(value.storageRebate, into: &buf) + FfiConverterUInt64.write(value.nonRefundableStorageFee, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeGasCostSummary_lift(_ buf: RustBuffer) throws -> GasCostSummary { + return try FfiConverterTypeGasCostSummary.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeGasCostSummary_lower(_ value: GasCostSummary) -> RustBuffer { + return FfiConverterTypeGasCostSummary.lower(value) +} + + +/** + * 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 + * ``` + */ +public struct GasPayment { + public var objects: [ObjectReference] + /** + * Owner of the gas objects, either the transaction sender or a sponsor + */ + public var 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) + */ + public var price: UInt64 + /** + * Total budget willing to spend for the execution of a transaction + */ + public var budget: UInt64 + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(objects: [ObjectReference], + /** + * 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: UInt64, + /** + * Total budget willing to spend for the execution of a transaction + */budget: UInt64) { + self.objects = objects + self.owner = owner + self.price = price + self.budget = budget + } +} + +#if compiler(>=6) +extension GasPayment: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeGasPayment: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> GasPayment { + return + try GasPayment( + objects: FfiConverterSequenceTypeObjectReference.read(from: &buf), + owner: FfiConverterTypeAddress.read(from: &buf), + price: FfiConverterUInt64.read(from: &buf), + budget: FfiConverterUInt64.read(from: &buf) + ) + } + + public static func write(_ value: GasPayment, into buf: inout [UInt8]) { + FfiConverterSequenceTypeObjectReference.write(value.objects, into: &buf) + FfiConverterTypeAddress.write(value.owner, into: &buf) + FfiConverterUInt64.write(value.price, into: &buf) + FfiConverterUInt64.write(value.budget, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeGasPayment_lift(_ buf: RustBuffer) throws -> GasPayment { + return try FfiConverterTypeGasPayment.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeGasPayment_lower(_ value: GasPayment) -> RustBuffer { + return FfiConverterTypeGasPayment.lower(value) +} + + +/** + * 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 + * ``` + */ +public struct Jwk { + /** + * Key type parameter, + */ + public var kty: String + /** + * RSA public exponent, + */ + public var e: String + /** + * RSA modulus, + */ + public var n: String + /** + * Algorithm parameter, + */ + public var alg: String + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Key type parameter, + */kty: String, + /** + * RSA public exponent, + */e: String, + /** + * RSA modulus, + */n: String, + /** + * Algorithm parameter, + */alg: String) { + self.kty = kty + self.e = e + self.n = n + self.alg = alg + } +} + +#if compiler(>=6) +extension Jwk: Sendable {} +#endif + + +extension Jwk: Equatable, Hashable { + public static func ==(lhs: Jwk, rhs: Jwk) -> Bool { + if lhs.kty != rhs.kty { + return false + } + if lhs.e != rhs.e { + return false + } + if lhs.n != rhs.n { + return false + } + if lhs.alg != rhs.alg { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(kty) + hasher.combine(e) + hasher.combine(n) + hasher.combine(alg) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeJwk: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Jwk { + return + try Jwk( + kty: FfiConverterString.read(from: &buf), + e: FfiConverterString.read(from: &buf), + n: FfiConverterString.read(from: &buf), + alg: FfiConverterString.read(from: &buf) + ) + } + + public static func write(_ value: Jwk, into buf: inout [UInt8]) { + FfiConverterString.write(value.kty, into: &buf) + FfiConverterString.write(value.e, into: &buf) + FfiConverterString.write(value.n, into: &buf) + FfiConverterString.write(value.alg, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeJwk_lift(_ buf: RustBuffer) throws -> Jwk { + return try FfiConverterTypeJwk.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeJwk_lower(_ value: Jwk) -> RustBuffer { + return FfiConverterTypeJwk.lower(value) +} + + +/** + * 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 + * ``` + */ +public struct JwkId { + /** + * The issuer or identity of the OIDC provider. + */ + public var iss: String + /** + * A key id use to uniquely identify a key from an OIDC provider. + */ + public var kid: String + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * 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) { + self.iss = iss + self.kid = kid + } +} + +#if compiler(>=6) +extension JwkId: Sendable {} +#endif + + +extension JwkId: Equatable, Hashable { + public static func ==(lhs: JwkId, rhs: JwkId) -> Bool { + if lhs.iss != rhs.iss { + return false + } + if lhs.kid != rhs.kid { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(iss) + hasher.combine(kid) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeJwkId: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> JwkId { + return + try JwkId( + iss: FfiConverterString.read(from: &buf), + kid: FfiConverterString.read(from: &buf) + ) + } + + public static func write(_ value: JwkId, into buf: inout [UInt8]) { + FfiConverterString.write(value.iss, into: &buf) + FfiConverterString.write(value.kid, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeJwkId_lift(_ buf: RustBuffer) throws -> JwkId { + return try FfiConverterTypeJwkId.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeJwkId_lower(_ value: JwkId) -> RustBuffer { + return FfiConverterTypeJwkId.lower(value) +} + + +public struct MoveEnum { + public var abilities: [MoveAbility]? + public var name: String + public var typeParameters: [MoveStructTypeParameter]? + public var variants: [MoveEnumVariant]? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(abilities: [MoveAbility]? = nil, name: String, typeParameters: [MoveStructTypeParameter]? = nil, variants: [MoveEnumVariant]? = nil) { + self.abilities = abilities + self.name = name + self.typeParameters = typeParameters + self.variants = variants + } +} + +#if compiler(>=6) +extension MoveEnum: Sendable {} +#endif + + +extension MoveEnum: Equatable, Hashable { + public static func ==(lhs: MoveEnum, rhs: MoveEnum) -> Bool { + if lhs.abilities != rhs.abilities { + return false + } + if lhs.name != rhs.name { + return false + } + if lhs.typeParameters != rhs.typeParameters { + return false + } + if lhs.variants != rhs.variants { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(abilities) + hasher.combine(name) + hasher.combine(typeParameters) + hasher.combine(variants) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMoveEnum: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MoveEnum { + return + try MoveEnum( + abilities: FfiConverterOptionSequenceTypeMoveAbility.read(from: &buf), + name: FfiConverterString.read(from: &buf), + typeParameters: FfiConverterOptionSequenceTypeMoveStructTypeParameter.read(from: &buf), + variants: FfiConverterOptionSequenceTypeMoveEnumVariant.read(from: &buf) + ) + } + + public static func write(_ value: MoveEnum, into buf: inout [UInt8]) { + FfiConverterOptionSequenceTypeMoveAbility.write(value.abilities, into: &buf) + FfiConverterString.write(value.name, into: &buf) + FfiConverterOptionSequenceTypeMoveStructTypeParameter.write(value.typeParameters, into: &buf) + FfiConverterOptionSequenceTypeMoveEnumVariant.write(value.variants, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveEnum_lift(_ buf: RustBuffer) throws -> MoveEnum { + return try FfiConverterTypeMoveEnum.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveEnum_lower(_ value: MoveEnum) -> RustBuffer { + return FfiConverterTypeMoveEnum.lower(value) +} + + +public struct MoveEnumConnection { + public var nodes: [MoveEnum] + public var pageInfo: PageInfo + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(nodes: [MoveEnum], pageInfo: PageInfo) { + self.nodes = nodes + self.pageInfo = pageInfo + } +} + +#if compiler(>=6) +extension MoveEnumConnection: Sendable {} +#endif + + +extension MoveEnumConnection: Equatable, Hashable { + public static func ==(lhs: MoveEnumConnection, rhs: MoveEnumConnection) -> Bool { + if lhs.nodes != rhs.nodes { + return false + } + if lhs.pageInfo != rhs.pageInfo { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(nodes) + hasher.combine(pageInfo) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMoveEnumConnection: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MoveEnumConnection { + return + try MoveEnumConnection( + nodes: FfiConverterSequenceTypeMoveEnum.read(from: &buf), + pageInfo: FfiConverterTypePageInfo.read(from: &buf) + ) + } + + public static func write(_ value: MoveEnumConnection, into buf: inout [UInt8]) { + FfiConverterSequenceTypeMoveEnum.write(value.nodes, into: &buf) + FfiConverterTypePageInfo.write(value.pageInfo, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveEnumConnection_lift(_ buf: RustBuffer) throws -> MoveEnumConnection { + return try FfiConverterTypeMoveEnumConnection.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveEnumConnection_lower(_ value: MoveEnumConnection) -> RustBuffer { + return FfiConverterTypeMoveEnumConnection.lower(value) +} + + +public struct MoveEnumVariant { + public var fields: [MoveField]? + public var name: String + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(fields: [MoveField]?, name: String) { + self.fields = fields + self.name = name + } +} + +#if compiler(>=6) +extension MoveEnumVariant: Sendable {} +#endif + + +extension MoveEnumVariant: Equatable, Hashable { + public static func ==(lhs: MoveEnumVariant, rhs: MoveEnumVariant) -> Bool { + if lhs.fields != rhs.fields { + return false + } + if lhs.name != rhs.name { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(fields) + hasher.combine(name) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMoveEnumVariant: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MoveEnumVariant { + return + try MoveEnumVariant( + fields: FfiConverterOptionSequenceTypeMoveField.read(from: &buf), + name: FfiConverterString.read(from: &buf) + ) + } + + public static func write(_ value: MoveEnumVariant, into buf: inout [UInt8]) { + FfiConverterOptionSequenceTypeMoveField.write(value.fields, into: &buf) + FfiConverterString.write(value.name, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveEnumVariant_lift(_ buf: RustBuffer) throws -> MoveEnumVariant { + return try FfiConverterTypeMoveEnumVariant.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveEnumVariant_lower(_ value: MoveEnumVariant) -> RustBuffer { + return FfiConverterTypeMoveEnumVariant.lower(value) +} + + +public struct MoveField { + public var name: String + public var type: OpenMoveType? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(name: String, type: OpenMoveType?) { + self.name = name + self.type = type + } +} + +#if compiler(>=6) +extension MoveField: Sendable {} +#endif + + +extension MoveField: Equatable, Hashable { + public static func ==(lhs: MoveField, rhs: MoveField) -> Bool { + if lhs.name != rhs.name { + return false + } + if lhs.type != rhs.type { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(name) + hasher.combine(type) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMoveField: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MoveField { + return + try MoveField( + name: FfiConverterString.read(from: &buf), + type: FfiConverterOptionTypeOpenMoveType.read(from: &buf) + ) + } + + public static func write(_ value: MoveField, into buf: inout [UInt8]) { + FfiConverterString.write(value.name, into: &buf) + FfiConverterOptionTypeOpenMoveType.write(value.type, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveField_lift(_ buf: RustBuffer) throws -> MoveField { + return try FfiConverterTypeMoveField.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveField_lower(_ value: MoveField) -> RustBuffer { + return FfiConverterTypeMoveField.lower(value) +} + + +public struct MoveFunction { + public var isEntry: Bool? + public var name: String + public var parameters: [OpenMoveType]? + public var `return`: [OpenMoveType]? + public var typeParameters: [MoveFunctionTypeParameter]? + public var visibility: MoveVisibility? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(isEntry: Bool? = nil, name: String, parameters: [OpenMoveType]? = nil, `return`: [OpenMoveType]? = nil, typeParameters: [MoveFunctionTypeParameter]? = nil, visibility: MoveVisibility? = nil) { + self.isEntry = isEntry + self.name = name + self.parameters = parameters + self.`return` = `return` + self.typeParameters = typeParameters + self.visibility = visibility + } +} + +#if compiler(>=6) +extension MoveFunction: Sendable {} +#endif + + +extension MoveFunction: Equatable, Hashable { + public static func ==(lhs: MoveFunction, rhs: MoveFunction) -> Bool { + if lhs.isEntry != rhs.isEntry { + return false + } + if lhs.name != rhs.name { + return false + } + if lhs.parameters != rhs.parameters { + return false + } + if lhs.`return` != rhs.`return` { + return false + } + if lhs.typeParameters != rhs.typeParameters { + return false + } + if lhs.visibility != rhs.visibility { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(isEntry) + hasher.combine(name) + hasher.combine(parameters) + hasher.combine(`return`) + hasher.combine(typeParameters) + hasher.combine(visibility) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMoveFunction: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MoveFunction { + return + try MoveFunction( + isEntry: FfiConverterOptionBool.read(from: &buf), + name: FfiConverterString.read(from: &buf), + parameters: FfiConverterOptionSequenceTypeOpenMoveType.read(from: &buf), + return: FfiConverterOptionSequenceTypeOpenMoveType.read(from: &buf), + typeParameters: FfiConverterOptionSequenceTypeMoveFunctionTypeParameter.read(from: &buf), + visibility: FfiConverterOptionTypeMoveVisibility.read(from: &buf) + ) + } + + public static func write(_ value: MoveFunction, into buf: inout [UInt8]) { + FfiConverterOptionBool.write(value.isEntry, into: &buf) + FfiConverterString.write(value.name, into: &buf) + FfiConverterOptionSequenceTypeOpenMoveType.write(value.parameters, into: &buf) + FfiConverterOptionSequenceTypeOpenMoveType.write(value.`return`, into: &buf) + FfiConverterOptionSequenceTypeMoveFunctionTypeParameter.write(value.typeParameters, into: &buf) + FfiConverterOptionTypeMoveVisibility.write(value.visibility, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveFunction_lift(_ buf: RustBuffer) throws -> MoveFunction { + return try FfiConverterTypeMoveFunction.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveFunction_lower(_ value: MoveFunction) -> RustBuffer { + return FfiConverterTypeMoveFunction.lower(value) +} + + +public struct MoveFunctionConnection { + public var nodes: [MoveFunction] + public var pageInfo: PageInfo + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(nodes: [MoveFunction], pageInfo: PageInfo) { + self.nodes = nodes + self.pageInfo = pageInfo + } +} + +#if compiler(>=6) +extension MoveFunctionConnection: Sendable {} +#endif + + +extension MoveFunctionConnection: Equatable, Hashable { + public static func ==(lhs: MoveFunctionConnection, rhs: MoveFunctionConnection) -> Bool { + if lhs.nodes != rhs.nodes { + return false + } + if lhs.pageInfo != rhs.pageInfo { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(nodes) + hasher.combine(pageInfo) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMoveFunctionConnection: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MoveFunctionConnection { + return + try MoveFunctionConnection( + nodes: FfiConverterSequenceTypeMoveFunction.read(from: &buf), + pageInfo: FfiConverterTypePageInfo.read(from: &buf) + ) + } + + public static func write(_ value: MoveFunctionConnection, into buf: inout [UInt8]) { + FfiConverterSequenceTypeMoveFunction.write(value.nodes, into: &buf) + FfiConverterTypePageInfo.write(value.pageInfo, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveFunctionConnection_lift(_ buf: RustBuffer) throws -> MoveFunctionConnection { + return try FfiConverterTypeMoveFunctionConnection.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveFunctionConnection_lower(_ value: MoveFunctionConnection) -> RustBuffer { + return FfiConverterTypeMoveFunctionConnection.lower(value) +} + + +public struct MoveFunctionTypeParameter { + public var constraints: [MoveAbility] + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(constraints: [MoveAbility]) { + self.constraints = constraints + } +} + +#if compiler(>=6) +extension MoveFunctionTypeParameter: Sendable {} +#endif + + +extension MoveFunctionTypeParameter: Equatable, Hashable { + public static func ==(lhs: MoveFunctionTypeParameter, rhs: MoveFunctionTypeParameter) -> Bool { + if lhs.constraints != rhs.constraints { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(constraints) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMoveFunctionTypeParameter: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MoveFunctionTypeParameter { + return + try MoveFunctionTypeParameter( + constraints: FfiConverterSequenceTypeMoveAbility.read(from: &buf) + ) + } + + public static func write(_ value: MoveFunctionTypeParameter, into buf: inout [UInt8]) { + FfiConverterSequenceTypeMoveAbility.write(value.constraints, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveFunctionTypeParameter_lift(_ buf: RustBuffer) throws -> MoveFunctionTypeParameter { + return try FfiConverterTypeMoveFunctionTypeParameter.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveFunctionTypeParameter_lower(_ value: MoveFunctionTypeParameter) -> RustBuffer { + return FfiConverterTypeMoveFunctionTypeParameter.lower(value) +} + + +/** + * 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) + * ``` + */ +public struct MoveLocation { + /** + * The package id + */ + public var package: ObjectId + /** + * The module name + */ + public var module: String + /** + * The function index + */ + public var function: UInt16 + /** + * Index into the code stream for a jump. The offset is relative to the + * beginning of the instruction stream. + */ + public var instruction: UInt16 + /** + * The name of the function if available + */ + public var functionName: String? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * The package id + */package: ObjectId, + /** + * The module name + */module: String, + /** + * The function index + */function: UInt16, + /** + * Index into the code stream for a jump. The offset is relative to the + * beginning of the instruction stream. + */instruction: UInt16, + /** + * The name of the function if available + */functionName: String?) { + self.package = package + self.module = module + self.function = function + self.instruction = instruction + self.functionName = functionName + } +} + +#if compiler(>=6) +extension MoveLocation: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMoveLocation: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MoveLocation { + return + try MoveLocation( + package: FfiConverterTypeObjectId.read(from: &buf), + module: FfiConverterString.read(from: &buf), + function: FfiConverterUInt16.read(from: &buf), + instruction: FfiConverterUInt16.read(from: &buf), + functionName: FfiConverterOptionString.read(from: &buf) + ) + } + + public static func write(_ value: MoveLocation, into buf: inout [UInt8]) { + FfiConverterTypeObjectId.write(value.package, into: &buf) + FfiConverterString.write(value.module, into: &buf) + FfiConverterUInt16.write(value.function, into: &buf) + FfiConverterUInt16.write(value.instruction, into: &buf) + FfiConverterOptionString.write(value.functionName, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveLocation_lift(_ buf: RustBuffer) throws -> MoveLocation { + return try FfiConverterTypeMoveLocation.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveLocation_lower(_ value: MoveLocation) -> RustBuffer { + return FfiConverterTypeMoveLocation.lower(value) +} + + +public struct MoveModule { + public var fileFormatVersion: Int32 + public var enums: MoveEnumConnection? + public var friends: MoveModuleConnection + public var functions: MoveFunctionConnection? + public var structs: MoveStructConnection? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(fileFormatVersion: Int32, enums: MoveEnumConnection? = nil, friends: MoveModuleConnection, functions: MoveFunctionConnection? = nil, structs: MoveStructConnection? = nil) { + self.fileFormatVersion = fileFormatVersion + self.enums = enums + self.friends = friends + self.functions = functions + self.structs = structs + } +} + +#if compiler(>=6) +extension MoveModule: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMoveModule: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MoveModule { + return + try MoveModule( + fileFormatVersion: FfiConverterInt32.read(from: &buf), + enums: FfiConverterOptionTypeMoveEnumConnection.read(from: &buf), + friends: FfiConverterTypeMoveModuleConnection.read(from: &buf), + functions: FfiConverterOptionTypeMoveFunctionConnection.read(from: &buf), + structs: FfiConverterOptionTypeMoveStructConnection.read(from: &buf) + ) + } + + public static func write(_ value: MoveModule, into buf: inout [UInt8]) { + FfiConverterInt32.write(value.fileFormatVersion, into: &buf) + FfiConverterOptionTypeMoveEnumConnection.write(value.enums, into: &buf) + FfiConverterTypeMoveModuleConnection.write(value.friends, into: &buf) + FfiConverterOptionTypeMoveFunctionConnection.write(value.functions, into: &buf) + FfiConverterOptionTypeMoveStructConnection.write(value.structs, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveModule_lift(_ buf: RustBuffer) throws -> MoveModule { + return try FfiConverterTypeMoveModule.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveModule_lower(_ value: MoveModule) -> RustBuffer { + return FfiConverterTypeMoveModule.lower(value) +} + + +public struct MoveModuleConnection { + public var nodes: [MoveModuleQuery] + public var pageInfo: PageInfo + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(nodes: [MoveModuleQuery], pageInfo: PageInfo) { + self.nodes = nodes + self.pageInfo = pageInfo + } +} + +#if compiler(>=6) +extension MoveModuleConnection: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMoveModuleConnection: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MoveModuleConnection { + return + try MoveModuleConnection( + nodes: FfiConverterSequenceTypeMoveModuleQuery.read(from: &buf), + pageInfo: FfiConverterTypePageInfo.read(from: &buf) + ) + } + + public static func write(_ value: MoveModuleConnection, into buf: inout [UInt8]) { + FfiConverterSequenceTypeMoveModuleQuery.write(value.nodes, into: &buf) + FfiConverterTypePageInfo.write(value.pageInfo, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveModuleConnection_lift(_ buf: RustBuffer) throws -> MoveModuleConnection { + return try FfiConverterTypeMoveModuleConnection.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveModuleConnection_lower(_ value: MoveModuleConnection) -> RustBuffer { + return FfiConverterTypeMoveModuleConnection.lower(value) +} + + +public struct MoveModuleQuery { + public var package: MovePackageQuery + public var name: String + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(package: MovePackageQuery, name: String) { + self.package = package + self.name = name + } +} + +#if compiler(>=6) +extension MoveModuleQuery: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMoveModuleQuery: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MoveModuleQuery { + return + try MoveModuleQuery( + package: FfiConverterTypeMovePackageQuery.read(from: &buf), + name: FfiConverterString.read(from: &buf) + ) + } + + public static func write(_ value: MoveModuleQuery, into buf: inout [UInt8]) { + FfiConverterTypeMovePackageQuery.write(value.package, into: &buf) + FfiConverterString.write(value.name, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveModuleQuery_lift(_ buf: RustBuffer) throws -> MoveModuleQuery { + return try FfiConverterTypeMoveModuleQuery.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveModuleQuery_lower(_ value: MoveModuleQuery) -> RustBuffer { + return FfiConverterTypeMoveModuleQuery.lower(value) +} + + +public struct MoveObject { + public var bcs: Base64? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(bcs: Base64? = nil) { + self.bcs = bcs + } +} + +#if compiler(>=6) +extension MoveObject: Sendable {} +#endif + + +extension MoveObject: Equatable, Hashable { + public static func ==(lhs: MoveObject, rhs: MoveObject) -> Bool { + if lhs.bcs != rhs.bcs { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(bcs) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMoveObject: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MoveObject { + return + try MoveObject( + bcs: FfiConverterOptionTypeBase64.read(from: &buf) + ) + } + + public static func write(_ value: MoveObject, into buf: inout [UInt8]) { + FfiConverterOptionTypeBase64.write(value.bcs, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveObject_lift(_ buf: RustBuffer) throws -> MoveObject { + return try FfiConverterTypeMoveObject.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveObject_lower(_ value: MoveObject) -> RustBuffer { + return FfiConverterTypeMoveObject.lower(value) +} + + +/** + * A page of items returned by the GraphQL server. + */ +public struct MovePackagePage { + /** + * Information about the page, such as the cursor and whether there are + * more pages. + */ + public var pageInfo: PageInfo + /** + * The data returned by the server. + */ + public var data: [MovePackage] + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Information about the page, such as the cursor and whether there are + * more pages. + */pageInfo: PageInfo, + /** + * The data returned by the server. + */data: [MovePackage]) { + self.pageInfo = pageInfo + self.data = data + } +} + +#if compiler(>=6) +extension MovePackagePage: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMovePackagePage: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MovePackagePage { + return + try MovePackagePage( + pageInfo: FfiConverterTypePageInfo.read(from: &buf), + data: FfiConverterSequenceTypeMovePackage.read(from: &buf) + ) + } + + public static func write(_ value: MovePackagePage, into buf: inout [UInt8]) { + FfiConverterTypePageInfo.write(value.pageInfo, into: &buf) + FfiConverterSequenceTypeMovePackage.write(value.data, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMovePackagePage_lift(_ buf: RustBuffer) throws -> MovePackagePage { + return try FfiConverterTypeMovePackagePage.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMovePackagePage_lower(_ value: MovePackagePage) -> RustBuffer { + return FfiConverterTypeMovePackagePage.lower(value) +} + + +public struct MovePackageQuery { + public var address: Address + public var bcs: Base64? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(address: Address, bcs: Base64?) { + self.address = address + self.bcs = bcs + } +} + +#if compiler(>=6) +extension MovePackageQuery: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMovePackageQuery: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MovePackageQuery { + return + try MovePackageQuery( + address: FfiConverterTypeAddress.read(from: &buf), + bcs: FfiConverterOptionTypeBase64.read(from: &buf) + ) + } + + public static func write(_ value: MovePackageQuery, into buf: inout [UInt8]) { + FfiConverterTypeAddress.write(value.address, into: &buf) + FfiConverterOptionTypeBase64.write(value.bcs, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMovePackageQuery_lift(_ buf: RustBuffer) throws -> MovePackageQuery { + return try FfiConverterTypeMovePackageQuery.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMovePackageQuery_lower(_ value: MovePackageQuery) -> RustBuffer { + return FfiConverterTypeMovePackageQuery.lower(value) +} + + +/** + * 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 + * ``` + */ +public struct MoveStruct { + /** + * The type of this object + */ + public var 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 + */ + public var version: UInt64 + /** + * BCS bytes of a Move struct value + */ + public var contents: Data + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * 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: UInt64, + /** + * BCS bytes of a Move struct value + */contents: Data) { + self.structType = structType + self.version = version + self.contents = contents + } +} + +#if compiler(>=6) +extension MoveStruct: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMoveStruct: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MoveStruct { + return + try MoveStruct( + structType: FfiConverterTypeStructTag.read(from: &buf), + version: FfiConverterUInt64.read(from: &buf), + contents: FfiConverterData.read(from: &buf) + ) + } + + public static func write(_ value: MoveStruct, into buf: inout [UInt8]) { + FfiConverterTypeStructTag.write(value.structType, into: &buf) + FfiConverterUInt64.write(value.version, into: &buf) + FfiConverterData.write(value.contents, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveStruct_lift(_ buf: RustBuffer) throws -> MoveStruct { + return try FfiConverterTypeMoveStruct.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveStruct_lower(_ value: MoveStruct) -> RustBuffer { + return FfiConverterTypeMoveStruct.lower(value) +} + + +public struct MoveStructConnection { + public var pageInfo: PageInfo + public var nodes: [MoveStructQuery] + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(pageInfo: PageInfo, nodes: [MoveStructQuery]) { + self.pageInfo = pageInfo + self.nodes = nodes + } +} + +#if compiler(>=6) +extension MoveStructConnection: Sendable {} +#endif + + +extension MoveStructConnection: Equatable, Hashable { + public static func ==(lhs: MoveStructConnection, rhs: MoveStructConnection) -> Bool { + if lhs.pageInfo != rhs.pageInfo { + return false + } + if lhs.nodes != rhs.nodes { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(pageInfo) + hasher.combine(nodes) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMoveStructConnection: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MoveStructConnection { + return + try MoveStructConnection( + pageInfo: FfiConverterTypePageInfo.read(from: &buf), + nodes: FfiConverterSequenceTypeMoveStructQuery.read(from: &buf) + ) + } + + public static func write(_ value: MoveStructConnection, into buf: inout [UInt8]) { + FfiConverterTypePageInfo.write(value.pageInfo, into: &buf) + FfiConverterSequenceTypeMoveStructQuery.write(value.nodes, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveStructConnection_lift(_ buf: RustBuffer) throws -> MoveStructConnection { + return try FfiConverterTypeMoveStructConnection.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveStructConnection_lower(_ value: MoveStructConnection) -> RustBuffer { + return FfiConverterTypeMoveStructConnection.lower(value) +} + + +public struct MoveStructQuery { + public var abilities: [MoveAbility]? + public var name: String + public var fields: [MoveField]? + public var typeParameters: [MoveStructTypeParameter]? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(abilities: [MoveAbility]?, name: String, fields: [MoveField]?, typeParameters: [MoveStructTypeParameter]?) { + self.abilities = abilities + self.name = name + self.fields = fields + self.typeParameters = typeParameters + } +} + +#if compiler(>=6) +extension MoveStructQuery: Sendable {} +#endif + + +extension MoveStructQuery: Equatable, Hashable { + public static func ==(lhs: MoveStructQuery, rhs: MoveStructQuery) -> Bool { + if lhs.abilities != rhs.abilities { + return false + } + if lhs.name != rhs.name { + return false + } + if lhs.fields != rhs.fields { + return false + } + if lhs.typeParameters != rhs.typeParameters { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(abilities) + hasher.combine(name) + hasher.combine(fields) + hasher.combine(typeParameters) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMoveStructQuery: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MoveStructQuery { + return + try MoveStructQuery( + abilities: FfiConverterOptionSequenceTypeMoveAbility.read(from: &buf), + name: FfiConverterString.read(from: &buf), + fields: FfiConverterOptionSequenceTypeMoveField.read(from: &buf), + typeParameters: FfiConverterOptionSequenceTypeMoveStructTypeParameter.read(from: &buf) + ) + } + + public static func write(_ value: MoveStructQuery, into buf: inout [UInt8]) { + FfiConverterOptionSequenceTypeMoveAbility.write(value.abilities, into: &buf) + FfiConverterString.write(value.name, into: &buf) + FfiConverterOptionSequenceTypeMoveField.write(value.fields, into: &buf) + FfiConverterOptionSequenceTypeMoveStructTypeParameter.write(value.typeParameters, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveStructQuery_lift(_ buf: RustBuffer) throws -> MoveStructQuery { + return try FfiConverterTypeMoveStructQuery.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveStructQuery_lower(_ value: MoveStructQuery) -> RustBuffer { + return FfiConverterTypeMoveStructQuery.lower(value) +} + + +public struct MoveStructTypeParameter { + public var constraints: [MoveAbility] + public var isPhantom: Bool + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(constraints: [MoveAbility], isPhantom: Bool) { + self.constraints = constraints + self.isPhantom = isPhantom + } +} + +#if compiler(>=6) +extension MoveStructTypeParameter: Sendable {} +#endif + + +extension MoveStructTypeParameter: Equatable, Hashable { + public static func ==(lhs: MoveStructTypeParameter, rhs: MoveStructTypeParameter) -> Bool { + if lhs.constraints != rhs.constraints { + return false + } + if lhs.isPhantom != rhs.isPhantom { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(constraints) + hasher.combine(isPhantom) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMoveStructTypeParameter: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MoveStructTypeParameter { + return + try MoveStructTypeParameter( + constraints: FfiConverterSequenceTypeMoveAbility.read(from: &buf), + isPhantom: FfiConverterBool.read(from: &buf) + ) + } + + public static func write(_ value: MoveStructTypeParameter, into buf: inout [UInt8]) { + FfiConverterSequenceTypeMoveAbility.write(value.constraints, into: &buf) + FfiConverterBool.write(value.isPhantom, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveStructTypeParameter_lift(_ buf: RustBuffer) throws -> MoveStructTypeParameter { + return try FfiConverterTypeMoveStructTypeParameter.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveStructTypeParameter_lower(_ value: MoveStructTypeParameter) -> RustBuffer { + return FfiConverterTypeMoveStructTypeParameter.lower(value) +} + + +public struct ObjectFilter { + public var typeTag: String? + public var owner: Address? + public var objectIds: [ObjectId]? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(typeTag: String?, owner: Address?, objectIds: [ObjectId]?) { + self.typeTag = typeTag + self.owner = owner + self.objectIds = objectIds + } +} + +#if compiler(>=6) +extension ObjectFilter: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeObjectFilter: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ObjectFilter { + return + try ObjectFilter( + typeTag: FfiConverterOptionString.read(from: &buf), + owner: FfiConverterOptionTypeAddress.read(from: &buf), + objectIds: FfiConverterOptionSequenceTypeObjectId.read(from: &buf) + ) + } + + public static func write(_ value: ObjectFilter, into buf: inout [UInt8]) { + FfiConverterOptionString.write(value.typeTag, into: &buf) + FfiConverterOptionTypeAddress.write(value.owner, into: &buf) + FfiConverterOptionSequenceTypeObjectId.write(value.objectIds, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeObjectFilter_lift(_ buf: RustBuffer) throws -> ObjectFilter { + return try FfiConverterTypeObjectFilter.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeObjectFilter_lower(_ value: ObjectFilter) -> RustBuffer { + return FfiConverterTypeObjectFilter.lower(value) +} + + +/** + * A page of items returned by the GraphQL server. + */ +public struct ObjectPage { + /** + * Information about the page, such as the cursor and whether there are + * more pages. + */ + public var pageInfo: PageInfo + /** + * The data returned by the server. + */ + public var data: [Object] + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Information about the page, such as the cursor and whether there are + * more pages. + */pageInfo: PageInfo, + /** + * The data returned by the server. + */data: [Object]) { + self.pageInfo = pageInfo + self.data = data + } +} + +#if compiler(>=6) +extension ObjectPage: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeObjectPage: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ObjectPage { + return + try ObjectPage( + pageInfo: FfiConverterTypePageInfo.read(from: &buf), + data: FfiConverterSequenceTypeObject.read(from: &buf) + ) + } + + public static func write(_ value: ObjectPage, into buf: inout [UInt8]) { + FfiConverterTypePageInfo.write(value.pageInfo, into: &buf) + FfiConverterSequenceTypeObject.write(value.data, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeObjectPage_lift(_ buf: RustBuffer) throws -> ObjectPage { + return try FfiConverterTypeObjectPage.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeObjectPage_lower(_ value: ObjectPage) -> RustBuffer { + return FfiConverterTypeObjectPage.lower(value) +} + + +public struct ObjectRef { + public var address: ObjectId + public var digest: String + public var version: UInt64 + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(address: ObjectId, digest: String, version: UInt64) { + self.address = address + self.digest = digest + self.version = version + } +} + +#if compiler(>=6) +extension ObjectRef: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeObjectRef: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ObjectRef { + return + try ObjectRef( + address: FfiConverterTypeObjectId.read(from: &buf), + digest: FfiConverterString.read(from: &buf), + version: FfiConverterUInt64.read(from: &buf) + ) + } + + public static func write(_ value: ObjectRef, into buf: inout [UInt8]) { + FfiConverterTypeObjectId.write(value.address, into: &buf) + FfiConverterString.write(value.digest, into: &buf) + FfiConverterUInt64.write(value.version, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeObjectRef_lift(_ buf: RustBuffer) throws -> ObjectRef { + return try FfiConverterTypeObjectRef.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeObjectRef_lower(_ value: ObjectRef) -> RustBuffer { + return FfiConverterTypeObjectRef.lower(value) +} + + +/** + * 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 + * ``` + */ +public struct ObjectReference { + public var objectId: ObjectId + public var version: UInt64 + public var digest: ObjectDigest + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(objectId: ObjectId, version: UInt64, digest: ObjectDigest) { + self.objectId = objectId + self.version = version + self.digest = digest + } +} + +#if compiler(>=6) +extension ObjectReference: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeObjectReference: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ObjectReference { + return + try ObjectReference( + objectId: FfiConverterTypeObjectId.read(from: &buf), + version: FfiConverterUInt64.read(from: &buf), + digest: FfiConverterTypeObjectDigest.read(from: &buf) + ) + } + + public static func write(_ value: ObjectReference, into buf: inout [UInt8]) { + FfiConverterTypeObjectId.write(value.objectId, into: &buf) + FfiConverterUInt64.write(value.version, into: &buf) + FfiConverterTypeObjectDigest.write(value.digest, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeObjectReference_lift(_ buf: RustBuffer) throws -> ObjectReference { + return try FfiConverterTypeObjectReference.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeObjectReference_lower(_ value: ObjectReference) -> RustBuffer { + return FfiConverterTypeObjectReference.lower(value) +} + + +public struct OpenMoveType { + public var repr: String + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(repr: String) { + self.repr = repr + } +} + +#if compiler(>=6) +extension OpenMoveType: Sendable {} +#endif + + +extension OpenMoveType: Equatable, Hashable { + public static func ==(lhs: OpenMoveType, rhs: OpenMoveType) -> Bool { + if lhs.repr != rhs.repr { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(repr) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeOpenMoveType: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> OpenMoveType { + return + try OpenMoveType( + repr: FfiConverterString.read(from: &buf) + ) + } + + public static func write(_ value: OpenMoveType, into buf: inout [UInt8]) { + FfiConverterString.write(value.repr, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeOpenMoveType_lift(_ buf: RustBuffer) throws -> OpenMoveType { + return try FfiConverterTypeOpenMoveType.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeOpenMoveType_lower(_ value: OpenMoveType) -> RustBuffer { + return FfiConverterTypeOpenMoveType.lower(value) +} + + +/** + * Information about pagination in a connection. + */ +public struct PageInfo { + /** + * When paginating backwards, are there more items? + */ + public var hasPreviousPage: Bool + /** + * Are there more items when paginating forwards? + */ + public var hasNextPage: Bool + /** + * When paginating backwards, the cursor to continue. + */ + public var startCursor: String? + /** + * When paginating forwards, the cursor to continue. + */ + public var endCursor: String? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * When paginating backwards, are there more items? + */hasPreviousPage: Bool, + /** + * Are there more items when paginating forwards? + */hasNextPage: Bool, + /** + * When paginating backwards, the cursor to continue. + */startCursor: String? = nil, + /** + * When paginating forwards, the cursor to continue. + */endCursor: String? = nil) { + self.hasPreviousPage = hasPreviousPage + self.hasNextPage = hasNextPage + self.startCursor = startCursor + self.endCursor = endCursor + } +} + +#if compiler(>=6) +extension PageInfo: Sendable {} +#endif + + +extension PageInfo: Equatable, Hashable { + public static func ==(lhs: PageInfo, rhs: PageInfo) -> Bool { + if lhs.hasPreviousPage != rhs.hasPreviousPage { + return false + } + if lhs.hasNextPage != rhs.hasNextPage { + return false + } + if lhs.startCursor != rhs.startCursor { + return false + } + if lhs.endCursor != rhs.endCursor { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(hasPreviousPage) + hasher.combine(hasNextPage) + hasher.combine(startCursor) + hasher.combine(endCursor) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypePageInfo: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PageInfo { + return + try PageInfo( + hasPreviousPage: FfiConverterBool.read(from: &buf), + hasNextPage: FfiConverterBool.read(from: &buf), + startCursor: FfiConverterOptionString.read(from: &buf), + endCursor: FfiConverterOptionString.read(from: &buf) + ) + } + + public static func write(_ value: PageInfo, into buf: inout [UInt8]) { + FfiConverterBool.write(value.hasPreviousPage, into: &buf) + FfiConverterBool.write(value.hasNextPage, into: &buf) + FfiConverterOptionString.write(value.startCursor, into: &buf) + FfiConverterOptionString.write(value.endCursor, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypePageInfo_lift(_ buf: RustBuffer) throws -> PageInfo { + return try FfiConverterTypePageInfo.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypePageInfo_lower(_ value: PageInfo) -> RustBuffer { + return FfiConverterTypePageInfo.lower(value) +} + + +/** + * Pagination options for querying the GraphQL server. It defaults to forward + * pagination with the GraphQL server's max page size. + */ +public struct PaginationFilter { + /** + * The direction of pagination. + */ + public var direction: Direction + /** + * An opaque cursor used for pagination. + */ + public var 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. + */ + public var limit: Int32? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * The direction of pagination. + */direction: Direction, + /** + * An opaque cursor used for pagination. + */cursor: String? = nil, + /** + * The maximum number of items to return. If this is omitted, it will + * lazily query the service configuration for the max page size. + */limit: Int32? = nil) { + self.direction = direction + self.cursor = cursor + self.limit = limit + } +} + +#if compiler(>=6) +extension PaginationFilter: Sendable {} +#endif + + +extension PaginationFilter: Equatable, Hashable { + public static func ==(lhs: PaginationFilter, rhs: PaginationFilter) -> Bool { + if lhs.direction != rhs.direction { + return false + } + if lhs.cursor != rhs.cursor { + return false + } + if lhs.limit != rhs.limit { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(direction) + hasher.combine(cursor) + hasher.combine(limit) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypePaginationFilter: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PaginationFilter { + return + try PaginationFilter( + direction: FfiConverterTypeDirection.read(from: &buf), + cursor: FfiConverterOptionString.read(from: &buf), + limit: FfiConverterOptionInt32.read(from: &buf) + ) + } + + public static func write(_ value: PaginationFilter, into buf: inout [UInt8]) { + FfiConverterTypeDirection.write(value.direction, into: &buf) + FfiConverterOptionString.write(value.cursor, into: &buf) + FfiConverterOptionInt32.write(value.limit, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypePaginationFilter_lift(_ buf: RustBuffer) throws -> PaginationFilter { + return try FfiConverterTypePaginationFilter.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypePaginationFilter_lower(_ value: PaginationFilter) -> RustBuffer { + return FfiConverterTypePaginationFilter.lower(value) +} + + +/** + * A key-value protocol configuration attribute. + */ +public struct ProtocolConfigAttr { + public var key: String + public var value: String? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(key: String, value: String?) { + self.key = key + self.value = value + } +} + +#if compiler(>=6) +extension ProtocolConfigAttr: Sendable {} +#endif + + +extension ProtocolConfigAttr: Equatable, Hashable { + public static func ==(lhs: ProtocolConfigAttr, rhs: ProtocolConfigAttr) -> Bool { + if lhs.key != rhs.key { + return false + } + if lhs.value != rhs.value { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(key) + hasher.combine(value) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeProtocolConfigAttr: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ProtocolConfigAttr { + return + try ProtocolConfigAttr( + key: FfiConverterString.read(from: &buf), + value: FfiConverterOptionString.read(from: &buf) + ) + } + + public static func write(_ value: ProtocolConfigAttr, into buf: inout [UInt8]) { + FfiConverterString.write(value.key, into: &buf) + FfiConverterOptionString.write(value.value, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeProtocolConfigAttr_lift(_ buf: RustBuffer) throws -> ProtocolConfigAttr { + return try FfiConverterTypeProtocolConfigAttr.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeProtocolConfigAttr_lower(_ value: ProtocolConfigAttr) -> RustBuffer { + return FfiConverterTypeProtocolConfigAttr.lower(value) +} + + +/** + * 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. + */ +public struct ProtocolConfigFeatureFlag { + public var key: String + public var value: Bool + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(key: String, value: Bool) { + self.key = key + self.value = value + } +} + +#if compiler(>=6) +extension ProtocolConfigFeatureFlag: Sendable {} +#endif + + +extension ProtocolConfigFeatureFlag: Equatable, Hashable { + public static func ==(lhs: ProtocolConfigFeatureFlag, rhs: ProtocolConfigFeatureFlag) -> Bool { + if lhs.key != rhs.key { + return false + } + if lhs.value != rhs.value { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(key) + hasher.combine(value) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeProtocolConfigFeatureFlag: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ProtocolConfigFeatureFlag { + return + try ProtocolConfigFeatureFlag( + key: FfiConverterString.read(from: &buf), + value: FfiConverterBool.read(from: &buf) + ) + } + + public static func write(_ value: ProtocolConfigFeatureFlag, into buf: inout [UInt8]) { + FfiConverterString.write(value.key, into: &buf) + FfiConverterBool.write(value.value, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeProtocolConfigFeatureFlag_lift(_ buf: RustBuffer) throws -> ProtocolConfigFeatureFlag { + return try FfiConverterTypeProtocolConfigFeatureFlag.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeProtocolConfigFeatureFlag_lower(_ value: ProtocolConfigFeatureFlag) -> RustBuffer { + return FfiConverterTypeProtocolConfigFeatureFlag.lower(value) +} + + +/** + * 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. + */ +public struct 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. + */ + public var protocolVersion: UInt64 + /** + * 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. + */ + public var featureFlags: [ProtocolConfigFeatureFlag] + /** + * 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. + */ + public var configs: [ProtocolConfigAttr] + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * 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: UInt64, + /** + * 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: [ProtocolConfigFeatureFlag], + /** + * 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: [ProtocolConfigAttr]) { + self.protocolVersion = protocolVersion + self.featureFlags = featureFlags + self.configs = configs + } +} + +#if compiler(>=6) +extension ProtocolConfigs: Sendable {} +#endif + + +extension ProtocolConfigs: Equatable, Hashable { + public static func ==(lhs: ProtocolConfigs, rhs: ProtocolConfigs) -> Bool { + if lhs.protocolVersion != rhs.protocolVersion { + return false + } + if lhs.featureFlags != rhs.featureFlags { + return false + } + if lhs.configs != rhs.configs { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(protocolVersion) + hasher.combine(featureFlags) + hasher.combine(configs) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeProtocolConfigs: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ProtocolConfigs { + return + try ProtocolConfigs( + protocolVersion: FfiConverterUInt64.read(from: &buf), + featureFlags: FfiConverterSequenceTypeProtocolConfigFeatureFlag.read(from: &buf), + configs: FfiConverterSequenceTypeProtocolConfigAttr.read(from: &buf) + ) + } + + public static func write(_ value: ProtocolConfigs, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.protocolVersion, into: &buf) + FfiConverterSequenceTypeProtocolConfigFeatureFlag.write(value.featureFlags, into: &buf) + FfiConverterSequenceTypeProtocolConfigAttr.write(value.configs, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeProtocolConfigs_lift(_ buf: RustBuffer) throws -> ProtocolConfigs { + return try FfiConverterTypeProtocolConfigs.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeProtocolConfigs_lower(_ value: ProtocolConfigs) -> RustBuffer { + return FfiConverterTypeProtocolConfigs.lower(value) +} + + +/** + * Randomness update + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * randomness-state-update = u64 u64 bytes u64 + * ``` + */ +public struct RandomnessStateUpdate { + /** + * Epoch of the randomness state update transaction + */ + public var epoch: UInt64 + /** + * Randomness round of the update + */ + public var randomnessRound: UInt64 + /** + * Updated random bytes + */ + public var randomBytes: Data + /** + * The initial version of the randomness object that it was shared at + */ + public var randomnessObjInitialSharedVersion: UInt64 + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Epoch of the randomness state update transaction + */epoch: UInt64, + /** + * Randomness round of the update + */randomnessRound: UInt64, + /** + * Updated random bytes + */randomBytes: Data, + /** + * The initial version of the randomness object that it was shared at + */randomnessObjInitialSharedVersion: UInt64) { + self.epoch = epoch + self.randomnessRound = randomnessRound + self.randomBytes = randomBytes + self.randomnessObjInitialSharedVersion = randomnessObjInitialSharedVersion + } +} + +#if compiler(>=6) +extension RandomnessStateUpdate: Sendable {} +#endif + + +extension RandomnessStateUpdate: Equatable, Hashable { + public static func ==(lhs: RandomnessStateUpdate, rhs: RandomnessStateUpdate) -> Bool { + if lhs.epoch != rhs.epoch { + return false + } + if lhs.randomnessRound != rhs.randomnessRound { + return false + } + if lhs.randomBytes != rhs.randomBytes { + return false + } + if lhs.randomnessObjInitialSharedVersion != rhs.randomnessObjInitialSharedVersion { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(epoch) + hasher.combine(randomnessRound) + hasher.combine(randomBytes) + hasher.combine(randomnessObjInitialSharedVersion) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeRandomnessStateUpdate: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> RandomnessStateUpdate { + return + try RandomnessStateUpdate( + epoch: FfiConverterUInt64.read(from: &buf), + randomnessRound: FfiConverterUInt64.read(from: &buf), + randomBytes: FfiConverterData.read(from: &buf), + randomnessObjInitialSharedVersion: FfiConverterUInt64.read(from: &buf) + ) + } + + public static func write(_ value: RandomnessStateUpdate, into buf: inout [UInt8]) { + FfiConverterUInt64.write(value.epoch, into: &buf) + FfiConverterUInt64.write(value.randomnessRound, into: &buf) + FfiConverterData.write(value.randomBytes, into: &buf) + FfiConverterUInt64.write(value.randomnessObjInitialSharedVersion, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeRandomnessStateUpdate_lift(_ buf: RustBuffer) throws -> RandomnessStateUpdate { + return try FfiConverterTypeRandomnessStateUpdate.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeRandomnessStateUpdate_lower(_ value: RandomnessStateUpdate) -> RustBuffer { + return FfiConverterTypeRandomnessStateUpdate.lower(value) +} + + +public struct ServiceConfig { + /** + * Default number of elements allowed on a single page of a connection. + */ + public var defaultPageSize: Int32 + /** + * List of all features that are enabled on this RPC service. + */ + public var enabledFeatures: [Feature] + /** + * 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. + */ + public var maxMoveValueDepth: Int32 + /** + * 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. + */ + public var maxOutputNodes: Int32 + /** + * Maximum number of elements allowed on a single page of a connection. + */ + public var maxPageSize: Int32 + /** + * The maximum depth a GraphQL query can be to be accepted by this service. + */ + public var maxQueryDepth: Int32 + /** + * The maximum number of nodes (field names) the service will accept in a + * single query. + */ + public var maxQueryNodes: Int32 + /** + * Maximum length of a query payload string. + */ + public var maxQueryPayloadSize: Int32 + /** + * Maximum nesting allowed in type arguments in Move Types resolved by this + * service. + */ + public var maxTypeArgumentDepth: Int32 + /** + * Maximum number of type arguments passed into a generic instantiation of + * a Move Type resolved by this service. + */ + public var maxTypeArgumentWidth: Int32 + /** + * Maximum number of structs that need to be processed when calculating the + * layout of a single Move Type. + */ + public var maxTypeNodes: Int32 + /** + * Maximum time in milliseconds spent waiting for a response from fullnode + * after issuing a 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). + */ + public var mutationTimeoutMs: Int32 + /** + * Maximum time in milliseconds that will be spent to serve one query + * request. + */ + public var requestTimeoutMs: Int32 + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Default number of elements allowed on a single page of a connection. + */defaultPageSize: Int32, + /** + * List of all features that are enabled on this RPC service. + */enabledFeatures: [Feature], + /** + * 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: Int32, + /** + * 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: Int32, + /** + * Maximum number of elements allowed on a single page of a connection. + */maxPageSize: Int32, + /** + * The maximum depth a GraphQL query can be to be accepted by this service. + */maxQueryDepth: Int32, + /** + * The maximum number of nodes (field names) the service will accept in a + * single query. + */maxQueryNodes: Int32, + /** + * Maximum length of a query payload string. + */maxQueryPayloadSize: Int32, + /** + * Maximum nesting allowed in type arguments in Move Types resolved by this + * service. + */maxTypeArgumentDepth: Int32, + /** + * Maximum number of type arguments passed into a generic instantiation of + * a Move Type resolved by this service. + */maxTypeArgumentWidth: Int32, + /** + * Maximum number of structs that need to be processed when calculating the + * layout of a single Move Type. + */maxTypeNodes: Int32, + /** + * Maximum time in milliseconds spent waiting for a response from fullnode + * after issuing a 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: Int32, + /** + * Maximum time in milliseconds that will be spent to serve one query + * request. + */requestTimeoutMs: Int32) { + self.defaultPageSize = defaultPageSize + self.enabledFeatures = enabledFeatures + self.maxMoveValueDepth = maxMoveValueDepth + self.maxOutputNodes = maxOutputNodes + self.maxPageSize = maxPageSize + self.maxQueryDepth = maxQueryDepth + self.maxQueryNodes = maxQueryNodes + self.maxQueryPayloadSize = maxQueryPayloadSize + self.maxTypeArgumentDepth = maxTypeArgumentDepth + self.maxTypeArgumentWidth = maxTypeArgumentWidth + self.maxTypeNodes = maxTypeNodes + self.mutationTimeoutMs = mutationTimeoutMs + self.requestTimeoutMs = requestTimeoutMs + } +} + +#if compiler(>=6) +extension ServiceConfig: Sendable {} +#endif + + +extension ServiceConfig: Equatable, Hashable { + public static func ==(lhs: ServiceConfig, rhs: ServiceConfig) -> Bool { + if lhs.defaultPageSize != rhs.defaultPageSize { + return false + } + if lhs.enabledFeatures != rhs.enabledFeatures { + return false + } + if lhs.maxMoveValueDepth != rhs.maxMoveValueDepth { + return false + } + if lhs.maxOutputNodes != rhs.maxOutputNodes { + return false + } + if lhs.maxPageSize != rhs.maxPageSize { + return false + } + if lhs.maxQueryDepth != rhs.maxQueryDepth { + return false + } + if lhs.maxQueryNodes != rhs.maxQueryNodes { + return false + } + if lhs.maxQueryPayloadSize != rhs.maxQueryPayloadSize { + return false + } + if lhs.maxTypeArgumentDepth != rhs.maxTypeArgumentDepth { + return false + } + if lhs.maxTypeArgumentWidth != rhs.maxTypeArgumentWidth { + return false + } + if lhs.maxTypeNodes != rhs.maxTypeNodes { + return false + } + if lhs.mutationTimeoutMs != rhs.mutationTimeoutMs { + return false + } + if lhs.requestTimeoutMs != rhs.requestTimeoutMs { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(defaultPageSize) + hasher.combine(enabledFeatures) + hasher.combine(maxMoveValueDepth) + hasher.combine(maxOutputNodes) + hasher.combine(maxPageSize) + hasher.combine(maxQueryDepth) + hasher.combine(maxQueryNodes) + hasher.combine(maxQueryPayloadSize) + hasher.combine(maxTypeArgumentDepth) + hasher.combine(maxTypeArgumentWidth) + hasher.combine(maxTypeNodes) + hasher.combine(mutationTimeoutMs) + hasher.combine(requestTimeoutMs) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeServiceConfig: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ServiceConfig { + return + try ServiceConfig( + defaultPageSize: FfiConverterInt32.read(from: &buf), + enabledFeatures: FfiConverterSequenceTypeFeature.read(from: &buf), + maxMoveValueDepth: FfiConverterInt32.read(from: &buf), + maxOutputNodes: FfiConverterInt32.read(from: &buf), + maxPageSize: FfiConverterInt32.read(from: &buf), + maxQueryDepth: FfiConverterInt32.read(from: &buf), + maxQueryNodes: FfiConverterInt32.read(from: &buf), + maxQueryPayloadSize: FfiConverterInt32.read(from: &buf), + maxTypeArgumentDepth: FfiConverterInt32.read(from: &buf), + maxTypeArgumentWidth: FfiConverterInt32.read(from: &buf), + maxTypeNodes: FfiConverterInt32.read(from: &buf), + mutationTimeoutMs: FfiConverterInt32.read(from: &buf), + requestTimeoutMs: FfiConverterInt32.read(from: &buf) + ) + } + + public static func write(_ value: ServiceConfig, into buf: inout [UInt8]) { + FfiConverterInt32.write(value.defaultPageSize, into: &buf) + FfiConverterSequenceTypeFeature.write(value.enabledFeatures, into: &buf) + FfiConverterInt32.write(value.maxMoveValueDepth, into: &buf) + FfiConverterInt32.write(value.maxOutputNodes, into: &buf) + FfiConverterInt32.write(value.maxPageSize, into: &buf) + FfiConverterInt32.write(value.maxQueryDepth, into: &buf) + FfiConverterInt32.write(value.maxQueryNodes, into: &buf) + FfiConverterInt32.write(value.maxQueryPayloadSize, into: &buf) + FfiConverterInt32.write(value.maxTypeArgumentDepth, into: &buf) + FfiConverterInt32.write(value.maxTypeArgumentWidth, into: &buf) + FfiConverterInt32.write(value.maxTypeNodes, into: &buf) + FfiConverterInt32.write(value.mutationTimeoutMs, into: &buf) + FfiConverterInt32.write(value.requestTimeoutMs, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeServiceConfig_lift(_ buf: RustBuffer) throws -> ServiceConfig { + return try FfiConverterTypeServiceConfig.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeServiceConfig_lower(_ value: ServiceConfig) -> RustBuffer { + return FfiConverterTypeServiceConfig.lower(value) +} + + +public struct SignedTransaction { + public var transaction: Transaction + public var signatures: [UserSignature] + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(transaction: Transaction, signatures: [UserSignature]) { + self.transaction = transaction + self.signatures = signatures + } +} + +#if compiler(>=6) +extension SignedTransaction: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeSignedTransaction: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SignedTransaction { + return + try SignedTransaction( + transaction: FfiConverterTypeTransaction.read(from: &buf), + signatures: FfiConverterSequenceTypeUserSignature.read(from: &buf) + ) + } + + public static func write(_ value: SignedTransaction, into buf: inout [UInt8]) { + FfiConverterTypeTransaction.write(value.transaction, into: &buf) + FfiConverterSequenceTypeUserSignature.write(value.signatures, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSignedTransaction_lift(_ buf: RustBuffer) throws -> SignedTransaction { + return try FfiConverterTypeSignedTransaction.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSignedTransaction_lower(_ value: SignedTransaction) -> RustBuffer { + return FfiConverterTypeSignedTransaction.lower(value) +} + + +/** + * A page of items returned by the GraphQL server. + */ +public struct SignedTransactionPage { + /** + * Information about the page, such as the cursor and whether there are + * more pages. + */ + public var pageInfo: PageInfo + /** + * The data returned by the server. + */ + public var data: [SignedTransaction] + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Information about the page, such as the cursor and whether there are + * more pages. + */pageInfo: PageInfo, + /** + * The data returned by the server. + */data: [SignedTransaction]) { + self.pageInfo = pageInfo + self.data = data + } +} + +#if compiler(>=6) +extension SignedTransactionPage: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeSignedTransactionPage: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SignedTransactionPage { + return + try SignedTransactionPage( + pageInfo: FfiConverterTypePageInfo.read(from: &buf), + data: FfiConverterSequenceTypeSignedTransaction.read(from: &buf) + ) + } + + public static func write(_ value: SignedTransactionPage, into buf: inout [UInt8]) { + FfiConverterTypePageInfo.write(value.pageInfo, into: &buf) + FfiConverterSequenceTypeSignedTransaction.write(value.data, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSignedTransactionPage_lift(_ buf: RustBuffer) throws -> SignedTransactionPage { + return try FfiConverterTypeSignedTransactionPage.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSignedTransactionPage_lower(_ value: SignedTransactionPage) -> RustBuffer { + return FfiConverterTypeSignedTransactionPage.lower(value) +} + + +public struct TransactionDataEffects { + public var tx: SignedTransaction + public var effects: TransactionEffects + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(tx: SignedTransaction, effects: TransactionEffects) { + self.tx = tx + self.effects = effects + } +} + +#if compiler(>=6) +extension TransactionDataEffects: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeTransactionDataEffects: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TransactionDataEffects { + return + try TransactionDataEffects( + tx: FfiConverterTypeSignedTransaction.read(from: &buf), + effects: FfiConverterTypeTransactionEffects.read(from: &buf) + ) + } + + public static func write(_ value: TransactionDataEffects, into buf: inout [UInt8]) { + FfiConverterTypeSignedTransaction.write(value.tx, into: &buf) + FfiConverterTypeTransactionEffects.write(value.effects, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionDataEffects_lift(_ buf: RustBuffer) throws -> TransactionDataEffects { + return try FfiConverterTypeTransactionDataEffects.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionDataEffects_lower(_ value: TransactionDataEffects) -> RustBuffer { + return FfiConverterTypeTransactionDataEffects.lower(value) +} + + +/** + * A page of items returned by the GraphQL server. + */ +public struct TransactionDataEffectsPage { + /** + * Information about the page, such as the cursor and whether there are + * more pages. + */ + public var pageInfo: PageInfo + /** + * The data returned by the server. + */ + public var data: [TransactionDataEffects] + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Information about the page, such as the cursor and whether there are + * more pages. + */pageInfo: PageInfo, + /** + * The data returned by the server. + */data: [TransactionDataEffects]) { + self.pageInfo = pageInfo + self.data = data + } +} + +#if compiler(>=6) +extension TransactionDataEffectsPage: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeTransactionDataEffectsPage: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TransactionDataEffectsPage { + return + try TransactionDataEffectsPage( + pageInfo: FfiConverterTypePageInfo.read(from: &buf), + data: FfiConverterSequenceTypeTransactionDataEffects.read(from: &buf) + ) + } + + public static func write(_ value: TransactionDataEffectsPage, into buf: inout [UInt8]) { + FfiConverterTypePageInfo.write(value.pageInfo, into: &buf) + FfiConverterSequenceTypeTransactionDataEffects.write(value.data, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionDataEffectsPage_lift(_ buf: RustBuffer) throws -> TransactionDataEffectsPage { + return try FfiConverterTypeTransactionDataEffectsPage.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionDataEffectsPage_lower(_ value: TransactionDataEffectsPage) -> RustBuffer { + return FfiConverterTypeTransactionDataEffectsPage.lower(value) +} + + +/** + * A page of items returned by the GraphQL server. + */ +public struct TransactionEffectsPage { + /** + * Information about the page, such as the cursor and whether there are + * more pages. + */ + public var pageInfo: PageInfo + /** + * The data returned by the server. + */ + public var data: [TransactionEffects] + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Information about the page, such as the cursor and whether there are + * more pages. + */pageInfo: PageInfo, + /** + * The data returned by the server. + */data: [TransactionEffects]) { + self.pageInfo = pageInfo + self.data = data + } +} + +#if compiler(>=6) +extension TransactionEffectsPage: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeTransactionEffectsPage: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TransactionEffectsPage { + return + try TransactionEffectsPage( + pageInfo: FfiConverterTypePageInfo.read(from: &buf), + data: FfiConverterSequenceTypeTransactionEffects.read(from: &buf) + ) + } + + public static func write(_ value: TransactionEffectsPage, into buf: inout [UInt8]) { + FfiConverterTypePageInfo.write(value.pageInfo, into: &buf) + FfiConverterSequenceTypeTransactionEffects.write(value.data, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionEffectsPage_lift(_ buf: RustBuffer) throws -> TransactionEffectsPage { + return try FfiConverterTypeTransactionEffectsPage.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionEffectsPage_lower(_ value: TransactionEffectsPage) -> RustBuffer { + return FfiConverterTypeTransactionEffectsPage.lower(value) +} + + +/** + * 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 + * ``` + */ +public struct TransactionEffectsV1 { + /** + * The status of the execution + */ + public var status: ExecutionStatus + /** + * The epoch when this transaction was executed. + */ + public var epoch: UInt64 + /** + * The gas used by this transaction + */ + public var gasUsed: GasCostSummary + /** + * The transaction digest + */ + public var transactionDigest: TransactionDigest + /** + * 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. + */ + public var gasObjectIndex: UInt32? + /** + * The digest of the events emitted during execution, + * can be None if the transaction does not emit any event. + */ + public var eventsDigest: TransactionEventsDigest? + /** + * The set of transaction digests this transaction depends on. + */ + public var dependencies: [TransactionDigest] + /** + * The version number of all the written Move objects by this transaction. + */ + public var lamportVersion: UInt64 + /** + * Objects whose state are changed in the object store. + */ + public var changedObjects: [ChangedObject] + /** + * 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. + */ + public var unchangedSharedObjects: [UnchangedSharedObject] + /** + * 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. + */ + public var auxiliaryDataDigest: EffectsAuxiliaryDataDigest? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * The status of the execution + */status: ExecutionStatus, + /** + * The epoch when this transaction was executed. + */epoch: UInt64, + /** + * The gas used by this transaction + */gasUsed: GasCostSummary, + /** + * The transaction digest + */transactionDigest: TransactionDigest, + /** + * 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: UInt32?, + /** + * The digest of the events emitted during execution, + * can be None if the transaction does not emit any event. + */eventsDigest: TransactionEventsDigest?, + /** + * The set of transaction digests this transaction depends on. + */dependencies: [TransactionDigest], + /** + * The version number of all the written Move objects by this transaction. + */lamportVersion: UInt64, + /** + * Objects whose state are changed in the object store. + */changedObjects: [ChangedObject], + /** + * 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: [UnchangedSharedObject], + /** + * 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: EffectsAuxiliaryDataDigest?) { + self.status = status + self.epoch = epoch + self.gasUsed = gasUsed + self.transactionDigest = transactionDigest + self.gasObjectIndex = gasObjectIndex + self.eventsDigest = eventsDigest + self.dependencies = dependencies + self.lamportVersion = lamportVersion + self.changedObjects = changedObjects + self.unchangedSharedObjects = unchangedSharedObjects + self.auxiliaryDataDigest = auxiliaryDataDigest + } +} + +#if compiler(>=6) +extension TransactionEffectsV1: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeTransactionEffectsV1: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TransactionEffectsV1 { + return + try TransactionEffectsV1( + status: FfiConverterTypeExecutionStatus.read(from: &buf), + epoch: FfiConverterUInt64.read(from: &buf), + gasUsed: FfiConverterTypeGasCostSummary.read(from: &buf), + transactionDigest: FfiConverterTypeTransactionDigest.read(from: &buf), + gasObjectIndex: FfiConverterOptionUInt32.read(from: &buf), + eventsDigest: FfiConverterOptionTypeTransactionEventsDigest.read(from: &buf), + dependencies: FfiConverterSequenceTypeTransactionDigest.read(from: &buf), + lamportVersion: FfiConverterUInt64.read(from: &buf), + changedObjects: FfiConverterSequenceTypeChangedObject.read(from: &buf), + unchangedSharedObjects: FfiConverterSequenceTypeUnchangedSharedObject.read(from: &buf), + auxiliaryDataDigest: FfiConverterOptionTypeEffectsAuxiliaryDataDigest.read(from: &buf) + ) + } + + public static func write(_ value: TransactionEffectsV1, into buf: inout [UInt8]) { + FfiConverterTypeExecutionStatus.write(value.status, into: &buf) + FfiConverterUInt64.write(value.epoch, into: &buf) + FfiConverterTypeGasCostSummary.write(value.gasUsed, into: &buf) + FfiConverterTypeTransactionDigest.write(value.transactionDigest, into: &buf) + FfiConverterOptionUInt32.write(value.gasObjectIndex, into: &buf) + FfiConverterOptionTypeTransactionEventsDigest.write(value.eventsDigest, into: &buf) + FfiConverterSequenceTypeTransactionDigest.write(value.dependencies, into: &buf) + FfiConverterUInt64.write(value.lamportVersion, into: &buf) + FfiConverterSequenceTypeChangedObject.write(value.changedObjects, into: &buf) + FfiConverterSequenceTypeUnchangedSharedObject.write(value.unchangedSharedObjects, into: &buf) + FfiConverterOptionTypeEffectsAuxiliaryDataDigest.write(value.auxiliaryDataDigest, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionEffectsV1_lift(_ buf: RustBuffer) throws -> TransactionEffectsV1 { + return try FfiConverterTypeTransactionEffectsV1.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionEffectsV1_lower(_ value: TransactionEffectsV1) -> RustBuffer { + return FfiConverterTypeTransactionEffectsV1.lower(value) +} + + +public struct TransactionMetadata { + public var gasBudget: UInt64? + public var gasObjects: [ObjectRef]? + public var gasPrice: UInt64? + public var gasSponsor: Address? + public var sender: Address? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(gasBudget: UInt64? = nil, gasObjects: [ObjectRef]? = nil, gasPrice: UInt64? = nil, gasSponsor: Address? = nil, sender: Address? = nil) { + self.gasBudget = gasBudget + self.gasObjects = gasObjects + self.gasPrice = gasPrice + self.gasSponsor = gasSponsor + self.sender = sender + } +} + +#if compiler(>=6) +extension TransactionMetadata: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeTransactionMetadata: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TransactionMetadata { + return + try TransactionMetadata( + gasBudget: FfiConverterOptionUInt64.read(from: &buf), + gasObjects: FfiConverterOptionSequenceTypeObjectRef.read(from: &buf), + gasPrice: FfiConverterOptionUInt64.read(from: &buf), + gasSponsor: FfiConverterOptionTypeAddress.read(from: &buf), + sender: FfiConverterOptionTypeAddress.read(from: &buf) + ) + } + + public static func write(_ value: TransactionMetadata, into buf: inout [UInt8]) { + FfiConverterOptionUInt64.write(value.gasBudget, into: &buf) + FfiConverterOptionSequenceTypeObjectRef.write(value.gasObjects, into: &buf) + FfiConverterOptionUInt64.write(value.gasPrice, into: &buf) + FfiConverterOptionTypeAddress.write(value.gasSponsor, into: &buf) + FfiConverterOptionTypeAddress.write(value.sender, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionMetadata_lift(_ buf: RustBuffer) throws -> TransactionMetadata { + return try FfiConverterTypeTransactionMetadata.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionMetadata_lower(_ value: TransactionMetadata) -> RustBuffer { + return FfiConverterTypeTransactionMetadata.lower(value) +} + + +public struct TransactionsFilter { + public var function: String? + public var kind: TransactionBlockKindInput? + public var afterCheckpoint: UInt64? + public var atCheckpoint: UInt64? + public var beforeCheckpoint: UInt64? + public var signAddress: Address? + public var recvAddress: Address? + public var inputObject: ObjectId? + public var changedObject: ObjectId? + public var transactionIds: [String]? + public var wrappedOrDeletedObject: ObjectId? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(function: String? = nil, kind: TransactionBlockKindInput? = nil, afterCheckpoint: UInt64? = nil, atCheckpoint: UInt64? = nil, beforeCheckpoint: UInt64? = nil, signAddress: Address? = nil, recvAddress: Address? = nil, inputObject: ObjectId? = nil, changedObject: ObjectId? = nil, transactionIds: [String]? = nil, wrappedOrDeletedObject: ObjectId? = nil) { + self.function = function + self.kind = kind + self.afterCheckpoint = afterCheckpoint + self.atCheckpoint = atCheckpoint + self.beforeCheckpoint = beforeCheckpoint + self.signAddress = signAddress + self.recvAddress = recvAddress + self.inputObject = inputObject + self.changedObject = changedObject + self.transactionIds = transactionIds + self.wrappedOrDeletedObject = wrappedOrDeletedObject + } +} + +#if compiler(>=6) +extension TransactionsFilter: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeTransactionsFilter: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TransactionsFilter { + return + try TransactionsFilter( + function: FfiConverterOptionString.read(from: &buf), + kind: FfiConverterOptionTypeTransactionBlockKindInput.read(from: &buf), + afterCheckpoint: FfiConverterOptionUInt64.read(from: &buf), + atCheckpoint: FfiConverterOptionUInt64.read(from: &buf), + beforeCheckpoint: FfiConverterOptionUInt64.read(from: &buf), + signAddress: FfiConverterOptionTypeAddress.read(from: &buf), + recvAddress: FfiConverterOptionTypeAddress.read(from: &buf), + inputObject: FfiConverterOptionTypeObjectId.read(from: &buf), + changedObject: FfiConverterOptionTypeObjectId.read(from: &buf), + transactionIds: FfiConverterOptionSequenceString.read(from: &buf), + wrappedOrDeletedObject: FfiConverterOptionTypeObjectId.read(from: &buf) + ) + } + + public static func write(_ value: TransactionsFilter, into buf: inout [UInt8]) { + FfiConverterOptionString.write(value.function, into: &buf) + FfiConverterOptionTypeTransactionBlockKindInput.write(value.kind, into: &buf) + FfiConverterOptionUInt64.write(value.afterCheckpoint, into: &buf) + FfiConverterOptionUInt64.write(value.atCheckpoint, into: &buf) + FfiConverterOptionUInt64.write(value.beforeCheckpoint, into: &buf) + FfiConverterOptionTypeAddress.write(value.signAddress, into: &buf) + FfiConverterOptionTypeAddress.write(value.recvAddress, into: &buf) + FfiConverterOptionTypeObjectId.write(value.inputObject, into: &buf) + FfiConverterOptionTypeObjectId.write(value.changedObject, into: &buf) + FfiConverterOptionSequenceString.write(value.transactionIds, into: &buf) + FfiConverterOptionTypeObjectId.write(value.wrappedOrDeletedObject, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionsFilter_lift(_ buf: RustBuffer) throws -> TransactionsFilter { + return try FfiConverterTypeTransactionsFilter.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionsFilter_lower(_ value: TransactionsFilter) -> RustBuffer { + return FfiConverterTypeTransactionsFilter.lower(value) +} + + +/** + * 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 + * ``` + */ +public struct TypeOrigin { + public var moduleName: Identifier + public var structName: Identifier + public var package: ObjectId + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(moduleName: Identifier, structName: Identifier, package: ObjectId) { + self.moduleName = moduleName + self.structName = structName + self.package = package + } +} + +#if compiler(>=6) +extension TypeOrigin: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeTypeOrigin: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TypeOrigin { + return + try TypeOrigin( + moduleName: FfiConverterTypeIdentifier.read(from: &buf), + structName: FfiConverterTypeIdentifier.read(from: &buf), + package: FfiConverterTypeObjectId.read(from: &buf) + ) + } + + public static func write(_ value: TypeOrigin, into buf: inout [UInt8]) { + FfiConverterTypeIdentifier.write(value.moduleName, into: &buf) + FfiConverterTypeIdentifier.write(value.structName, into: &buf) + FfiConverterTypeObjectId.write(value.package, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTypeOrigin_lift(_ buf: RustBuffer) throws -> TypeOrigin { + return try FfiConverterTypeTypeOrigin.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTypeOrigin_lower(_ value: TypeOrigin) -> RustBuffer { + return FfiConverterTypeTypeOrigin.lower(value) +} + + +/** + * 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 + * ``` + */ +public struct UnchangedSharedObject { + public var objectId: ObjectId + public var kind: UnchangedSharedKind + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(objectId: ObjectId, kind: UnchangedSharedKind) { + self.objectId = objectId + self.kind = kind + } +} + +#if compiler(>=6) +extension UnchangedSharedObject: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeUnchangedSharedObject: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UnchangedSharedObject { + return + try UnchangedSharedObject( + objectId: FfiConverterTypeObjectId.read(from: &buf), + kind: FfiConverterTypeUnchangedSharedKind.read(from: &buf) + ) + } + + public static func write(_ value: UnchangedSharedObject, into buf: inout [UInt8]) { + FfiConverterTypeObjectId.write(value.objectId, into: &buf) + FfiConverterTypeUnchangedSharedKind.write(value.kind, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeUnchangedSharedObject_lift(_ buf: RustBuffer) throws -> UnchangedSharedObject { + return try FfiConverterTypeUnchangedSharedObject.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeUnchangedSharedObject_lower(_ value: UnchangedSharedObject) -> RustBuffer { + return FfiConverterTypeUnchangedSharedObject.lower(value) +} + + +/** + * 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 + * ``` + */ +public struct UpgradeInfo { + /** + * Id of the upgraded packages + */ + public var upgradedId: ObjectId + /** + * Version of the upgraded package + */ + public var upgradedVersion: UInt64 + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Id of the upgraded packages + */upgradedId: ObjectId, + /** + * Version of the upgraded package + */upgradedVersion: UInt64) { + self.upgradedId = upgradedId + self.upgradedVersion = upgradedVersion + } +} + +#if compiler(>=6) +extension UpgradeInfo: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeUpgradeInfo: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UpgradeInfo { + return + try UpgradeInfo( + upgradedId: FfiConverterTypeObjectId.read(from: &buf), + upgradedVersion: FfiConverterUInt64.read(from: &buf) + ) + } + + public static func write(_ value: UpgradeInfo, into buf: inout [UInt8]) { + FfiConverterTypeObjectId.write(value.upgradedId, into: &buf) + FfiConverterUInt64.write(value.upgradedVersion, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeUpgradeInfo_lift(_ buf: RustBuffer) throws -> UpgradeInfo { + return try FfiConverterTypeUpgradeInfo.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeUpgradeInfo_lower(_ value: UpgradeInfo) -> RustBuffer { + return FfiConverterTypeUpgradeInfo.lower(value) +} + + +/** + * Represents a validator in the system. + */ +public struct Validator { + /** + * The APY of this validator in basis points. + * To get the APY in percentage, divide by 100. + */ + public var apy: Int32? + /** + * The validator's address. + */ + public var address: Address + /** + * The fee charged by the validator for staking services. + */ + public var commissionRate: Int32? + /** + * Validator's credentials. + */ + public var credentials: ValidatorCredentials? + /** + * Validator's description. + */ + public var description: String? + /** + * Number of exchange rates in the table. + */ + public var exchangeRatesSize: UInt64? + /** + * The reference gas price for this epoch. + */ + public var gasPrice: UInt64? + /** + * Validator's name. + */ + public var name: String? + /** + * Validator's url containing their custom image. + */ + public var imageUrl: String? + /** + * The proposed next epoch fee for the validator's staking services. + */ + public var nextEpochCommissionRate: Int32? + /** + * Validator's credentials for the next epoch. + */ + public var nextEpochCredentials: ValidatorCredentials? + /** + * The validator's gas price quote for the next epoch. + */ + public var nextEpochGasPrice: UInt64? + /** + * The total number of IOTA tokens in this pool plus + * the pending stake amount for this epoch. + */ + public var nextEpochStake: UInt64? + /** + * 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. + */ + public var operationCap: Data? + /** + * Pending pool token withdrawn during the current epoch, emptied at epoch + * boundaries. + */ + public var pendingPoolTokenWithdraw: UInt64? + /** + * Pending stake amount for this epoch. + */ + public var pendingStake: UInt64? + /** + * Pending stake withdrawn during the current epoch, emptied at epoch + * boundaries. + */ + public var pendingTotalIotaWithdraw: UInt64? + /** + * Total number of pool tokens issued by the pool. + */ + public var poolTokenBalance: UInt64? + /** + * Validator's homepage URL. + */ + public var projectUrl: String? + /** + * The epoch stake rewards will be added here at the end of each epoch. + */ + public var rewardsPool: UInt64? + /** + * The epoch at which this pool became active. + */ + public var stakingPoolActivationEpoch: UInt64? + /** + * The ID of this validator's `0x3::staking_pool::StakingPool`. + */ + public var stakingPoolId: ObjectId + /** + * The total number of IOTA tokens in this pool. + */ + public var stakingPoolIotaBalance: UInt64? + /** + * The voting power of this validator in basis points (e.g., 100 = 1% + * voting power). + */ + public var votingPower: Int32? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * The APY of this validator in basis points. + * To get the APY in percentage, divide by 100. + */apy: Int32?, + /** + * The validator's address. + */address: Address, + /** + * The fee charged by the validator for staking services. + */commissionRate: Int32?, + /** + * Validator's credentials. + */credentials: ValidatorCredentials?, + /** + * Validator's description. + */description: String?, + /** + * Number of exchange rates in the table. + */exchangeRatesSize: UInt64?, + /** + * The reference gas price for this epoch. + */gasPrice: UInt64?, + /** + * 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: Int32?, + /** + * Validator's credentials for the next epoch. + */nextEpochCredentials: ValidatorCredentials?, + /** + * The validator's gas price quote for the next epoch. + */nextEpochGasPrice: UInt64?, + /** + * The total number of IOTA tokens in this pool plus + * the pending stake amount for this epoch. + */nextEpochStake: UInt64?, + /** + * 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: Data?, + /** + * Pending pool token withdrawn during the current epoch, emptied at epoch + * boundaries. + */pendingPoolTokenWithdraw: UInt64?, + /** + * Pending stake amount for this epoch. + */pendingStake: UInt64?, + /** + * Pending stake withdrawn during the current epoch, emptied at epoch + * boundaries. + */pendingTotalIotaWithdraw: UInt64?, + /** + * Total number of pool tokens issued by the pool. + */poolTokenBalance: UInt64?, + /** + * Validator's homepage URL. + */projectUrl: String?, + /** + * The epoch stake rewards will be added here at the end of each epoch. + */rewardsPool: UInt64?, + /** + * The epoch at which this pool became active. + */stakingPoolActivationEpoch: UInt64?, + /** + * The ID of this validator's `0x3::staking_pool::StakingPool`. + */stakingPoolId: ObjectId, + /** + * The total number of IOTA tokens in this pool. + */stakingPoolIotaBalance: UInt64?, + /** + * The voting power of this validator in basis points (e.g., 100 = 1% + * voting power). + */votingPower: Int32?) { + self.apy = apy + self.address = address + self.commissionRate = commissionRate + self.credentials = credentials + self.description = description + self.exchangeRatesSize = exchangeRatesSize + self.gasPrice = gasPrice + self.name = name + self.imageUrl = imageUrl + self.nextEpochCommissionRate = nextEpochCommissionRate + self.nextEpochCredentials = nextEpochCredentials + self.nextEpochGasPrice = nextEpochGasPrice + self.nextEpochStake = nextEpochStake + self.operationCap = operationCap + self.pendingPoolTokenWithdraw = pendingPoolTokenWithdraw + self.pendingStake = pendingStake + self.pendingTotalIotaWithdraw = pendingTotalIotaWithdraw + self.poolTokenBalance = poolTokenBalance + self.projectUrl = projectUrl + self.rewardsPool = rewardsPool + self.stakingPoolActivationEpoch = stakingPoolActivationEpoch + self.stakingPoolId = stakingPoolId + self.stakingPoolIotaBalance = stakingPoolIotaBalance + self.votingPower = votingPower + } +} + +#if compiler(>=6) +extension Validator: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeValidator: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Validator { + return + try Validator( + apy: FfiConverterOptionInt32.read(from: &buf), + address: FfiConverterTypeAddress.read(from: &buf), + commissionRate: FfiConverterOptionInt32.read(from: &buf), + credentials: FfiConverterOptionTypeValidatorCredentials.read(from: &buf), + description: FfiConverterOptionString.read(from: &buf), + exchangeRatesSize: FfiConverterOptionUInt64.read(from: &buf), + gasPrice: FfiConverterOptionUInt64.read(from: &buf), + name: FfiConverterOptionString.read(from: &buf), + imageUrl: FfiConverterOptionString.read(from: &buf), + nextEpochCommissionRate: FfiConverterOptionInt32.read(from: &buf), + nextEpochCredentials: FfiConverterOptionTypeValidatorCredentials.read(from: &buf), + nextEpochGasPrice: FfiConverterOptionUInt64.read(from: &buf), + nextEpochStake: FfiConverterOptionUInt64.read(from: &buf), + operationCap: FfiConverterOptionData.read(from: &buf), + pendingPoolTokenWithdraw: FfiConverterOptionUInt64.read(from: &buf), + pendingStake: FfiConverterOptionUInt64.read(from: &buf), + pendingTotalIotaWithdraw: FfiConverterOptionUInt64.read(from: &buf), + poolTokenBalance: FfiConverterOptionUInt64.read(from: &buf), + projectUrl: FfiConverterOptionString.read(from: &buf), + rewardsPool: FfiConverterOptionUInt64.read(from: &buf), + stakingPoolActivationEpoch: FfiConverterOptionUInt64.read(from: &buf), + stakingPoolId: FfiConverterTypeObjectId.read(from: &buf), + stakingPoolIotaBalance: FfiConverterOptionUInt64.read(from: &buf), + votingPower: FfiConverterOptionInt32.read(from: &buf) + ) + } + + public static func write(_ value: Validator, into buf: inout [UInt8]) { + FfiConverterOptionInt32.write(value.apy, into: &buf) + FfiConverterTypeAddress.write(value.address, into: &buf) + FfiConverterOptionInt32.write(value.commissionRate, into: &buf) + FfiConverterOptionTypeValidatorCredentials.write(value.credentials, into: &buf) + FfiConverterOptionString.write(value.description, into: &buf) + FfiConverterOptionUInt64.write(value.exchangeRatesSize, into: &buf) + FfiConverterOptionUInt64.write(value.gasPrice, into: &buf) + FfiConverterOptionString.write(value.name, into: &buf) + FfiConverterOptionString.write(value.imageUrl, into: &buf) + FfiConverterOptionInt32.write(value.nextEpochCommissionRate, into: &buf) + FfiConverterOptionTypeValidatorCredentials.write(value.nextEpochCredentials, into: &buf) + FfiConverterOptionUInt64.write(value.nextEpochGasPrice, into: &buf) + FfiConverterOptionUInt64.write(value.nextEpochStake, into: &buf) + FfiConverterOptionData.write(value.operationCap, into: &buf) + FfiConverterOptionUInt64.write(value.pendingPoolTokenWithdraw, into: &buf) + FfiConverterOptionUInt64.write(value.pendingStake, into: &buf) + FfiConverterOptionUInt64.write(value.pendingTotalIotaWithdraw, into: &buf) + FfiConverterOptionUInt64.write(value.poolTokenBalance, into: &buf) + FfiConverterOptionString.write(value.projectUrl, into: &buf) + FfiConverterOptionUInt64.write(value.rewardsPool, into: &buf) + FfiConverterOptionUInt64.write(value.stakingPoolActivationEpoch, into: &buf) + FfiConverterTypeObjectId.write(value.stakingPoolId, into: &buf) + FfiConverterOptionUInt64.write(value.stakingPoolIotaBalance, into: &buf) + FfiConverterOptionInt32.write(value.votingPower, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeValidator_lift(_ buf: RustBuffer) throws -> Validator { + return try FfiConverterTypeValidator.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeValidator_lower(_ value: Validator) -> RustBuffer { + return FfiConverterTypeValidator.lower(value) +} + + +/** + * 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 + * ``` + */ +public struct ValidatorCommitteeMember { + public var publicKey: Bls12381PublicKey + public var stake: UInt64 + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(publicKey: Bls12381PublicKey, stake: UInt64) { + self.publicKey = publicKey + self.stake = stake + } +} + +#if compiler(>=6) +extension ValidatorCommitteeMember: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeValidatorCommitteeMember: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ValidatorCommitteeMember { + return + try ValidatorCommitteeMember( + publicKey: FfiConverterTypeBls12381PublicKey.read(from: &buf), + stake: FfiConverterUInt64.read(from: &buf) + ) + } + + public static func write(_ value: ValidatorCommitteeMember, into buf: inout [UInt8]) { + FfiConverterTypeBls12381PublicKey.write(value.publicKey, into: &buf) + FfiConverterUInt64.write(value.stake, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeValidatorCommitteeMember_lift(_ buf: RustBuffer) throws -> ValidatorCommitteeMember { + return try FfiConverterTypeValidatorCommitteeMember.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeValidatorCommitteeMember_lower(_ value: ValidatorCommitteeMember) -> RustBuffer { + return FfiConverterTypeValidatorCommitteeMember.lower(value) +} + + +public struct ValidatorConnection { + public var pageInfo: PageInfo + public var nodes: [Validator] + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(pageInfo: PageInfo, nodes: [Validator]) { + self.pageInfo = pageInfo + self.nodes = nodes + } +} + +#if compiler(>=6) +extension ValidatorConnection: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeValidatorConnection: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ValidatorConnection { + return + try ValidatorConnection( + pageInfo: FfiConverterTypePageInfo.read(from: &buf), + nodes: FfiConverterSequenceTypeValidator.read(from: &buf) + ) + } + + public static func write(_ value: ValidatorConnection, into buf: inout [UInt8]) { + FfiConverterTypePageInfo.write(value.pageInfo, into: &buf) + FfiConverterSequenceTypeValidator.write(value.nodes, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeValidatorConnection_lift(_ buf: RustBuffer) throws -> ValidatorConnection { + return try FfiConverterTypeValidatorConnection.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeValidatorConnection_lower(_ value: ValidatorConnection) -> RustBuffer { + return FfiConverterTypeValidatorConnection.lower(value) +} + + +public struct ValidatorCredentials { + public var authorityPubKey: Base64? + public var networkPubKey: Base64? + public var protocolPubKey: Base64? + public var proofOfPossession: Base64? + public var netAddress: String? + public var p2pAddress: String? + public var primaryAddress: String? + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(authorityPubKey: Base64?, networkPubKey: Base64?, protocolPubKey: Base64?, proofOfPossession: Base64?, netAddress: String?, p2pAddress: String?, primaryAddress: String?) { + self.authorityPubKey = authorityPubKey + self.networkPubKey = networkPubKey + self.protocolPubKey = protocolPubKey + self.proofOfPossession = proofOfPossession + self.netAddress = netAddress + self.p2pAddress = p2pAddress + self.primaryAddress = primaryAddress + } +} + +#if compiler(>=6) +extension ValidatorCredentials: Sendable {} +#endif + + +extension ValidatorCredentials: Equatable, Hashable { + public static func ==(lhs: ValidatorCredentials, rhs: ValidatorCredentials) -> Bool { + if lhs.authorityPubKey != rhs.authorityPubKey { + return false + } + if lhs.networkPubKey != rhs.networkPubKey { + return false + } + if lhs.protocolPubKey != rhs.protocolPubKey { + return false + } + if lhs.proofOfPossession != rhs.proofOfPossession { + return false + } + if lhs.netAddress != rhs.netAddress { + return false + } + if lhs.p2pAddress != rhs.p2pAddress { + return false + } + if lhs.primaryAddress != rhs.primaryAddress { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(authorityPubKey) + hasher.combine(networkPubKey) + hasher.combine(protocolPubKey) + hasher.combine(proofOfPossession) + hasher.combine(netAddress) + hasher.combine(p2pAddress) + hasher.combine(primaryAddress) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeValidatorCredentials: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ValidatorCredentials { + return + try ValidatorCredentials( + authorityPubKey: FfiConverterOptionTypeBase64.read(from: &buf), + networkPubKey: FfiConverterOptionTypeBase64.read(from: &buf), + protocolPubKey: FfiConverterOptionTypeBase64.read(from: &buf), + proofOfPossession: FfiConverterOptionTypeBase64.read(from: &buf), + netAddress: FfiConverterOptionString.read(from: &buf), + p2pAddress: FfiConverterOptionString.read(from: &buf), + primaryAddress: FfiConverterOptionString.read(from: &buf) + ) + } + + public static func write(_ value: ValidatorCredentials, into buf: inout [UInt8]) { + FfiConverterOptionTypeBase64.write(value.authorityPubKey, into: &buf) + FfiConverterOptionTypeBase64.write(value.networkPubKey, into: &buf) + FfiConverterOptionTypeBase64.write(value.protocolPubKey, into: &buf) + FfiConverterOptionTypeBase64.write(value.proofOfPossession, into: &buf) + FfiConverterOptionString.write(value.netAddress, into: &buf) + FfiConverterOptionString.write(value.p2pAddress, into: &buf) + FfiConverterOptionString.write(value.primaryAddress, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeValidatorCredentials_lift(_ buf: RustBuffer) throws -> ValidatorCredentials { + return try FfiConverterTypeValidatorCredentials.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeValidatorCredentials_lower(_ value: ValidatorCredentials) -> RustBuffer { + return FfiConverterTypeValidatorCredentials.lower(value) +} + + +/** + * A page of items returned by the GraphQL server. + */ +public struct ValidatorPage { + /** + * Information about the page, such as the cursor and whether there are + * more pages. + */ + public var pageInfo: PageInfo + /** + * The data returned by the server. + */ + public var data: [Validator] + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init( + /** + * Information about the page, such as the cursor and whether there are + * more pages. + */pageInfo: PageInfo, + /** + * The data returned by the server. + */data: [Validator]) { + self.pageInfo = pageInfo + self.data = data + } +} + +#if compiler(>=6) +extension ValidatorPage: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeValidatorPage: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ValidatorPage { + return + try ValidatorPage( + pageInfo: FfiConverterTypePageInfo.read(from: &buf), + data: FfiConverterSequenceTypeValidator.read(from: &buf) + ) + } + + public static func write(_ value: ValidatorPage, into buf: inout [UInt8]) { + FfiConverterTypePageInfo.write(value.pageInfo, into: &buf) + FfiConverterSequenceTypeValidator.write(value.data, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeValidatorPage_lift(_ buf: RustBuffer) throws -> ValidatorPage { + return try FfiConverterTypeValidatorPage.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeValidatorPage_lower(_ value: ValidatorPage) -> RustBuffer { + return FfiConverterTypeValidatorPage.lower(value) +} + + +public struct ValidatorSet { + public var activeValidators: ValidatorConnection + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(activeValidators: ValidatorConnection) { + self.activeValidators = activeValidators + } +} + +#if compiler(>=6) +extension ValidatorSet: Sendable {} +#endif + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeValidatorSet: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ValidatorSet { + return + try ValidatorSet( + activeValidators: FfiConverterTypeValidatorConnection.read(from: &buf) + ) + } + + public static func write(_ value: ValidatorSet, into buf: inout [UInt8]) { + FfiConverterTypeValidatorConnection.write(value.activeValidators, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeValidatorSet_lift(_ buf: RustBuffer) throws -> ValidatorSet { + return try FfiConverterTypeValidatorSet.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeValidatorSet_lower(_ value: ValidatorSet) -> RustBuffer { + return FfiConverterTypeValidatorSet.lower(value) +} + + +public struct ZkLoginClaim { + public var value: String + public var indexMod4: UInt8 + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(value: String, indexMod4: UInt8) { + self.value = value + self.indexMod4 = indexMod4 + } +} + +#if compiler(>=6) +extension ZkLoginClaim: Sendable {} +#endif + + +extension ZkLoginClaim: Equatable, Hashable { + public static func ==(lhs: ZkLoginClaim, rhs: ZkLoginClaim) -> Bool { + if lhs.value != rhs.value { + return false + } + if lhs.indexMod4 != rhs.indexMod4 { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(value) + hasher.combine(indexMod4) + } +} + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeZkLoginClaim: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ZkLoginClaim { + return + try ZkLoginClaim( + value: FfiConverterString.read(from: &buf), + indexMod4: FfiConverterUInt8.read(from: &buf) + ) + } + + public static func write(_ value: ZkLoginClaim, into buf: inout [UInt8]) { + FfiConverterString.write(value.value, into: &buf) + FfiConverterUInt8.write(value.indexMod4, into: &buf) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeZkLoginClaim_lift(_ buf: RustBuffer) throws -> ZkLoginClaim { + return try FfiConverterTypeZkLoginClaim.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeZkLoginClaim_lower(_ value: ZkLoginClaim) -> RustBuffer { + return FfiConverterTypeZkLoginClaim.lower(value) +} + +// Note that we don't yet support `indirect` for enums. +// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion. + +public enum CommandArgumentError { + + case typeMismatch + case invalidBcsBytes + case invalidUsageOfPureArgument + case invalidArgumentToPrivateEntryFunction + case indexOutOfBounds(index: UInt16 + ) + case secondaryIndexOutOfBounds(result: UInt16, subresult: UInt16 + ) + case invalidResultArity(result: UInt16 + ) + case invalidGasCoinUsage + case invalidValueUsage + case invalidObjectByValue + case invalidObjectByMutRef + case sharedObjectOperationNotAllowed +} + + +#if compiler(>=6) +extension CommandArgumentError: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeCommandArgumentError: FfiConverterRustBuffer { + typealias SwiftType = CommandArgumentError + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CommandArgumentError { + let variant: Int32 = try readInt(&buf) + switch variant { + + case 1: return .typeMismatch + + case 2: return .invalidBcsBytes + + case 3: return .invalidUsageOfPureArgument + + case 4: return .invalidArgumentToPrivateEntryFunction + + case 5: return .indexOutOfBounds(index: try FfiConverterUInt16.read(from: &buf) + ) + + case 6: return .secondaryIndexOutOfBounds(result: try FfiConverterUInt16.read(from: &buf), subresult: try FfiConverterUInt16.read(from: &buf) + ) + + case 7: return .invalidResultArity(result: try FfiConverterUInt16.read(from: &buf) + ) + + case 8: return .invalidGasCoinUsage + + case 9: return .invalidValueUsage + + case 10: return .invalidObjectByValue + + case 11: return .invalidObjectByMutRef + + case 12: return .sharedObjectOperationNotAllowed + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: CommandArgumentError, into buf: inout [UInt8]) { + switch value { + + + case .typeMismatch: + writeInt(&buf, Int32(1)) + + + case .invalidBcsBytes: + writeInt(&buf, Int32(2)) + + + case .invalidUsageOfPureArgument: + writeInt(&buf, Int32(3)) + + + case .invalidArgumentToPrivateEntryFunction: + writeInt(&buf, Int32(4)) + + + case let .indexOutOfBounds(index): + writeInt(&buf, Int32(5)) + FfiConverterUInt16.write(index, into: &buf) + + + case let .secondaryIndexOutOfBounds(result,subresult): + writeInt(&buf, Int32(6)) + FfiConverterUInt16.write(result, into: &buf) + FfiConverterUInt16.write(subresult, into: &buf) + + + case let .invalidResultArity(result): + writeInt(&buf, Int32(7)) + FfiConverterUInt16.write(result, into: &buf) + + + case .invalidGasCoinUsage: + writeInt(&buf, Int32(8)) + + + case .invalidValueUsage: + writeInt(&buf, Int32(9)) + + + case .invalidObjectByValue: + writeInt(&buf, Int32(10)) + + + case .invalidObjectByMutRef: + writeInt(&buf, Int32(11)) + + + case .sharedObjectOperationNotAllowed: + writeInt(&buf, Int32(12)) + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeCommandArgumentError_lift(_ buf: RustBuffer) throws -> CommandArgumentError { + return try FfiConverterTypeCommandArgumentError.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeCommandArgumentError_lower(_ value: CommandArgumentError) -> RustBuffer { + return FfiConverterTypeCommandArgumentError.lower(value) +} + + +extension CommandArgumentError: Equatable, Hashable {} + + + + + + +// Note that we don't yet support `indirect` for enums. +// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion. +/** + * Pagination direction. + */ + +public enum Direction { + + case forward + case backward +} + + +#if compiler(>=6) +extension Direction: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeDirection: FfiConverterRustBuffer { + typealias SwiftType = Direction + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Direction { + let variant: Int32 = try readInt(&buf) + switch variant { + + case 1: return .forward + + case 2: return .backward + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: Direction, into buf: inout [UInt8]) { + switch value { + + + case .forward: + writeInt(&buf, Int32(1)) + + + case .backward: + writeInt(&buf, Int32(2)) + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeDirection_lift(_ buf: RustBuffer) throws -> Direction { + return try FfiConverterTypeDirection.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeDirection_lower(_ value: Direction) -> RustBuffer { + return FfiConverterTypeDirection.lower(value) +} + + +extension Direction: Equatable, Hashable {} + + + + + + +// Note that we don't yet support `indirect` for enums. +// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion. +/** + * 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 + * ``` + */ + +public enum ExecutionError { + + /** + * Insufficient Gas + */ + case insufficientGas + /** + * Invalid Gas Object. + */ + case invalidGasObject + /** + * Invariant Violation + */ + case invariantViolation + /** + * Attempted to used feature that is not supported yet + */ + case featureNotYetSupported + /** + * Move object is larger than the maximum allowed size + */ + case objectTooBig(objectSize: UInt64, maxObjectSize: UInt64 + ) + /** + * Package is larger than the maximum allowed size + */ + case packageTooBig(objectSize: UInt64, maxObjectSize: UInt64 + ) + /** + * Circular Object Ownership + */ + case circularObjectOwnership(object: ObjectId + ) + /** + * Insufficient coin balance for requested operation + */ + case insufficientCoinBalance + /** + * Coin balance overflowed an u64 + */ + case coinBalanceOverflow + /** + * Publish Error, Non-zero Address. + * The modules in the package must have their self-addresses set to zero. + */ + case publishErrorNonZeroAddress + /** + * IOTA Move Bytecode Verification Error. + */ + case iotaMoveVerification + /** + * Error from a non-abort instruction. + * Possible causes: + * Arithmetic error, stack overflow, max value depth, etc." + */ + case movePrimitiveRuntime(location: MoveLocation? + ) + /** + * Move runtime abort + */ + case moveAbort(location: MoveLocation, code: UInt64 + ) + /** + * Bytecode verification error. + */ + case vmVerificationOrDeserialization + /** + * MoveVm invariant violation + */ + case vmInvariantViolation + /** + * Function not found + */ + case functionNotFound + /** + * Arity mismatch for Move function. + * The number of arguments does not match the number of parameters + */ + case arityMismatch + /** + * Type arity mismatch for Move function. + * Mismatch between the number of actual versus expected type arguments. + */ + case typeArityMismatch + /** + * Non Entry Function Invoked. Move Call must start with an entry function. + */ + case nonEntryFunctionInvoked + /** + * Invalid command argument + */ + case commandArgument(argument: UInt16, kind: CommandArgumentError + ) + /** + * Type argument error + */ + case typeArgument( + /** + * Index of the problematic type argument + */typeArgument: UInt16, kind: TypeArgumentError + ) + /** + * Unused result without the drop ability. + */ + case unusedValueWithoutDrop(result: UInt16, subresult: UInt16 + ) + /** + * Invalid public Move function signature. + * Unsupported return type for return value + */ + case invalidPublicFunctionReturnType(index: UInt16 + ) + /** + * Invalid Transfer Object, object does not have public transfer. + */ + case invalidTransferObject + /** + * Effects from the transaction are too large + */ + case effectsTooLarge(currentSize: UInt64, maxSize: UInt64 + ) + /** + * Publish or Upgrade is missing dependency + */ + case 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. + */ + case publishUpgradeDependencyDowngrade + /** + * Invalid package upgrade + */ + case packageUpgrade(kind: PackageUpgradeError + ) + /** + * Indicates the transaction tried to write objects too large to storage + */ + case writtenObjectsTooLarge(objectSize: UInt64, maxObjectSize: UInt64 + ) + /** + * Certificate is on the deny list + */ + case certificateDenied + /** + * IOTA Move Bytecode verification timed out. + */ + case iotaMoveVerificationTimeout + /** + * The requested shared object operation is not allowed + */ + case sharedObjectOperationNotAllowed + /** + * Requested shared object has been deleted + */ + case inputObjectDeleted + /** + * Certificate is cancelled due to congestion on shared objects + */ + case executionCancelledDueToSharedObjectCongestion(congestedObjects: [ObjectId] + ) + /** + * Certificate is cancelled due to congestion on shared objects; + * suggested gas price can be used to give this certificate more priority. + */ + case executionCancelledDueToSharedObjectCongestionV2(congestedObjects: [ObjectId], suggestedGasPrice: UInt64 + ) + /** + * Address is denied for this coin type + */ + case addressDeniedForCoin(address: Address, coinType: String + ) + /** + * Coin type is globally paused for use + */ + case coinTypeGlobalPause(coinType: String + ) + /** + * Certificate is cancelled because randomness could not be generated this + * epoch + */ + case executionCancelledDueToRandomnessUnavailable + /** + * A valid linkage was unable to be determined for the transaction or one + * of its commands. + */ + case invalidLinkage +} + + +#if compiler(>=6) +extension ExecutionError: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeExecutionError: FfiConverterRustBuffer { + typealias SwiftType = ExecutionError + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ExecutionError { + let variant: Int32 = try readInt(&buf) + switch variant { + + case 1: return .insufficientGas + + case 2: return .invalidGasObject + + case 3: return .invariantViolation + + case 4: return .featureNotYetSupported + + case 5: return .objectTooBig(objectSize: try FfiConverterUInt64.read(from: &buf), maxObjectSize: try FfiConverterUInt64.read(from: &buf) + ) + + case 6: return .packageTooBig(objectSize: try FfiConverterUInt64.read(from: &buf), maxObjectSize: try FfiConverterUInt64.read(from: &buf) + ) + + case 7: return .circularObjectOwnership(object: try FfiConverterTypeObjectId.read(from: &buf) + ) + + case 8: return .insufficientCoinBalance + + case 9: return .coinBalanceOverflow + + case 10: return .publishErrorNonZeroAddress + + case 11: return .iotaMoveVerification + + case 12: return .movePrimitiveRuntime(location: try FfiConverterOptionTypeMoveLocation.read(from: &buf) + ) + + case 13: return .moveAbort(location: try FfiConverterTypeMoveLocation.read(from: &buf), code: try FfiConverterUInt64.read(from: &buf) + ) + + case 14: return .vmVerificationOrDeserialization + + case 15: return .vmInvariantViolation + + case 16: return .functionNotFound + + case 17: return .arityMismatch + + case 18: return .typeArityMismatch + + case 19: return .nonEntryFunctionInvoked + + case 20: return .commandArgument(argument: try FfiConverterUInt16.read(from: &buf), kind: try FfiConverterTypeCommandArgumentError.read(from: &buf) + ) + + case 21: return .typeArgument(typeArgument: try FfiConverterUInt16.read(from: &buf), kind: try FfiConverterTypeTypeArgumentError.read(from: &buf) + ) + + case 22: return .unusedValueWithoutDrop(result: try FfiConverterUInt16.read(from: &buf), subresult: try FfiConverterUInt16.read(from: &buf) + ) + + case 23: return .invalidPublicFunctionReturnType(index: try FfiConverterUInt16.read(from: &buf) + ) + + case 24: return .invalidTransferObject + + case 25: return .effectsTooLarge(currentSize: try FfiConverterUInt64.read(from: &buf), maxSize: try FfiConverterUInt64.read(from: &buf) + ) + + case 26: return .publishUpgradeMissingDependency + + case 27: return .publishUpgradeDependencyDowngrade + + case 28: return .packageUpgrade(kind: try FfiConverterTypePackageUpgradeError.read(from: &buf) + ) + + case 29: return .writtenObjectsTooLarge(objectSize: try FfiConverterUInt64.read(from: &buf), maxObjectSize: try FfiConverterUInt64.read(from: &buf) + ) + + case 30: return .certificateDenied + + case 31: return .iotaMoveVerificationTimeout + + case 32: return .sharedObjectOperationNotAllowed + + case 33: return .inputObjectDeleted + + case 34: return .executionCancelledDueToSharedObjectCongestion(congestedObjects: try FfiConverterSequenceTypeObjectId.read(from: &buf) + ) + + case 35: return .executionCancelledDueToSharedObjectCongestionV2(congestedObjects: try FfiConverterSequenceTypeObjectId.read(from: &buf), suggestedGasPrice: try FfiConverterUInt64.read(from: &buf) + ) + + case 36: return .addressDeniedForCoin(address: try FfiConverterTypeAddress.read(from: &buf), coinType: try FfiConverterString.read(from: &buf) + ) + + case 37: return .coinTypeGlobalPause(coinType: try FfiConverterString.read(from: &buf) + ) + + case 38: return .executionCancelledDueToRandomnessUnavailable + + case 39: return .invalidLinkage + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: ExecutionError, into buf: inout [UInt8]) { + switch value { + + + case .insufficientGas: + writeInt(&buf, Int32(1)) + + + case .invalidGasObject: + writeInt(&buf, Int32(2)) + + + case .invariantViolation: + writeInt(&buf, Int32(3)) + + + case .featureNotYetSupported: + writeInt(&buf, Int32(4)) + + + case let .objectTooBig(objectSize,maxObjectSize): + writeInt(&buf, Int32(5)) + FfiConverterUInt64.write(objectSize, into: &buf) + FfiConverterUInt64.write(maxObjectSize, into: &buf) + + + case let .packageTooBig(objectSize,maxObjectSize): + writeInt(&buf, Int32(6)) + FfiConverterUInt64.write(objectSize, into: &buf) + FfiConverterUInt64.write(maxObjectSize, into: &buf) + + + case let .circularObjectOwnership(object): + writeInt(&buf, Int32(7)) + FfiConverterTypeObjectId.write(object, into: &buf) + + + case .insufficientCoinBalance: + writeInt(&buf, Int32(8)) + + + case .coinBalanceOverflow: + writeInt(&buf, Int32(9)) + + + case .publishErrorNonZeroAddress: + writeInt(&buf, Int32(10)) + + + case .iotaMoveVerification: + writeInt(&buf, Int32(11)) + + + case let .movePrimitiveRuntime(location): + writeInt(&buf, Int32(12)) + FfiConverterOptionTypeMoveLocation.write(location, into: &buf) + + + case let .moveAbort(location,code): + writeInt(&buf, Int32(13)) + FfiConverterTypeMoveLocation.write(location, into: &buf) + FfiConverterUInt64.write(code, into: &buf) + + + case .vmVerificationOrDeserialization: + writeInt(&buf, Int32(14)) + + + case .vmInvariantViolation: + writeInt(&buf, Int32(15)) + + + case .functionNotFound: + writeInt(&buf, Int32(16)) + + + case .arityMismatch: + writeInt(&buf, Int32(17)) + + + case .typeArityMismatch: + writeInt(&buf, Int32(18)) + + + case .nonEntryFunctionInvoked: + writeInt(&buf, Int32(19)) + + + case let .commandArgument(argument,kind): + writeInt(&buf, Int32(20)) + FfiConverterUInt16.write(argument, into: &buf) + FfiConverterTypeCommandArgumentError.write(kind, into: &buf) + + + case let .typeArgument(typeArgument,kind): + writeInt(&buf, Int32(21)) + FfiConverterUInt16.write(typeArgument, into: &buf) + FfiConverterTypeTypeArgumentError.write(kind, into: &buf) + + + case let .unusedValueWithoutDrop(result,subresult): + writeInt(&buf, Int32(22)) + FfiConverterUInt16.write(result, into: &buf) + FfiConverterUInt16.write(subresult, into: &buf) + + + case let .invalidPublicFunctionReturnType(index): + writeInt(&buf, Int32(23)) + FfiConverterUInt16.write(index, into: &buf) + + + case .invalidTransferObject: + writeInt(&buf, Int32(24)) + + + case let .effectsTooLarge(currentSize,maxSize): + writeInt(&buf, Int32(25)) + FfiConverterUInt64.write(currentSize, into: &buf) + FfiConverterUInt64.write(maxSize, into: &buf) + + + case .publishUpgradeMissingDependency: + writeInt(&buf, Int32(26)) + + + case .publishUpgradeDependencyDowngrade: + writeInt(&buf, Int32(27)) + + + case let .packageUpgrade(kind): + writeInt(&buf, Int32(28)) + FfiConverterTypePackageUpgradeError.write(kind, into: &buf) + + + case let .writtenObjectsTooLarge(objectSize,maxObjectSize): + writeInt(&buf, Int32(29)) + FfiConverterUInt64.write(objectSize, into: &buf) + FfiConverterUInt64.write(maxObjectSize, into: &buf) + + + case .certificateDenied: + writeInt(&buf, Int32(30)) + + + case .iotaMoveVerificationTimeout: + writeInt(&buf, Int32(31)) + + + case .sharedObjectOperationNotAllowed: + writeInt(&buf, Int32(32)) + + + case .inputObjectDeleted: + writeInt(&buf, Int32(33)) + + + case let .executionCancelledDueToSharedObjectCongestion(congestedObjects): + writeInt(&buf, Int32(34)) + FfiConverterSequenceTypeObjectId.write(congestedObjects, into: &buf) + + + case let .executionCancelledDueToSharedObjectCongestionV2(congestedObjects,suggestedGasPrice): + writeInt(&buf, Int32(35)) + FfiConverterSequenceTypeObjectId.write(congestedObjects, into: &buf) + FfiConverterUInt64.write(suggestedGasPrice, into: &buf) + + + case let .addressDeniedForCoin(address,coinType): + writeInt(&buf, Int32(36)) + FfiConverterTypeAddress.write(address, into: &buf) + FfiConverterString.write(coinType, into: &buf) + + + case let .coinTypeGlobalPause(coinType): + writeInt(&buf, Int32(37)) + FfiConverterString.write(coinType, into: &buf) + + + case .executionCancelledDueToRandomnessUnavailable: + writeInt(&buf, Int32(38)) + + + case .invalidLinkage: + writeInt(&buf, Int32(39)) + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeExecutionError_lift(_ buf: RustBuffer) throws -> ExecutionError { + return try FfiConverterTypeExecutionError.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeExecutionError_lower(_ value: ExecutionError) -> RustBuffer { + return FfiConverterTypeExecutionError.lower(value) +} + + + + + + +// Note that we don't yet support `indirect` for enums. +// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion. +/** + * 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) + * ```xx + */ + +public enum ExecutionStatus { + + /** + * The Transaction successfully executed. + */ + case 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. + */ + case failure( + /** + * The error encountered during execution. + */error: ExecutionError, + /** + * The command, if any, during which the error occurred. + */command: UInt64? + ) +} + + +#if compiler(>=6) +extension ExecutionStatus: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeExecutionStatus: FfiConverterRustBuffer { + typealias SwiftType = ExecutionStatus + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ExecutionStatus { + let variant: Int32 = try readInt(&buf) + switch variant { + + case 1: return .success + + case 2: return .failure(error: try FfiConverterTypeExecutionError.read(from: &buf), command: try FfiConverterOptionUInt64.read(from: &buf) + ) + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: ExecutionStatus, into buf: inout [UInt8]) { + switch value { + + + case .success: + writeInt(&buf, Int32(1)) + + + case let .failure(error,command): + writeInt(&buf, Int32(2)) + FfiConverterTypeExecutionError.write(error, into: &buf) + FfiConverterOptionUInt64.write(command, into: &buf) + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeExecutionStatus_lift(_ buf: RustBuffer) throws -> ExecutionStatus { + return try FfiConverterTypeExecutionStatus.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeExecutionStatus_lower(_ value: ExecutionStatus) -> RustBuffer { + return FfiConverterTypeExecutionStatus.lower(value) +} + + + + + + +// Note that we don't yet support `indirect` for enums. +// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion. + +public enum Feature { + + case analytics + case coins + case dynamicFields + case subscriptions + case systemState +} + + +#if compiler(>=6) +extension Feature: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeFeature: FfiConverterRustBuffer { + typealias SwiftType = Feature + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Feature { + let variant: Int32 = try readInt(&buf) + switch variant { + + case 1: return .analytics + + case 2: return .coins + + case 3: return .dynamicFields + + case 4: return .subscriptions + + case 5: return .systemState + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: Feature, into buf: inout [UInt8]) { + switch value { + + + case .analytics: + writeInt(&buf, Int32(1)) + + + case .coins: + writeInt(&buf, Int32(2)) + + + case .dynamicFields: + writeInt(&buf, Int32(3)) + + + case .subscriptions: + writeInt(&buf, Int32(4)) + + + case .systemState: + writeInt(&buf, Int32(5)) + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeFeature_lift(_ buf: RustBuffer) throws -> Feature { + return try FfiConverterTypeFeature.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeFeature_lower(_ value: Feature) -> RustBuffer { + return FfiConverterTypeFeature.lower(value) +} + + +extension Feature: Equatable, Hashable {} + + + + + + +// Note that we don't yet support `indirect` for enums. +// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion. + +public enum IdOperation { + + case none + case created + case deleted +} + + +#if compiler(>=6) +extension IdOperation: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeIdOperation: FfiConverterRustBuffer { + typealias SwiftType = IdOperation + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> IdOperation { + let variant: Int32 = try readInt(&buf) + switch variant { + + case 1: return .none + + case 2: return .created + + case 3: return .deleted + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: IdOperation, into buf: inout [UInt8]) { + switch value { + + + case .none: + writeInt(&buf, Int32(1)) + + + case .created: + writeInt(&buf, Int32(2)) + + + case .deleted: + writeInt(&buf, Int32(3)) + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeIdOperation_lift(_ buf: RustBuffer) throws -> IdOperation { + return try FfiConverterTypeIdOperation.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeIdOperation_lower(_ value: IdOperation) -> RustBuffer { + return FfiConverterTypeIdOperation.lower(value) +} + + +extension IdOperation: Equatable, Hashable {} + + + + + + +// Note that we don't yet support `indirect` for enums. +// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion. + +public enum MoveAbility { + + case copy + case drop + case key + case store +} + + +#if compiler(>=6) +extension MoveAbility: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMoveAbility: FfiConverterRustBuffer { + typealias SwiftType = MoveAbility + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MoveAbility { + let variant: Int32 = try readInt(&buf) + switch variant { + + case 1: return .copy + + case 2: return .drop + + case 3: return .key + + case 4: return .store + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: MoveAbility, into buf: inout [UInt8]) { + switch value { + + + case .copy: + writeInt(&buf, Int32(1)) + + + case .drop: + writeInt(&buf, Int32(2)) + + + case .key: + writeInt(&buf, Int32(3)) + + + case .store: + writeInt(&buf, Int32(4)) + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveAbility_lift(_ buf: RustBuffer) throws -> MoveAbility { + return try FfiConverterTypeMoveAbility.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveAbility_lower(_ value: MoveAbility) -> RustBuffer { + return FfiConverterTypeMoveAbility.lower(value) +} + + +extension MoveAbility: Equatable, Hashable {} + + + + + + +// Note that we don't yet support `indirect` for enums. +// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion. + +public enum MoveVisibility { + + case `public` + case `private` + case friend +} + + +#if compiler(>=6) +extension MoveVisibility: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeMoveVisibility: FfiConverterRustBuffer { + typealias SwiftType = MoveVisibility + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MoveVisibility { + let variant: Int32 = try readInt(&buf) + switch variant { + + case 1: return .`public` + + case 2: return .`private` + + case 3: return .friend + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: MoveVisibility, into buf: inout [UInt8]) { + switch value { + + + case .`public`: + writeInt(&buf, Int32(1)) + + + case .`private`: + writeInt(&buf, Int32(2)) + + + case .friend: + writeInt(&buf, Int32(3)) + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveVisibility_lift(_ buf: RustBuffer) throws -> MoveVisibility { + return try FfiConverterTypeMoveVisibility.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeMoveVisibility_lower(_ value: MoveVisibility) -> RustBuffer { + return FfiConverterTypeMoveVisibility.lower(value) +} + + +extension MoveVisibility: Equatable, Hashable {} + + + + + + +// Note that we don't yet support `indirect` for enums. +// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion. +/** + * State of an object prior to execution + * + * If an object exists (at root-level) in the store prior to this transaction, + * it should be Exist, otherwise it's NonExist, e.g. wrapped objects should be + * NonExist. + * + * # BCS + * + * The BCS serialized form for this type is defined by the following ABNF: + * + * ```text + * object-in = object-in-not-exist / object-in-exist + * + * object-in-not-exist = %x00 + * object-in-exist = %x01 u64 digest owner + * ``` + */ + +public enum ObjectIn { + + case notExist + /** + * The old version, digest and owner. + */ + case exist(version: UInt64, digest: ObjectDigest, owner: Owner + ) +} + + +#if compiler(>=6) +extension ObjectIn: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeObjectIn: FfiConverterRustBuffer { + typealias SwiftType = ObjectIn + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ObjectIn { + let variant: Int32 = try readInt(&buf) + switch variant { + + case 1: return .notExist + + case 2: return .exist(version: try FfiConverterUInt64.read(from: &buf), digest: try FfiConverterTypeObjectDigest.read(from: &buf), owner: try FfiConverterTypeOwner.read(from: &buf) + ) + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: ObjectIn, into buf: inout [UInt8]) { + switch value { + + + case .notExist: + writeInt(&buf, Int32(1)) + + + case let .exist(version,digest,owner): + writeInt(&buf, Int32(2)) + FfiConverterUInt64.write(version, into: &buf) + FfiConverterTypeObjectDigest.write(digest, into: &buf) + FfiConverterTypeOwner.write(owner, into: &buf) + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeObjectIn_lift(_ buf: RustBuffer) throws -> ObjectIn { + return try FfiConverterTypeObjectIn.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeObjectIn_lower(_ value: ObjectIn) -> RustBuffer { + return FfiConverterTypeObjectIn.lower(value) +} + + + + + + +// Note that we don't yet support `indirect` for enums. +// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion. +/** + * 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-not-exist + * =/ object-out-object-write + * =/ object-out-package-write + * + * + * object-out-not-exist = %x00 + * object-out-object-write = %x01 digest owner + * object-out-package-write = %x02 version digest + * ``` + */ + +public enum ObjectOut { + + /** + * Same definition as in ObjectIn. + */ + case notExist + /** + * Any written object, including all of mutated, created, unwrapped today. + */ + case objectWrite(digest: ObjectDigest, owner: Owner + ) + /** + * Packages writes need to be tracked separately with version because + * we don't use lamport version for package publish and upgrades. + */ + case packageWrite(version: UInt64, digest: ObjectDigest + ) +} + + +#if compiler(>=6) +extension ObjectOut: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeObjectOut: FfiConverterRustBuffer { + typealias SwiftType = ObjectOut + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ObjectOut { + let variant: Int32 = try readInt(&buf) + switch variant { + + case 1: return .notExist + + case 2: return .objectWrite(digest: try FfiConverterTypeObjectDigest.read(from: &buf), owner: try FfiConverterTypeOwner.read(from: &buf) + ) + + case 3: return .packageWrite(version: try FfiConverterUInt64.read(from: &buf), digest: try FfiConverterTypeObjectDigest.read(from: &buf) + ) + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: ObjectOut, into buf: inout [UInt8]) { + switch value { + + + case .notExist: + writeInt(&buf, Int32(1)) + + + case let .objectWrite(digest,owner): + writeInt(&buf, Int32(2)) + FfiConverterTypeObjectDigest.write(digest, into: &buf) + FfiConverterTypeOwner.write(owner, into: &buf) + + + case let .packageWrite(version,digest): + writeInt(&buf, Int32(3)) + FfiConverterUInt64.write(version, into: &buf) + FfiConverterTypeObjectDigest.write(digest, into: &buf) + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeObjectOut_lift(_ buf: RustBuffer) throws -> ObjectOut { + return try FfiConverterTypeObjectOut.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeObjectOut_lower(_ value: ObjectOut) -> RustBuffer { + return FfiConverterTypeObjectOut.lower(value) +} + + + + + + +// Note that we don't yet support `indirect` for enums. +// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion. +/** + * 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 + * ``` + */ + +public enum PackageUpgradeError { + + /** + * Unable to fetch package + */ + case unableToFetchPackage(packageId: ObjectId + ) + /** + * Object is not a package + */ + case notAPackage(objectId: ObjectId + ) + /** + * Package upgrade is incompatible with previous version + */ + case incompatibleUpgrade + /** + * Digest in upgrade ticket and computed digest differ + */ + case digestDoesNotMatch(digest: Digest + ) + /** + * Upgrade policy is not valid + */ + case unknownUpgradePolicy(policy: UInt8 + ) + /** + * PackageId does not matach PackageId in upgrade ticket + */ + case packageIdDoesNotMatch(packageId: ObjectId, ticketId: ObjectId + ) +} + + +#if compiler(>=6) +extension PackageUpgradeError: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypePackageUpgradeError: FfiConverterRustBuffer { + typealias SwiftType = PackageUpgradeError + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PackageUpgradeError { + let variant: Int32 = try readInt(&buf) + switch variant { + + case 1: return .unableToFetchPackage(packageId: try FfiConverterTypeObjectId.read(from: &buf) + ) + + case 2: return .notAPackage(objectId: try FfiConverterTypeObjectId.read(from: &buf) + ) + + case 3: return .incompatibleUpgrade + + case 4: return .digestDoesNotMatch(digest: try FfiConverterTypeDigest.read(from: &buf) + ) + + case 5: return .unknownUpgradePolicy(policy: try FfiConverterUInt8.read(from: &buf) + ) + + case 6: return .packageIdDoesNotMatch(packageId: try FfiConverterTypeObjectId.read(from: &buf), ticketId: try FfiConverterTypeObjectId.read(from: &buf) + ) + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: PackageUpgradeError, into buf: inout [UInt8]) { + switch value { + + + case let .unableToFetchPackage(packageId): + writeInt(&buf, Int32(1)) + FfiConverterTypeObjectId.write(packageId, into: &buf) + + + case let .notAPackage(objectId): + writeInt(&buf, Int32(2)) + FfiConverterTypeObjectId.write(objectId, into: &buf) + + + case .incompatibleUpgrade: + writeInt(&buf, Int32(3)) + + + case let .digestDoesNotMatch(digest): + writeInt(&buf, Int32(4)) + FfiConverterTypeDigest.write(digest, into: &buf) + + + case let .unknownUpgradePolicy(policy): + writeInt(&buf, Int32(5)) + FfiConverterUInt8.write(policy, into: &buf) + + + case let .packageIdDoesNotMatch(packageId,ticketId): + writeInt(&buf, Int32(6)) + FfiConverterTypeObjectId.write(packageId, into: &buf) + FfiConverterTypeObjectId.write(ticketId, into: &buf) + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypePackageUpgradeError_lift(_ buf: RustBuffer) throws -> PackageUpgradeError { + return try FfiConverterTypePackageUpgradeError.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypePackageUpgradeError_lower(_ value: PackageUpgradeError) -> RustBuffer { + return FfiConverterTypePackageUpgradeError.lower(value) +} + + + + + + + +public enum SdkFfiError: Swift.Error { + + + + case Generic(message: String) + +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeSdkFfiError: FfiConverterRustBuffer { + typealias SwiftType = SdkFfiError + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SdkFfiError { + let variant: Int32 = try readInt(&buf) + switch variant { + + + + + case 1: return .Generic( + message: try FfiConverterString.read(from: &buf) + ) + + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: SdkFfiError, into buf: inout [UInt8]) { + switch value { + + + + + case .Generic(_ /* message is ignored*/): + writeInt(&buf, Int32(1)) + + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSdkFfiError_lift(_ buf: RustBuffer) throws -> SdkFfiError { + return try FfiConverterTypeSdkFfiError.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSdkFfiError_lower(_ value: SdkFfiError) -> RustBuffer { + return FfiConverterTypeSdkFfiError.lower(value) +} + + +extension SdkFfiError: Equatable, Hashable {} + + + + +extension SdkFfiError: Foundation.LocalizedError { + public var errorDescription: String? { + String(reflecting: self) + } +} + + + + +// Note that we don't yet support `indirect` for enums. +// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion. + +public enum SignatureScheme { + + case ed25519 + case secp256k1 + case secp256r1 + case multisig + case bls12381 + case zkLogin + case passkey +} + + +#if compiler(>=6) +extension SignatureScheme: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeSignatureScheme: FfiConverterRustBuffer { + typealias SwiftType = SignatureScheme + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SignatureScheme { + let variant: Int32 = try readInt(&buf) + switch variant { + + case 1: return .ed25519 + + case 2: return .secp256k1 + + case 3: return .secp256r1 + + case 4: return .multisig + + case 5: return .bls12381 + + case 6: return .zkLogin + + case 7: return .passkey + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: SignatureScheme, into buf: inout [UInt8]) { + switch value { + + + case .ed25519: + writeInt(&buf, Int32(1)) + + + case .secp256k1: + writeInt(&buf, Int32(2)) + + + case .secp256r1: + writeInt(&buf, Int32(3)) + + + case .multisig: + writeInt(&buf, Int32(4)) + + + case .bls12381: + writeInt(&buf, Int32(5)) + + + case .zkLogin: + writeInt(&buf, Int32(6)) + + + case .passkey: + writeInt(&buf, Int32(7)) + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSignatureScheme_lift(_ buf: RustBuffer) throws -> SignatureScheme { + return try FfiConverterTypeSignatureScheme.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeSignatureScheme_lower(_ value: SignatureScheme) -> RustBuffer { + return FfiConverterTypeSignatureScheme.lower(value) +} + + +extension SignatureScheme: Equatable, Hashable {} + + + + + + +// Note that we don't yet support `indirect` for enums. +// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion. + +public enum TransactionBlockKindInput { + + case systemTx + case programmableTx + case genesis + case consensusCommitPrologueV1 + case authenticatorStateUpdateV1 + case randomnessStateUpdate + case endOfEpochTx +} + + +#if compiler(>=6) +extension TransactionBlockKindInput: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeTransactionBlockKindInput: FfiConverterRustBuffer { + typealias SwiftType = TransactionBlockKindInput + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TransactionBlockKindInput { + let variant: Int32 = try readInt(&buf) + switch variant { + + 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 UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: TransactionBlockKindInput, into buf: inout [UInt8]) { + switch value { + + + case .systemTx: + writeInt(&buf, Int32(1)) + + + case .programmableTx: + writeInt(&buf, Int32(2)) + + + case .genesis: + writeInt(&buf, Int32(3)) + + + case .consensusCommitPrologueV1: + writeInt(&buf, Int32(4)) + + + case .authenticatorStateUpdateV1: + writeInt(&buf, Int32(5)) + + + case .randomnessStateUpdate: + writeInt(&buf, Int32(6)) + + + case .endOfEpochTx: + writeInt(&buf, Int32(7)) + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionBlockKindInput_lift(_ buf: RustBuffer) throws -> TransactionBlockKindInput { + return try FfiConverterTypeTransactionBlockKindInput.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionBlockKindInput_lower(_ value: TransactionBlockKindInput) -> RustBuffer { + return FfiConverterTypeTransactionBlockKindInput.lower(value) +} + + +extension TransactionBlockKindInput: Equatable, Hashable {} + + + + + + +// Note that we don't yet support `indirect` for enums. +// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion. +/** + * 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 + * ``` + */ + +public enum TransactionExpiration { + + /** + * The transaction has no expiration + */ + case none + /** + * Validators wont sign a transaction unless the expiration Epoch + * is greater than or equal to the current epoch + */ + case epoch(UInt64 + ) +} + + +#if compiler(>=6) +extension TransactionExpiration: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeTransactionExpiration: FfiConverterRustBuffer { + typealias SwiftType = TransactionExpiration + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TransactionExpiration { + let variant: Int32 = try readInt(&buf) + switch variant { + + case 1: return .none + + case 2: return .epoch(try FfiConverterUInt64.read(from: &buf) + ) + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: TransactionExpiration, into buf: inout [UInt8]) { + switch value { + + + case .none: + writeInt(&buf, Int32(1)) + + + case let .epoch(v1): + writeInt(&buf, Int32(2)) + FfiConverterUInt64.write(v1, into: &buf) + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionExpiration_lift(_ buf: RustBuffer) throws -> TransactionExpiration { + return try FfiConverterTypeTransactionExpiration.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTransactionExpiration_lower(_ value: TransactionExpiration) -> RustBuffer { + return FfiConverterTypeTransactionExpiration.lower(value) +} + + +extension TransactionExpiration: Equatable, Hashable {} + + + + + + +// Note that we don't yet support `indirect` for enums. +// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion. + +public enum TypeArgumentError { + + case typeNotFound + case constraintNotSatisfied +} + + +#if compiler(>=6) +extension TypeArgumentError: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeTypeArgumentError: FfiConverterRustBuffer { + typealias SwiftType = TypeArgumentError + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TypeArgumentError { + let variant: Int32 = try readInt(&buf) + switch variant { + + case 1: return .typeNotFound + + case 2: return .constraintNotSatisfied + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: TypeArgumentError, into buf: inout [UInt8]) { + switch value { + + + case .typeNotFound: + writeInt(&buf, Int32(1)) + + + case .constraintNotSatisfied: + writeInt(&buf, Int32(2)) + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTypeArgumentError_lift(_ buf: RustBuffer) throws -> TypeArgumentError { + return try FfiConverterTypeTypeArgumentError.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeTypeArgumentError_lower(_ value: TypeArgumentError) -> RustBuffer { + return FfiConverterTypeTypeArgumentError.lower(value) +} + + +extension TypeArgumentError: Equatable, Hashable {} + + + + + + +// Note that we don't yet support `indirect` for enums. +// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion. +/** + * 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 + * ``` + */ + +public enum 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. + */ + case readOnlyRoot(version: UInt64, digest: ObjectDigest + ) + /** + * Deleted shared objects that appear mutably/owned in the input. + */ + case mutateDeleted(version: UInt64 + ) + /** + * Deleted shared objects that appear as read-only in the input. + */ + case readDeleted(version: UInt64 + ) + /** + * Shared objects in cancelled transaction. The sequence number embed + * cancellation reason. + */ + case cancelled(version: UInt64 + ) + /** + * Read of a per-epoch config object that should remain the same during an + * epoch. + */ + case perEpochConfig +} + + +#if compiler(>=6) +extension UnchangedSharedKind: Sendable {} +#endif + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeUnchangedSharedKind: FfiConverterRustBuffer { + typealias SwiftType = UnchangedSharedKind + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UnchangedSharedKind { + let variant: Int32 = try readInt(&buf) + switch variant { + + case 1: return .readOnlyRoot(version: try FfiConverterUInt64.read(from: &buf), digest: try FfiConverterTypeObjectDigest.read(from: &buf) + ) + + case 2: return .mutateDeleted(version: try FfiConverterUInt64.read(from: &buf) + ) + + case 3: return .readDeleted(version: try FfiConverterUInt64.read(from: &buf) + ) + + case 4: return .cancelled(version: try FfiConverterUInt64.read(from: &buf) + ) + + case 5: return .perEpochConfig + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: UnchangedSharedKind, into buf: inout [UInt8]) { + switch value { + + + case let .readOnlyRoot(version,digest): + writeInt(&buf, Int32(1)) + FfiConverterUInt64.write(version, into: &buf) + FfiConverterTypeObjectDigest.write(digest, into: &buf) + + + case let .mutateDeleted(version): + writeInt(&buf, Int32(2)) + FfiConverterUInt64.write(version, into: &buf) + + + case let .readDeleted(version): + writeInt(&buf, Int32(3)) + FfiConverterUInt64.write(version, into: &buf) + + + case let .cancelled(version): + writeInt(&buf, Int32(4)) + FfiConverterUInt64.write(version, into: &buf) + + + case .perEpochConfig: + writeInt(&buf, Int32(5)) + + } + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeUnchangedSharedKind_lift(_ buf: RustBuffer) throws -> UnchangedSharedKind { + return try FfiConverterTypeUnchangedSharedKind.lift(buf) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeUnchangedSharedKind_lower(_ value: UnchangedSharedKind) -> RustBuffer { + return FfiConverterTypeUnchangedSharedKind.lower(value) +} + + + + + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionUInt32: FfiConverterRustBuffer { + typealias SwiftType = UInt32? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterUInt32.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterUInt32.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionInt32: FfiConverterRustBuffer { + typealias SwiftType = Int32? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterInt32.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterInt32.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionUInt64: FfiConverterRustBuffer { + typealias SwiftType = UInt64? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterUInt64.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterUInt64.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionBool: FfiConverterRustBuffer { + typealias SwiftType = Bool? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterBool.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterBool.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer { + typealias SwiftType = String? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterString.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterString.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionData: FfiConverterRustBuffer { + typealias SwiftType = Data? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterData.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterData.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeAddress: FfiConverterRustBuffer { + typealias SwiftType = Address? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeAddress.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeAddress.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeArgument: FfiConverterRustBuffer { + typealias SwiftType = Argument? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeArgument.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeArgument.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeBatchSendStatus: FfiConverterRustBuffer { + typealias SwiftType = BatchSendStatus? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeBatchSendStatus.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeBatchSendStatus.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeCheckpointContentsDigest: FfiConverterRustBuffer { + typealias SwiftType = CheckpointContentsDigest? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeCheckpointContentsDigest.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeCheckpointContentsDigest.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeCheckpointDigest: FfiConverterRustBuffer { + typealias SwiftType = CheckpointDigest? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeCheckpointDigest.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeCheckpointDigest.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeEd25519PublicKey: FfiConverterRustBuffer { + typealias SwiftType = Ed25519PublicKey? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeEd25519PublicKey.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeEd25519PublicKey.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeEd25519Signature: FfiConverterRustBuffer { + typealias SwiftType = Ed25519Signature? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeEd25519Signature.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeEd25519Signature.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeEffectsAuxiliaryDataDigest: FfiConverterRustBuffer { + typealias SwiftType = EffectsAuxiliaryDataDigest? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeEffectsAuxiliaryDataDigest.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeEffectsAuxiliaryDataDigest.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeEpoch: FfiConverterRustBuffer { + typealias SwiftType = Epoch? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeEpoch.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeEpoch.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeFaucetReceipt: FfiConverterRustBuffer { + typealias SwiftType = FaucetReceipt? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeFaucetReceipt.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeFaucetReceipt.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeMovePackage: FfiConverterRustBuffer { + typealias SwiftType = MovePackage? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeMovePackage.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeMovePackage.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeMultisigAggregatedSignature: FfiConverterRustBuffer { + typealias SwiftType = MultisigAggregatedSignature? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeMultisigAggregatedSignature.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeMultisigAggregatedSignature.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeObject: FfiConverterRustBuffer { + typealias SwiftType = Object? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeObject.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeObject.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeObjectId: FfiConverterRustBuffer { + typealias SwiftType = ObjectId? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeObjectId.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeObjectId.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypePasskeyAuthenticator: FfiConverterRustBuffer { + typealias SwiftType = PasskeyAuthenticator? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypePasskeyAuthenticator.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypePasskeyAuthenticator.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeSecp256k1PublicKey: FfiConverterRustBuffer { + typealias SwiftType = Secp256k1PublicKey? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeSecp256k1PublicKey.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeSecp256k1PublicKey.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeSecp256k1Signature: FfiConverterRustBuffer { + typealias SwiftType = Secp256k1Signature? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeSecp256k1Signature.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeSecp256k1Signature.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeSecp256r1PublicKey: FfiConverterRustBuffer { + typealias SwiftType = Secp256r1PublicKey? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeSecp256r1PublicKey.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeSecp256r1PublicKey.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeSecp256r1Signature: FfiConverterRustBuffer { + typealias SwiftType = Secp256r1Signature? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeSecp256r1Signature.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeSecp256r1Signature.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeSimpleSignature: FfiConverterRustBuffer { + typealias SwiftType = SimpleSignature? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeSimpleSignature.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeSimpleSignature.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeStructTag: FfiConverterRustBuffer { + typealias SwiftType = StructTag? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeStructTag.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeStructTag.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeTransactionEffects: FfiConverterRustBuffer { + typealias SwiftType = TransactionEffects? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeTransactionEffects.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeTransactionEffects.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeTransactionEventsDigest: FfiConverterRustBuffer { + typealias SwiftType = TransactionEventsDigest? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeTransactionEventsDigest.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeTransactionEventsDigest.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeTypeTag: FfiConverterRustBuffer { + typealias SwiftType = TypeTag? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeTypeTag.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeTypeTag.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeZkLoginAuthenticator: FfiConverterRustBuffer { + typealias SwiftType = ZkLoginAuthenticator? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeZkLoginAuthenticator.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeZkLoginAuthenticator.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeZkLoginPublicIdentifier: FfiConverterRustBuffer { + typealias SwiftType = ZkLoginPublicIdentifier? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeZkLoginPublicIdentifier.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeZkLoginPublicIdentifier.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeCheckpointSummary: FfiConverterRustBuffer { + typealias SwiftType = CheckpointSummary? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeCheckpointSummary.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeCheckpointSummary.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeCoinMetadata: FfiConverterRustBuffer { + typealias SwiftType = CoinMetadata? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeCoinMetadata.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeCoinMetadata.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeDynamicFieldOutput: FfiConverterRustBuffer { + typealias SwiftType = DynamicFieldOutput? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeDynamicFieldOutput.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeDynamicFieldOutput.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeDynamicFieldValue: FfiConverterRustBuffer { + typealias SwiftType = DynamicFieldValue? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeDynamicFieldValue.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeDynamicFieldValue.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeEndOfEpochData: FfiConverterRustBuffer { + typealias SwiftType = EndOfEpochData? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeEndOfEpochData.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeEndOfEpochData.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeEventFilter: FfiConverterRustBuffer { + typealias SwiftType = EventFilter? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeEventFilter.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeEventFilter.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeMoveEnumConnection: FfiConverterRustBuffer { + typealias SwiftType = MoveEnumConnection? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeMoveEnumConnection.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeMoveEnumConnection.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeMoveFunction: FfiConverterRustBuffer { + typealias SwiftType = MoveFunction? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeMoveFunction.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeMoveFunction.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeMoveFunctionConnection: FfiConverterRustBuffer { + typealias SwiftType = MoveFunctionConnection? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeMoveFunctionConnection.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeMoveFunctionConnection.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeMoveLocation: FfiConverterRustBuffer { + typealias SwiftType = MoveLocation? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeMoveLocation.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeMoveLocation.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeMoveModule: FfiConverterRustBuffer { + typealias SwiftType = MoveModule? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeMoveModule.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeMoveModule.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeMoveStruct: FfiConverterRustBuffer { + typealias SwiftType = MoveStruct? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeMoveStruct.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeMoveStruct.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeMoveStructConnection: FfiConverterRustBuffer { + typealias SwiftType = MoveStructConnection? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeMoveStructConnection.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeMoveStructConnection.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeObjectFilter: FfiConverterRustBuffer { + typealias SwiftType = ObjectFilter? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeObjectFilter.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeObjectFilter.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeOpenMoveType: FfiConverterRustBuffer { + typealias SwiftType = OpenMoveType? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeOpenMoveType.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeOpenMoveType.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeProtocolConfigs: FfiConverterRustBuffer { + typealias SwiftType = ProtocolConfigs? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeProtocolConfigs.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeProtocolConfigs.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeSignedTransaction: FfiConverterRustBuffer { + typealias SwiftType = SignedTransaction? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeSignedTransaction.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeSignedTransaction.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeTransactionDataEffects: FfiConverterRustBuffer { + typealias SwiftType = TransactionDataEffects? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeTransactionDataEffects.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeTransactionDataEffects.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeTransactionsFilter: FfiConverterRustBuffer { + typealias SwiftType = TransactionsFilter? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeTransactionsFilter.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeTransactionsFilter.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeValidatorCredentials: FfiConverterRustBuffer { + typealias SwiftType = ValidatorCredentials? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeValidatorCredentials.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeValidatorCredentials.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeMoveVisibility: FfiConverterRustBuffer { + typealias SwiftType = MoveVisibility? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeMoveVisibility.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeMoveVisibility.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeTransactionBlockKindInput: FfiConverterRustBuffer { + typealias SwiftType = TransactionBlockKindInput? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeTransactionBlockKindInput.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeTransactionBlockKindInput.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionSequenceString: FfiConverterRustBuffer { + typealias SwiftType = [String]? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterSequenceString.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterSequenceString.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionSequenceTypeCancelledTransaction: FfiConverterRustBuffer { + typealias SwiftType = [CancelledTransaction]? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterSequenceTypeCancelledTransaction.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterSequenceTypeCancelledTransaction.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionSequenceTypeObjectId: FfiConverterRustBuffer { + typealias SwiftType = [ObjectId]? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterSequenceTypeObjectId.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterSequenceTypeObjectId.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionSequenceTypeMoveEnumVariant: FfiConverterRustBuffer { + typealias SwiftType = [MoveEnumVariant]? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterSequenceTypeMoveEnumVariant.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterSequenceTypeMoveEnumVariant.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionSequenceTypeMoveField: FfiConverterRustBuffer { + typealias SwiftType = [MoveField]? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterSequenceTypeMoveField.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterSequenceTypeMoveField.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionSequenceTypeMoveFunctionTypeParameter: FfiConverterRustBuffer { + typealias SwiftType = [MoveFunctionTypeParameter]? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterSequenceTypeMoveFunctionTypeParameter.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterSequenceTypeMoveFunctionTypeParameter.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionSequenceTypeMoveStructTypeParameter: FfiConverterRustBuffer { + typealias SwiftType = [MoveStructTypeParameter]? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterSequenceTypeMoveStructTypeParameter.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterSequenceTypeMoveStructTypeParameter.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionSequenceTypeObjectRef: FfiConverterRustBuffer { + typealias SwiftType = [ObjectRef]? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterSequenceTypeObjectRef.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterSequenceTypeObjectRef.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionSequenceTypeOpenMoveType: FfiConverterRustBuffer { + typealias SwiftType = [OpenMoveType]? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterSequenceTypeOpenMoveType.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterSequenceTypeOpenMoveType.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionSequenceTypeMoveAbility: FfiConverterRustBuffer { + typealias SwiftType = [MoveAbility]? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterSequenceTypeMoveAbility.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterSequenceTypeMoveAbility.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeBase64: FfiConverterRustBuffer { + typealias SwiftType = Base64? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeBase64.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeBase64.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeBigInt: FfiConverterRustBuffer { + typealias SwiftType = BigInt? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeBigInt.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeBigInt.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterOptionTypeValue: FfiConverterRustBuffer { + typealias SwiftType = Value? + + public static func write(_ value: SwiftType, into buf: inout [UInt8]) { + guard let value = value else { + writeInt(&buf, Int8(0)) + return + } + writeInt(&buf, Int8(1)) + FfiConverterTypeValue.write(value, into: &buf) + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType { + switch try readInt(&buf) as Int8 { + case 0: return nil + case 1: return try FfiConverterTypeValue.read(from: &buf) + default: throw UniffiInternalError.unexpectedOptionalTag + } + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceString: FfiConverterRustBuffer { + typealias SwiftType = [String] + + public static func write(_ value: [String], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterString.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [String] { + let len: Int32 = try readInt(&buf) + var seq = [String]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterString.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceData: FfiConverterRustBuffer { + typealias SwiftType = [Data] + + public static func write(_ value: [Data], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterData.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [Data] { + let len: Int32 = try readInt(&buf) + var seq = [Data]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterData.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeArgument: FfiConverterRustBuffer { + typealias SwiftType = [Argument] + + public static func write(_ value: [Argument], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeArgument.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [Argument] { + let len: Int32 = try readInt(&buf) + var seq = [Argument]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeArgument.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeCancelledTransaction: FfiConverterRustBuffer { + typealias SwiftType = [CancelledTransaction] + + public static func write(_ value: [CancelledTransaction], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeCancelledTransaction.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [CancelledTransaction] { + let len: Int32 = try readInt(&buf) + var seq = [CancelledTransaction]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeCancelledTransaction.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeCheckpointCommitment: FfiConverterRustBuffer { + typealias SwiftType = [CheckpointCommitment] + + public static func write(_ value: [CheckpointCommitment], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeCheckpointCommitment.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [CheckpointCommitment] { + let len: Int32 = try readInt(&buf) + var seq = [CheckpointCommitment]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeCheckpointCommitment.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeCoin: FfiConverterRustBuffer { + typealias SwiftType = [Coin] + + public static func write(_ value: [Coin], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeCoin.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [Coin] { + let len: Int32 = try readInt(&buf) + var seq = [Coin]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeCoin.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeCommand: FfiConverterRustBuffer { + typealias SwiftType = [Command] + + public static func write(_ value: [Command], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeCommand.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [Command] { + let len: Int32 = try readInt(&buf) + var seq = [Command]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeCommand.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeEndOfEpochTransactionKind: FfiConverterRustBuffer { + typealias SwiftType = [EndOfEpochTransactionKind] + + public static func write(_ value: [EndOfEpochTransactionKind], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeEndOfEpochTransactionKind.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [EndOfEpochTransactionKind] { + let len: Int32 = try readInt(&buf) + var seq = [EndOfEpochTransactionKind]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeEndOfEpochTransactionKind.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeEpoch: FfiConverterRustBuffer { + typealias SwiftType = [Epoch] + + public static func write(_ value: [Epoch], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeEpoch.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [Epoch] { + let len: Int32 = try readInt(&buf) + var seq = [Epoch]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeEpoch.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeExecutionTimeObservation: FfiConverterRustBuffer { + typealias SwiftType = [ExecutionTimeObservation] + + public static func write(_ value: [ExecutionTimeObservation], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeExecutionTimeObservation.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [ExecutionTimeObservation] { + let len: Int32 = try readInt(&buf) + var seq = [ExecutionTimeObservation]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeExecutionTimeObservation.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeGenesisObject: FfiConverterRustBuffer { + typealias SwiftType = [GenesisObject] + + public static func write(_ value: [GenesisObject], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeGenesisObject.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [GenesisObject] { + let len: Int32 = try readInt(&buf) + var seq = [GenesisObject]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeGenesisObject.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeInput: FfiConverterRustBuffer { + typealias SwiftType = [Input] + + public static func write(_ value: [Input], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeInput.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [Input] { + let len: Int32 = try readInt(&buf) + var seq = [Input]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeInput.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeMovePackage: FfiConverterRustBuffer { + typealias SwiftType = [MovePackage] + + public static func write(_ value: [MovePackage], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeMovePackage.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MovePackage] { + let len: Int32 = try readInt(&buf) + var seq = [MovePackage]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeMovePackage.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeMultisigMember: FfiConverterRustBuffer { + typealias SwiftType = [MultisigMember] + + public static func write(_ value: [MultisigMember], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeMultisigMember.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MultisigMember] { + let len: Int32 = try readInt(&buf) + var seq = [MultisigMember]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeMultisigMember.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeMultisigMemberSignature: FfiConverterRustBuffer { + typealias SwiftType = [MultisigMemberSignature] + + public static func write(_ value: [MultisigMemberSignature], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeMultisigMemberSignature.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MultisigMemberSignature] { + let len: Int32 = try readInt(&buf) + var seq = [MultisigMemberSignature]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeMultisigMemberSignature.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeObject: FfiConverterRustBuffer { + typealias SwiftType = [Object] + + public static func write(_ value: [Object], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeObject.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [Object] { + let len: Int32 = try readInt(&buf) + var seq = [Object]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeObject.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeObjectId: FfiConverterRustBuffer { + typealias SwiftType = [ObjectId] + + public static func write(_ value: [ObjectId], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeObjectId.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [ObjectId] { + let len: Int32 = try readInt(&buf) + var seq = [ObjectId]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeObjectId.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeSystemPackage: FfiConverterRustBuffer { + typealias SwiftType = [SystemPackage] + + public static func write(_ value: [SystemPackage], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeSystemPackage.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [SystemPackage] { + let len: Int32 = try readInt(&buf) + var seq = [SystemPackage]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeSystemPackage.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeTransactionDigest: FfiConverterRustBuffer { + typealias SwiftType = [TransactionDigest] + + public static func write(_ value: [TransactionDigest], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeTransactionDigest.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [TransactionDigest] { + let len: Int32 = try readInt(&buf) + var seq = [TransactionDigest]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeTransactionDigest.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeTransactionEffects: FfiConverterRustBuffer { + typealias SwiftType = [TransactionEffects] + + public static func write(_ value: [TransactionEffects], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeTransactionEffects.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [TransactionEffects] { + let len: Int32 = try readInt(&buf) + var seq = [TransactionEffects]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeTransactionEffects.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeTypeTag: FfiConverterRustBuffer { + typealias SwiftType = [TypeTag] + + public static func write(_ value: [TypeTag], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeTypeTag.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [TypeTag] { + let len: Int32 = try readInt(&buf) + var seq = [TypeTag]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeTypeTag.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeUserSignature: FfiConverterRustBuffer { + typealias SwiftType = [UserSignature] + + public static func write(_ value: [UserSignature], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeUserSignature.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [UserSignature] { + let len: Int32 = try readInt(&buf) + var seq = [UserSignature]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeUserSignature.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeValidatorExecutionTimeObservation: FfiConverterRustBuffer { + typealias SwiftType = [ValidatorExecutionTimeObservation] + + public static func write(_ value: [ValidatorExecutionTimeObservation], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeValidatorExecutionTimeObservation.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [ValidatorExecutionTimeObservation] { + let len: Int32 = try readInt(&buf) + var seq = [ValidatorExecutionTimeObservation]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeValidatorExecutionTimeObservation.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeVersionAssignment: FfiConverterRustBuffer { + typealias SwiftType = [VersionAssignment] + + public static func write(_ value: [VersionAssignment], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeVersionAssignment.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [VersionAssignment] { + let len: Int32 = try readInt(&buf) + var seq = [VersionAssignment]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeVersionAssignment.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeActiveJwk: FfiConverterRustBuffer { + typealias SwiftType = [ActiveJwk] + + public static func write(_ value: [ActiveJwk], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeActiveJwk.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [ActiveJwk] { + let len: Int32 = try readInt(&buf) + var seq = [ActiveJwk]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeActiveJwk.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeChangedObject: FfiConverterRustBuffer { + typealias SwiftType = [ChangedObject] + + public static func write(_ value: [ChangedObject], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeChangedObject.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [ChangedObject] { + let len: Int32 = try readInt(&buf) + var seq = [ChangedObject]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeChangedObject.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeCheckpointSummary: FfiConverterRustBuffer { + typealias SwiftType = [CheckpointSummary] + + public static func write(_ value: [CheckpointSummary], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeCheckpointSummary.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [CheckpointSummary] { + let len: Int32 = try readInt(&buf) + var seq = [CheckpointSummary]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeCheckpointSummary.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeDynamicFieldOutput: FfiConverterRustBuffer { + typealias SwiftType = [DynamicFieldOutput] + + public static func write(_ value: [DynamicFieldOutput], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeDynamicFieldOutput.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [DynamicFieldOutput] { + let len: Int32 = try readInt(&buf) + var seq = [DynamicFieldOutput]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeDynamicFieldOutput.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeEvent: FfiConverterRustBuffer { + typealias SwiftType = [Event] + + public static func write(_ value: [Event], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeEvent.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [Event] { + let len: Int32 = try readInt(&buf) + var seq = [Event]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeEvent.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeMoveEnum: FfiConverterRustBuffer { + typealias SwiftType = [MoveEnum] + + public static func write(_ value: [MoveEnum], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeMoveEnum.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MoveEnum] { + let len: Int32 = try readInt(&buf) + var seq = [MoveEnum]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeMoveEnum.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeMoveEnumVariant: FfiConverterRustBuffer { + typealias SwiftType = [MoveEnumVariant] + + public static func write(_ value: [MoveEnumVariant], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeMoveEnumVariant.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MoveEnumVariant] { + let len: Int32 = try readInt(&buf) + var seq = [MoveEnumVariant]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeMoveEnumVariant.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeMoveField: FfiConverterRustBuffer { + typealias SwiftType = [MoveField] + + public static func write(_ value: [MoveField], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeMoveField.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MoveField] { + let len: Int32 = try readInt(&buf) + var seq = [MoveField]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeMoveField.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeMoveFunction: FfiConverterRustBuffer { + typealias SwiftType = [MoveFunction] + + public static func write(_ value: [MoveFunction], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeMoveFunction.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MoveFunction] { + let len: Int32 = try readInt(&buf) + var seq = [MoveFunction]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeMoveFunction.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeMoveFunctionTypeParameter: FfiConverterRustBuffer { + typealias SwiftType = [MoveFunctionTypeParameter] + + public static func write(_ value: [MoveFunctionTypeParameter], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeMoveFunctionTypeParameter.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MoveFunctionTypeParameter] { + let len: Int32 = try readInt(&buf) + var seq = [MoveFunctionTypeParameter]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeMoveFunctionTypeParameter.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeMoveModuleQuery: FfiConverterRustBuffer { + typealias SwiftType = [MoveModuleQuery] + + public static func write(_ value: [MoveModuleQuery], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeMoveModuleQuery.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MoveModuleQuery] { + let len: Int32 = try readInt(&buf) + var seq = [MoveModuleQuery]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeMoveModuleQuery.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeMoveStructQuery: FfiConverterRustBuffer { + typealias SwiftType = [MoveStructQuery] + + public static func write(_ value: [MoveStructQuery], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeMoveStructQuery.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MoveStructQuery] { + let len: Int32 = try readInt(&buf) + var seq = [MoveStructQuery]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeMoveStructQuery.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeMoveStructTypeParameter: FfiConverterRustBuffer { + typealias SwiftType = [MoveStructTypeParameter] + + public static func write(_ value: [MoveStructTypeParameter], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeMoveStructTypeParameter.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MoveStructTypeParameter] { + let len: Int32 = try readInt(&buf) + var seq = [MoveStructTypeParameter]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeMoveStructTypeParameter.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeObjectRef: FfiConverterRustBuffer { + typealias SwiftType = [ObjectRef] + + public static func write(_ value: [ObjectRef], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeObjectRef.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [ObjectRef] { + let len: Int32 = try readInt(&buf) + var seq = [ObjectRef]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeObjectRef.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeObjectReference: FfiConverterRustBuffer { + typealias SwiftType = [ObjectReference] + + public static func write(_ value: [ObjectReference], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeObjectReference.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [ObjectReference] { + let len: Int32 = try readInt(&buf) + var seq = [ObjectReference]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeObjectReference.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeOpenMoveType: FfiConverterRustBuffer { + typealias SwiftType = [OpenMoveType] + + public static func write(_ value: [OpenMoveType], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeOpenMoveType.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [OpenMoveType] { + let len: Int32 = try readInt(&buf) + var seq = [OpenMoveType]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeOpenMoveType.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeProtocolConfigAttr: FfiConverterRustBuffer { + typealias SwiftType = [ProtocolConfigAttr] + + public static func write(_ value: [ProtocolConfigAttr], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeProtocolConfigAttr.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [ProtocolConfigAttr] { + let len: Int32 = try readInt(&buf) + var seq = [ProtocolConfigAttr]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeProtocolConfigAttr.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeProtocolConfigFeatureFlag: FfiConverterRustBuffer { + typealias SwiftType = [ProtocolConfigFeatureFlag] + + public static func write(_ value: [ProtocolConfigFeatureFlag], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeProtocolConfigFeatureFlag.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [ProtocolConfigFeatureFlag] { + let len: Int32 = try readInt(&buf) + var seq = [ProtocolConfigFeatureFlag]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeProtocolConfigFeatureFlag.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeSignedTransaction: FfiConverterRustBuffer { + typealias SwiftType = [SignedTransaction] + + public static func write(_ value: [SignedTransaction], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeSignedTransaction.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [SignedTransaction] { + let len: Int32 = try readInt(&buf) + var seq = [SignedTransaction]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeSignedTransaction.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeTransactionDataEffects: FfiConverterRustBuffer { + typealias SwiftType = [TransactionDataEffects] + + public static func write(_ value: [TransactionDataEffects], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeTransactionDataEffects.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [TransactionDataEffects] { + let len: Int32 = try readInt(&buf) + var seq = [TransactionDataEffects]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeTransactionDataEffects.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeTypeOrigin: FfiConverterRustBuffer { + typealias SwiftType = [TypeOrigin] + + public static func write(_ value: [TypeOrigin], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeTypeOrigin.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [TypeOrigin] { + let len: Int32 = try readInt(&buf) + var seq = [TypeOrigin]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeTypeOrigin.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeUnchangedSharedObject: FfiConverterRustBuffer { + typealias SwiftType = [UnchangedSharedObject] + + public static func write(_ value: [UnchangedSharedObject], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeUnchangedSharedObject.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [UnchangedSharedObject] { + let len: Int32 = try readInt(&buf) + var seq = [UnchangedSharedObject]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeUnchangedSharedObject.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeValidator: FfiConverterRustBuffer { + typealias SwiftType = [Validator] + + public static func write(_ value: [Validator], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeValidator.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [Validator] { + let len: Int32 = try readInt(&buf) + var seq = [Validator]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeValidator.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeValidatorCommitteeMember: FfiConverterRustBuffer { + typealias SwiftType = [ValidatorCommitteeMember] + + public static func write(_ value: [ValidatorCommitteeMember], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeValidatorCommitteeMember.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [ValidatorCommitteeMember] { + let len: Int32 = try readInt(&buf) + var seq = [ValidatorCommitteeMember]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeValidatorCommitteeMember.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeFeature: FfiConverterRustBuffer { + typealias SwiftType = [Feature] + + public static func write(_ value: [Feature], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeFeature.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [Feature] { + let len: Int32 = try readInt(&buf) + var seq = [Feature]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeFeature.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterSequenceTypeMoveAbility: FfiConverterRustBuffer { + typealias SwiftType = [MoveAbility] + + public static func write(_ value: [MoveAbility], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeMoveAbility.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MoveAbility] { + let len: Int32 = try readInt(&buf) + var seq = [MoveAbility]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeMoveAbility.read(from: &buf)) + } + return seq + } +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterDictionaryTypeIdentifierData: FfiConverterRustBuffer { + public static func write(_ value: [Identifier: Data], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for (key, value) in value { + FfiConverterTypeIdentifier.write(key, into: &buf) + FfiConverterData.write(value, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [Identifier: Data] { + let len: Int32 = try readInt(&buf) + var dict = [Identifier: Data]() + dict.reserveCapacity(Int(len)) + for _ in 0..=5.8) +@_documentation(visibility: private) +#endif +fileprivate struct FfiConverterDictionaryTypeObjectIdTypeUpgradeInfo: FfiConverterRustBuffer { + public static func write(_ value: [ObjectId: UpgradeInfo], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for (key, value) in value { + FfiConverterTypeObjectId.write(key, into: &buf) + FfiConverterTypeUpgradeInfo.write(value, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [ObjectId: UpgradeInfo] { + let len: Int32 = try readInt(&buf) + var dict = [ObjectId: UpgradeInfo]() + dict.reserveCapacity(Int(len)) + for _ in 0..=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeBase64: FfiConverter { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Base64 { + return try FfiConverterString.read(from: &buf) + } + + public static func write(_ value: Base64, into buf: inout [UInt8]) { + return FfiConverterString.write(value, into: &buf) + } + + public static func lift(_ value: RustBuffer) throws -> Base64 { + return try FfiConverterString.lift(value) + } + + public static func lower(_ value: Base64) -> RustBuffer { + return FfiConverterString.lower(value) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeBase64_lift(_ value: RustBuffer) throws -> Base64 { + return try FfiConverterTypeBase64.lift(value) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeBase64_lower(_ value: Base64) -> RustBuffer { + return FfiConverterTypeBase64.lower(value) +} + + + +/** + * Typealias from the type name used in the UDL file to the builtin type. This + * is needed because the UDL type name is used in function/method signatures. + */ +public typealias BigInt = String + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeBigInt: FfiConverter { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> BigInt { + return try FfiConverterString.read(from: &buf) + } + + public static func write(_ value: BigInt, into buf: inout [UInt8]) { + return FfiConverterString.write(value, into: &buf) + } + + public static func lift(_ value: RustBuffer) throws -> BigInt { + return try FfiConverterString.lift(value) + } + + public static func lower(_ value: BigInt) -> RustBuffer { + return FfiConverterString.lower(value) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeBigInt_lift(_ value: RustBuffer) throws -> BigInt { + return try FfiConverterTypeBigInt.lift(value) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeBigInt_lower(_ value: BigInt) -> RustBuffer { + return FfiConverterTypeBigInt.lower(value) +} + + + +/** + * Typealias from the type name used in the UDL file to the builtin type. This + * is needed because the UDL type name is used in function/method signatures. + */ +public typealias Value = String + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public struct FfiConverterTypeValue: FfiConverter { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Value { + return try FfiConverterString.read(from: &buf) + } + + public static func write(_ value: Value, into buf: inout [UInt8]) { + return FfiConverterString.write(value, into: &buf) + } + + public static func lift(_ value: RustBuffer) throws -> Value { + return try FfiConverterString.lift(value) + } + + public static func lower(_ value: Value) -> RustBuffer { + return FfiConverterString.lower(value) + } +} + + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeValue_lift(_ value: RustBuffer) throws -> Value { + return try FfiConverterTypeValue.lift(value) +} + +#if swift(>=5.8) +@_documentation(visibility: private) +#endif +public func FfiConverterTypeValue_lower(_ value: Value) -> RustBuffer { + return FfiConverterTypeValue.lower(value) +} + +private let UNIFFI_RUST_FUTURE_POLL_READY: Int8 = 0 +private let UNIFFI_RUST_FUTURE_POLL_MAYBE_READY: Int8 = 1 + +fileprivate let uniffiContinuationHandleMap = UniffiHandleMap>() + +fileprivate func uniffiRustCallAsync( + rustFutureFunc: () -> UInt64, + pollFunc: (UInt64, @escaping UniffiRustFutureContinuationCallback, UInt64) -> (), + completeFunc: (UInt64, UnsafeMutablePointer) -> F, + freeFunc: (UInt64) -> (), + liftFunc: (F) throws -> T, + errorHandler: ((RustBuffer) throws -> Swift.Error)? +) async throws -> T { + // Make sure to call the ensure init function since future creation doesn't have a + // RustCallStatus param, so doesn't use makeRustCall() + uniffiEnsureIotaSdkFfiInitialized() + let rustFuture = rustFutureFunc() + defer { + freeFunc(rustFuture) + } + var pollResult: Int8; + repeat { + pollResult = await withUnsafeContinuation { + pollFunc( + rustFuture, + uniffiFutureContinuationCallback, + uniffiContinuationHandleMap.insert(obj: $0) + ) + } + } while pollResult != UNIFFI_RUST_FUTURE_POLL_READY + + return try liftFunc(makeRustCall( + { completeFunc(rustFuture, $0) }, + errorHandler: errorHandler + )) +} + +// Callback handlers for an async calls. These are invoked by Rust when the future is ready. They +// lift the return value or error and resume the suspended function. +fileprivate func uniffiFutureContinuationCallback(handle: UInt64, pollResult: Int8) { + if let continuation = try? uniffiContinuationHandleMap.remove(handle: handle) { + continuation.resume(returning: pollResult) + } else { + print("uniffiFutureContinuationCallback invalid handle") + } +} + +private enum InitializationResult { + case ok + case contractVersionMismatch + case apiChecksumMismatch +} +// Use a global variable to perform the versioning checks. Swift ensures that +// the code inside is only computed once. +private let initializationResult: InitializationResult = { + // Get the bindings contract version from our ComponentInterface + let bindings_contract_version = 29 + // Get the scaffolding contract version by calling the into the dylib + let scaffolding_contract_version = ffi_iota_sdk_ffi_uniffi_contract_version() + if bindings_contract_version != scaffolding_contract_version { + return InitializationResult.contractVersionMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_address_to_bytes() != 57710) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_address_to_hex() != 22032) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_argument_nested() != 44576) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_bls12381publickey_to_bytes() != 9890) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_bls12381signature_to_bytes() != 56969) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_bn254fieldelement_padded() != 44301) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_bn254fieldelement_unpadded() != 33350) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_cancelledtransaction_digest() != 3583) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_cancelledtransaction_version_assignments() != 52539) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_changeepoch_computation_charge() != 25355) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_changeepoch_epoch() != 49990) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_changeepoch_epoch_start_timestamp_ms() != 57669) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_changeepoch_non_refundable_storage_fee() != 28070) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_changeepoch_protocol_version() != 40406) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_changeepoch_storage_charge() != 35870) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_changeepoch_storage_rebate() != 21786) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_changeepoch_system_packages() != 55002) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_changeepochv2_computation_charge() != 4379) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_changeepochv2_computation_charge_burned() != 17712) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_changeepochv2_epoch() != 52992) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_changeepochv2_epoch_start_timestamp_ms() != 35398) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_changeepochv2_non_refundable_storage_fee() != 38234) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_changeepochv2_protocol_version() != 16414) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_changeepochv2_storage_charge() != 4751) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_changeepochv2_storage_rebate() != 52102) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_changeepochv2_system_packages() != 48705) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_checkpointcommitment_as_ecmh_live_object_set_digest() != 41616) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_checkpointcommitment_is_ecmh_live_object_set() != 22589) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_checkpointcontentsdigest_to_base58() != 60951) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_checkpointcontentsdigest_to_bytes() != 51343) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_checkpointdigest_to_base58() != 40700) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_checkpointdigest_to_bytes() != 48082) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_coin_balance() != 29928) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_coin_coin_type() != 18211) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_coin_id() != 40013) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_consensuscommitdigest_to_base58() != 7053) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_consensuscommitdigest_to_bytes() != 5048) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_consensuscommitprologuev1_commit_timestamp_ms() != 14198) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_consensuscommitprologuev1_consensus_commit_digest() != 44291) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_consensuscommitprologuev1_consensus_determined_version_assignments() != 32713) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_consensuscommitprologuev1_epoch() != 1832) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_consensuscommitprologuev1_round() != 6355) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_consensuscommitprologuev1_sub_dag_index() != 56426) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_consensusdeterminedversionassignments_as_cancelled_transactions() != 59888) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_consensusdeterminedversionassignments_as_cancelled_transactions_opt() != 33554) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_consensusdeterminedversionassignments_is_cancelled_transactions() != 10241) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_digest_to_base58() != 54638) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_digest_to_bytes() != 14244) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_ed25519publickey_to_bytes() != 16656) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_ed25519signature_to_bytes() != 31911) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_effectsauxiliarydatadigest_to_base58() != 56652) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_effectsauxiliarydatadigest_to_bytes() != 12259) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_executiontimeobservation_key() != 10295) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_executiontimeobservation_observations() != 58594) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_faucetclient_request() != 13326) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_faucetclient_request_and_wait() != 48304) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_faucetclient_request_status() != 42353) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_genesisobject_data() != 26598) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_genesisobject_object_id() != 9601) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_genesisobject_object_type() != 32731) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_genesisobject_owner() != 50201) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_genesisobject_version() != 36305) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_genesistransaction_events() != 64664) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_genesistransaction_objects() != 14715) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_active_validators() != 26965) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_balance() != 9953) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_chain_id() != 45619) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_checkpoint() != 33658) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_checkpoints() != 8422) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_coin_metadata() != 10872) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_coins() != 48442) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_dry_run_tx() != 12272) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_dry_run_tx_kind() != 40594) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_dynamic_field() != 29988) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_dynamic_fields() != 43452) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_dynamic_object_field() != 47284) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_epoch() != 46788) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_epoch_total_checkpoints() != 29086) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_epoch_total_transaction_blocks() != 61978) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_events() != 41916) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_execute_tx() != 41079) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_latest_checkpoint_sequence_number() != 40336) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_max_page_size() != 44733) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_move_object_contents() != 40412) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_move_object_contents_bcs() != 49694) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_normalized_move_function() != 15206) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_normalized_move_module() != 46991) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_object() != 51508) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_object_bcs() != 1970) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_objects() != 37555) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_package() != 7913) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_package_latest() != 55024) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_package_versions() != 33869) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_packages() != 3319) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_protocol_config() != 62867) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_reference_gas_price() != 39065) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_service_config() != 11931) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_set_rpc_server() != 31958) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_total_supply() != 21504) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_total_transaction_blocks() != 9583) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_total_transaction_blocks_by_digest() != 64969) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_total_transaction_blocks_by_seq_num() != 18624) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_transaction() != 35048) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_transaction_data_effects() != 7442) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_transaction_effects() != 56760) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_transactions() != 31273) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_transactions_data_effects() != 14121) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_graphqlclient_transactions_effects() != 2687) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_identifier_as_str() != 63815) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_makemovevector_elements() != 20773) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_makemovevector_type_tag() != 31154) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_mergecoins_coin() != 38884) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_mergecoins_coins_to_merge() != 44350) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_movecall_arguments() != 17202) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_movecall_function() != 2751) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_movecall_module() != 35106) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_movecall_package() != 24481) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_movecall_type_arguments() != 46468) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigaggregatedsignature_bitmap() != 41489) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigaggregatedsignature_committee() != 17432) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigaggregatedsignature_signatures() != 5488) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigcommittee_is_valid() != 45468) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigcommittee_members() != 62870) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigcommittee_scheme() != 15458) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigcommittee_threshold() != 21653) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigmember_public_key() != 7804) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigmember_weight() != 57194) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_ed25519() != 8241) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_ed25519_opt() != 28021) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_secp256k1() != 52073) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_secp256k1_opt() != 40194) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_secp256r1() != 38170) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_secp256r1_opt() != 28963) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_zklogin() != 17714) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_zklogin_opt() != 23106) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_is_ed25519() != 1939) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_is_secp256k1() != 49521) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_is_secp256r1() != 16265) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_is_zklogin() != 37193) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_ed25519() != 22855) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_ed25519_opt() != 56690) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_secp256k1() != 49085) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_secp256k1_opt() != 26984) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_secp256r1() != 57510) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_secp256r1_opt() != 12419) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_zklogin() != 39624) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_zklogin_opt() != 34526) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_is_ed25519() != 18913) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_is_secp256k1() != 16841) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_is_secp256r1() != 51171) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_is_zklogin() != 65193) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_object_as_struct() != 37303) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_object_data() != 4330) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_object_object_id() != 6575) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_object_object_type() != 1843) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_object_owner() != 3724) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_object_previous_transaction() != 455) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_object_storage_rebate() != 24969) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_object_version() != 18433) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_objectdata_as_package_opt() != 50334) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_objectdata_as_struct_opt() != 8956) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_objectdata_is_package() != 11147) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_objectdata_is_struct() != 58579) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_objectdigest_to_base58() != 2414) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_objectdigest_to_bytes() != 31732) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_objectid_to_address() != 21880) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_objectid_to_bytes() != 38367) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_objectid_to_hex() != 4418) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_objecttype_as_struct_opt() != 14701) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_objecttype_is_package() != 40585) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_objecttype_is_struct() != 33698) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_owner_as_address_opt() != 36265) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_owner_as_object_opt() != 17159) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_owner_as_shared_opt() != 4209) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_owner_is_address() != 26982) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_owner_is_immutable() != 23542) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_owner_is_object() != 29892) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_owner_is_shared() != 6506) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_passkeyauthenticator_authenticator_data() != 55474) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_passkeyauthenticator_challenge() != 28147) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_passkeyauthenticator_client_data_json() != 20272) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_passkeyauthenticator_signature() != 5489) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_programmabletransaction_commands() != 49868) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_programmabletransaction_inputs() != 25458) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_publish_dependencies() != 57311) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_publish_modules() != 26011) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_secp256k1publickey_to_bytes() != 49170) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_secp256k1signature_to_bytes() != 49705) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_secp256r1publickey_to_bytes() != 21066) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_secp256r1signature_to_bytes() != 64948) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_simplesignature_ed25519_pub_key() != 36693) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_simplesignature_ed25519_pub_key_opt() != 11858) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_simplesignature_ed25519_sig() != 56126) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_simplesignature_ed25519_sig_opt() != 33862) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_simplesignature_is_ed25519() != 64494) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_simplesignature_is_secp256k1() != 39262) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_simplesignature_is_secp256r1() != 49536) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_simplesignature_scheme() != 30423) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256k1_pub_key() != 51778) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256k1_pub_key_opt() != 20475) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256k1_sig() != 36141) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256k1_sig_opt() != 16111) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256r1_pub_key() != 25197) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256r1_pub_key_opt() != 22487) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256r1_sig() != 30390) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256r1_sig_opt() != 51961) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_simplesignature_to_bytes() != 28081) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_splitcoins_amounts() != 10377) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_splitcoins_coin() != 17278) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_structtag_address() != 18393) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_structtag_coin_type() != 37745) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_structtag_coin_type_opt() != 65306) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_systempackage_dependencies() != 25411) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_systempackage_modules() != 23597) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_systempackage_version() != 39738) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_transaction_expiration() != 47752) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_transaction_gas_payment() != 5316) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_transaction_kind() != 49492) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_transaction_sender() != 38190) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_transactiondigest_to_base58() != 22119) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_transactiondigest_to_bytes() != 3253) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_transactioneffects_as_v1() != 48710) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_transactioneffects_is_v1() != 39808) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_transactioneffectsdigest_to_base58() != 38601) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_transactioneffectsdigest_to_bytes() != 43744) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_transactioneventsdigest_to_base58() != 54162) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_transactioneventsdigest_to_bytes() != 6773) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_transferobjects_address() != 37833) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_transferobjects_objects() != 24154) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_typetag_as_struct_tag() != 1715) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_typetag_as_struct_tag_opt() != 15734) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_typetag_as_vector_type_tag() != 20180) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_typetag_as_vector_type_tag_opt() != 55130) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_typetag_is_address() != 38219) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_typetag_is_bool() != 30264) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_typetag_is_signer() != 57678) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_typetag_is_struct() != 39029) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_typetag_is_u128() != 65460) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_typetag_is_u16() != 34540) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_typetag_is_u256() != 65130) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_typetag_is_u32() != 40795) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_typetag_is_u64() != 28705) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_typetag_is_u8() != 18761) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_typetag_is_vector() != 49992) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_upgrade_dependencies() != 7113) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_upgrade_modules() != 62138) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_upgrade_package() != 35757) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_upgrade_ticket() != 11416) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_usersignature_as_multisig() != 36332) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_usersignature_as_multisig_opt() != 21895) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_usersignature_as_passkey() != 17710) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_usersignature_as_passkey_opt() != 53755) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_usersignature_as_simple() != 57455) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_usersignature_as_simple_opt() != 47248) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_usersignature_as_zklogin() != 53484) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_usersignature_as_zklogin_opt() != 43934) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_usersignature_is_multisig() != 61839) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_usersignature_is_passkey() != 35671) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_usersignature_is_simple() != 58211) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_usersignature_is_zklogin() != 38693) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_usersignature_scheme() != 25381) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_usersignature_to_base64() != 33757) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_usersignature_to_bytes() != 58893) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_validatorexecutiontimeobservation_duration() != 59803) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_validatorexecutiontimeobservation_validator() != 10003) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_versionassignment_object_id() != 50440) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_versionassignment_version() != 51219) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_zkloginauthenticator_inputs() != 1512) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_zkloginauthenticator_max_epoch() != 9769) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_zkloginauthenticator_signature() != 18838) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_zklogininputs_address_seed() != 4892) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_zklogininputs_header_base64() != 32056) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_zklogininputs_iss_base64_details() != 20914) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_zklogininputs_proof_points() != 28172) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_zkloginproof_a() != 6891) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_zkloginproof_b() != 36477) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_zkloginproof_c() != 10897) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_zkloginpublicidentifier_address_seed() != 3936) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_method_zkloginpublicidentifier_iss() != 58864) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_address_from_bytes() != 58901) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_address_from_hex() != 63442) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_address_generate() != 48865) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_argument_new_gas() != 14489) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_argument_new_input() != 33966) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_argument_new_nested_result() != 57666) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_argument_new_result() != 44025) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_bls12381publickey_from_bytes() != 6069) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_bls12381publickey_from_str() != 26128) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_bls12381publickey_generate() != 30791) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_bls12381signature_from_bytes() != 42745) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_bls12381signature_from_str() != 5412) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_bls12381signature_generate() != 58435) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_bn254fieldelement_from_bytes() != 3672) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_bn254fieldelement_from_str() != 21214) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_bn254fieldelement_from_str_radix_10() != 17556) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_cancelledtransaction_new() != 21959) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_changeepoch_new() != 48694) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_changeepochv2_new() != 52433) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_checkpointcontentsdigest_from_base58() != 33027) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_checkpointcontentsdigest_from_bytes() != 37261) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_checkpointcontentsdigest_generate() != 79) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_checkpointdigest_from_base58() != 65453) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_checkpointdigest_from_bytes() != 24226) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_checkpointdigest_generate() != 13389) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_circomg1_new() != 39786) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_circomg2_new() != 50489) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_coin_try_from_object() != 35349) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_command_new_make_move_vector() != 54610) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_command_new_merge_coins() != 1888) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_command_new_move_call() != 23161) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_command_new_publish() != 7239) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_command_new_split_coins() != 59484) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_command_new_transfer_objects() != 54265) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_command_new_upgrade() != 48835) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_consensuscommitdigest_from_base58() != 17742) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_consensuscommitdigest_from_bytes() != 58221) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_consensuscommitdigest_generate() != 49846) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_consensuscommitprologuev1_new() != 41810) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_consensusdeterminedversionassignments_new_cancelled_transactions() != 929) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_digest_from_base58() != 41234) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_digest_from_bytes() != 65530) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_digest_generate() != 8094) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_ed25519publickey_from_bytes() != 60403) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_ed25519publickey_from_str() != 38751) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_ed25519publickey_generate() != 46412) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_ed25519signature_from_bytes() != 61841) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_ed25519signature_from_str() != 39607) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_ed25519signature_generate() != 41607) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_effectsauxiliarydatadigest_from_base58() != 31144) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_effectsauxiliarydatadigest_from_bytes() != 36699) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_effectsauxiliarydatadigest_generate() != 28926) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_endofepochtransactionkind_authenticator_state_create() != 18946) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_endofepochtransactionkind_authenticator_state_expire() != 31328) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_endofepochtransactionkind_change_epoch() != 16640) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_endofepochtransactionkind_change_epoch_v2() != 17262) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservation_new() != 22119) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_make_move_vec() != 1498) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_merge_coins() != 40848) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_move_entry_point() != 6711) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_publish() != 6398) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_split_coins() != 28564) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_transfer_objects() != 29560) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_upgrade() != 26115) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservations_new_v1() != 19098) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_faucetclient_devnet() != 37366) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_faucetclient_local() != 55393) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_faucetclient_new() != 13557) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_faucetclient_testnet() != 16109) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_genesisobject_new() != 35390) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_genesistransaction_new() != 47990) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_graphqlclient_new() != 32097) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_graphqlclient_new_devnet() != 6494) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_graphqlclient_new_localhost() != 5570) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_graphqlclient_new_mainnet() != 3613) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_graphqlclient_new_testnet() != 48529) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_identifier_new() != 9398) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_input_new_immutable_or_owned() != 33908) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_input_new_pure() != 53404) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_input_new_receiving() != 28060) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_input_new_shared() != 61970) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_makemovevector_new() != 20934) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_mergecoins_new() != 1506) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_movecall_new() != 30411) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_movepackage_new() != 17506) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_multisigaggregatedsignature_new() != 3396) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_multisigcommittee_new() != 40069) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_multisigmember_new() != 63622) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_object_new() != 56232) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_objectdata_new_move_package() != 5274) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_objectdata_new_move_struct() != 1861) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_objectdigest_from_base58() != 57967) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_objectdigest_from_bytes() != 62288) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_objectdigest_generate() != 61181) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_objectid_from_bytes() != 41789) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_objectid_from_hex() != 30954) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_objecttype_new_package() != 63533) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_objecttype_new_struct() != 65488) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_owner_new_address() != 6008) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_owner_new_immutable() != 51786) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_owner_new_object() != 381) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_owner_new_shared() != 36753) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_programmabletransaction_new() != 38638) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_publish_new() != 4785) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_secp256k1publickey_from_bytes() != 20339) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_secp256k1publickey_from_str() != 24158) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_secp256k1publickey_generate() != 36411) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_secp256k1signature_from_bytes() != 36237) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_secp256k1signature_from_str() != 16397) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_secp256k1signature_generate() != 63087) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_secp256r1publickey_from_bytes() != 60002) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_secp256r1publickey_from_str() != 27991) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_secp256r1publickey_generate() != 49992) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_secp256r1signature_from_bytes() != 8469) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_secp256r1signature_from_str() != 15312) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_secp256r1signature_generate() != 40260) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_splitcoins_new() != 50321) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_structtag_coin() != 13756) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_structtag_gas_coin() != 37848) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_structtag_new() != 20682) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_structtag_staked_iota() != 30839) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_systempackage_new() != 25070) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_transaction_new() != 4081) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_transactiondigest_from_base58() != 15069) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_transactiondigest_from_bytes() != 43656) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_transactiondigest_generate() != 14578) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_transactioneffects_new_v1() != 63561) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_transactioneffectsdigest_from_base58() != 63406) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_transactioneffectsdigest_from_bytes() != 51937) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_transactioneffectsdigest_generate() != 11715) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_transactioneventsdigest_from_base58() != 56954) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_transactioneventsdigest_from_bytes() != 4647) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_transactioneventsdigest_generate() != 18224) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_transactionkind_authenticator_state_update_v1() != 14756) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_transactionkind_consensus_commit_prologue_v1() != 50635) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_transactionkind_end_of_epoch() != 65525) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_transactionkind_genesis() != 65272) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_transactionkind_programmable_transaction() != 51205) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_transactionkind_randomness_state_update() != 16439) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_transferobjects_new() != 22470) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_typetag_address() != 44901) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_typetag_bool() != 19366) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_typetag_signer() != 12676) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_typetag_struct_tag() != 53303) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_typetag_u128() != 41280) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_typetag_u16() != 13801) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_typetag_u256() != 13310) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_typetag_u32() != 9870) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_typetag_u64() != 59470) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_typetag_u8() != 9403) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_typetag_vector() != 46548) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_upgrade_new() != 61663) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_usersignature_from_base64() != 8029) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_usersignature_from_bytes() != 37499) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_validatorexecutiontimeobservation_new() != 47546) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_versionassignment_new() != 14186) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_zkloginauthenticator_new() != 32812) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_zklogininputs_new() != 54245) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_zkloginproof_new() != 19950) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_iota_sdk_ffi_checksum_constructor_zkloginpublicidentifier_new() != 53294) { + return InitializationResult.apiChecksumMismatch + } + + return InitializationResult.ok +}() + +// Make the ensure init function public so that other modules which have external type references to +// our types can call it. +public func uniffiEnsureIotaSdkFfiInitialized() { + switch initializationResult { + case .ok: + break + case .contractVersionMismatch: + fatalError("UniFFI contract version mismatch: try cleaning and rebuilding your project") + case .apiChecksumMismatch: + fatalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } +} + +// swiftlint:enable all \ No newline at end of file diff --git a/bindings/swift/lib/iota_sdk_ffiFFI.h b/bindings/swift/lib/iota_sdk_ffiFFI.h new file mode 100644 index 000000000..e53f86e89 --- /dev/null +++ b/bindings/swift/lib/iota_sdk_ffiFFI.h @@ -0,0 +1,6185 @@ +// This file was autogenerated by some hot garbage in the `uniffi` crate. +// Trust me, you don't want to mess with it! + +#pragma once + +#include +#include +#include + +// The following structs are used to implement the lowest level +// of the FFI, and thus useful to multiple uniffied crates. +// We ensure they are declared exactly once, with a header guard, UNIFFI_SHARED_H. +#ifdef UNIFFI_SHARED_H + // We also try to prevent mixing versions of shared uniffi header structs. + // If you add anything to the #else block, you must increment the version suffix in UNIFFI_SHARED_HEADER_V4 + #ifndef UNIFFI_SHARED_HEADER_V4 + #error Combining helper code from multiple versions of uniffi is not supported + #endif // ndef UNIFFI_SHARED_HEADER_V4 +#else +#define UNIFFI_SHARED_H +#define UNIFFI_SHARED_HEADER_V4 +// ⚠️ Attention: If you change this #else block (ending in `#endif // def UNIFFI_SHARED_H`) you *must* ⚠️ +// ⚠️ increment the version suffix in all instances of UNIFFI_SHARED_HEADER_V4 in this file. ⚠️ + +typedef struct RustBuffer +{ + uint64_t capacity; + uint64_t len; + uint8_t *_Nullable data; +} RustBuffer; + +typedef struct ForeignBytes +{ + int32_t len; + const uint8_t *_Nullable data; +} ForeignBytes; + +// Error definitions +typedef struct RustCallStatus { + int8_t code; + RustBuffer errorBuf; +} RustCallStatus; + +// ⚠️ Attention: If you change this #else block (ending in `#endif // def UNIFFI_SHARED_H`) you *must* ⚠️ +// ⚠️ increment the version suffix in all instances of UNIFFI_SHARED_HEADER_V4 in this file. ⚠️ +#endif // def UNIFFI_SHARED_H +#ifndef UNIFFI_FFIDEF_RUST_FUTURE_CONTINUATION_CALLBACK +#define UNIFFI_FFIDEF_RUST_FUTURE_CONTINUATION_CALLBACK +typedef void (*UniffiRustFutureContinuationCallback)(uint64_t, int8_t + ); + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_FREE +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_FREE +typedef void (*UniffiForeignFutureFree)(uint64_t + ); + +#endif +#ifndef UNIFFI_FFIDEF_CALLBACK_INTERFACE_FREE +#define UNIFFI_FFIDEF_CALLBACK_INTERFACE_FREE +typedef void (*UniffiCallbackInterfaceFree)(uint64_t + ); + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE +#define UNIFFI_FFIDEF_FOREIGN_FUTURE +typedef struct UniffiForeignFuture { + uint64_t handle; + UniffiForeignFutureFree _Nonnull free; +} UniffiForeignFuture; + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_STRUCT_U8 +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_STRUCT_U8 +typedef struct UniffiForeignFutureStructU8 { + uint8_t returnValue; + RustCallStatus callStatus; +} UniffiForeignFutureStructU8; + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_U8 +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_U8 +typedef void (*UniffiForeignFutureCompleteU8)(uint64_t, UniffiForeignFutureStructU8 + ); + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_STRUCT_I8 +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_STRUCT_I8 +typedef struct UniffiForeignFutureStructI8 { + int8_t returnValue; + RustCallStatus callStatus; +} UniffiForeignFutureStructI8; + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_I8 +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_I8 +typedef void (*UniffiForeignFutureCompleteI8)(uint64_t, UniffiForeignFutureStructI8 + ); + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_STRUCT_U16 +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_STRUCT_U16 +typedef struct UniffiForeignFutureStructU16 { + uint16_t returnValue; + RustCallStatus callStatus; +} UniffiForeignFutureStructU16; + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_U16 +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_U16 +typedef void (*UniffiForeignFutureCompleteU16)(uint64_t, UniffiForeignFutureStructU16 + ); + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_STRUCT_I16 +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_STRUCT_I16 +typedef struct UniffiForeignFutureStructI16 { + int16_t returnValue; + RustCallStatus callStatus; +} UniffiForeignFutureStructI16; + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_I16 +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_I16 +typedef void (*UniffiForeignFutureCompleteI16)(uint64_t, UniffiForeignFutureStructI16 + ); + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_STRUCT_U32 +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_STRUCT_U32 +typedef struct UniffiForeignFutureStructU32 { + uint32_t returnValue; + RustCallStatus callStatus; +} UniffiForeignFutureStructU32; + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_U32 +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_U32 +typedef void (*UniffiForeignFutureCompleteU32)(uint64_t, UniffiForeignFutureStructU32 + ); + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_STRUCT_I32 +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_STRUCT_I32 +typedef struct UniffiForeignFutureStructI32 { + int32_t returnValue; + RustCallStatus callStatus; +} UniffiForeignFutureStructI32; + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_I32 +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_I32 +typedef void (*UniffiForeignFutureCompleteI32)(uint64_t, UniffiForeignFutureStructI32 + ); + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_STRUCT_U64 +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_STRUCT_U64 +typedef struct UniffiForeignFutureStructU64 { + uint64_t returnValue; + RustCallStatus callStatus; +} UniffiForeignFutureStructU64; + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_U64 +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_U64 +typedef void (*UniffiForeignFutureCompleteU64)(uint64_t, UniffiForeignFutureStructU64 + ); + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_STRUCT_I64 +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_STRUCT_I64 +typedef struct UniffiForeignFutureStructI64 { + int64_t returnValue; + RustCallStatus callStatus; +} UniffiForeignFutureStructI64; + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_I64 +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_I64 +typedef void (*UniffiForeignFutureCompleteI64)(uint64_t, UniffiForeignFutureStructI64 + ); + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_STRUCT_F32 +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_STRUCT_F32 +typedef struct UniffiForeignFutureStructF32 { + float returnValue; + RustCallStatus callStatus; +} UniffiForeignFutureStructF32; + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_F32 +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_F32 +typedef void (*UniffiForeignFutureCompleteF32)(uint64_t, UniffiForeignFutureStructF32 + ); + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_STRUCT_F64 +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_STRUCT_F64 +typedef struct UniffiForeignFutureStructF64 { + double returnValue; + RustCallStatus callStatus; +} UniffiForeignFutureStructF64; + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_F64 +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_F64 +typedef void (*UniffiForeignFutureCompleteF64)(uint64_t, UniffiForeignFutureStructF64 + ); + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_STRUCT_POINTER +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_STRUCT_POINTER +typedef struct UniffiForeignFutureStructPointer { + void*_Nonnull returnValue; + RustCallStatus callStatus; +} UniffiForeignFutureStructPointer; + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_POINTER +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_POINTER +typedef void (*UniffiForeignFutureCompletePointer)(uint64_t, UniffiForeignFutureStructPointer + ); + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_STRUCT_RUST_BUFFER +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_STRUCT_RUST_BUFFER +typedef struct UniffiForeignFutureStructRustBuffer { + RustBuffer returnValue; + RustCallStatus callStatus; +} UniffiForeignFutureStructRustBuffer; + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER +typedef void (*UniffiForeignFutureCompleteRustBuffer)(uint64_t, UniffiForeignFutureStructRustBuffer + ); + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_STRUCT_VOID +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_STRUCT_VOID +typedef struct UniffiForeignFutureStructVoid { + RustCallStatus callStatus; +} UniffiForeignFutureStructVoid; + +#endif +#ifndef UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_VOID +#define UNIFFI_FFIDEF_FOREIGN_FUTURE_COMPLETE_VOID +typedef void (*UniffiForeignFutureCompleteVoid)(uint64_t, UniffiForeignFutureStructVoid + ); + +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_ADDRESS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_ADDRESS +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_address(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_ADDRESS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_ADDRESS +void uniffi_iota_sdk_ffi_fn_free_address(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ADDRESS_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ADDRESS_FROM_BYTES +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_address_from_bytes(RustBuffer bytes, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ADDRESS_FROM_HEX +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ADDRESS_FROM_HEX +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_address_from_hex(RustBuffer hex, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ADDRESS_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ADDRESS_GENERATE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_address_generate(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ADDRESS_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ADDRESS_TO_BYTES +RustBuffer uniffi_iota_sdk_ffi_fn_method_address_to_bytes(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ADDRESS_TO_HEX +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ADDRESS_TO_HEX +RustBuffer uniffi_iota_sdk_ffi_fn_method_address_to_hex(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_ARGUMENT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_ARGUMENT +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_argument(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_ARGUMENT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_ARGUMENT +void uniffi_iota_sdk_ffi_fn_free_argument(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ARGUMENT_NEW_GAS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ARGUMENT_NEW_GAS +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_argument_new_gas(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ARGUMENT_NEW_INPUT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ARGUMENT_NEW_INPUT +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_argument_new_input(uint16_t input, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ARGUMENT_NEW_NESTED_RESULT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ARGUMENT_NEW_NESTED_RESULT +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_argument_new_nested_result(uint16_t command_index, uint16_t subresult_index, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ARGUMENT_NEW_RESULT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ARGUMENT_NEW_RESULT +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_argument_new_result(uint16_t result, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ARGUMENT_NESTED +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ARGUMENT_NESTED +RustBuffer uniffi_iota_sdk_ffi_fn_method_argument_nested(void*_Nonnull ptr, uint16_t ix, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_BATCHSENDSTATUS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_BATCHSENDSTATUS +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_batchsendstatus(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_BATCHSENDSTATUS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_BATCHSENDSTATUS +void uniffi_iota_sdk_ffi_fn_free_batchsendstatus(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_BLS12381PUBLICKEY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_BLS12381PUBLICKEY +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_bls12381publickey(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_BLS12381PUBLICKEY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_BLS12381PUBLICKEY +void uniffi_iota_sdk_ffi_fn_free_bls12381publickey(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_BLS12381PUBLICKEY_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_BLS12381PUBLICKEY_FROM_BYTES +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_bls12381publickey_from_bytes(RustBuffer bytes, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_BLS12381PUBLICKEY_FROM_STR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_BLS12381PUBLICKEY_FROM_STR +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_bls12381publickey_from_str(RustBuffer s, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_BLS12381PUBLICKEY_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_BLS12381PUBLICKEY_GENERATE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_bls12381publickey_generate(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_BLS12381PUBLICKEY_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_BLS12381PUBLICKEY_TO_BYTES +RustBuffer uniffi_iota_sdk_ffi_fn_method_bls12381publickey_to_bytes(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_BLS12381SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_BLS12381SIGNATURE +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_bls12381signature(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_BLS12381SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_BLS12381SIGNATURE +void uniffi_iota_sdk_ffi_fn_free_bls12381signature(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_BLS12381SIGNATURE_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_BLS12381SIGNATURE_FROM_BYTES +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_bls12381signature_from_bytes(RustBuffer bytes, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_BLS12381SIGNATURE_FROM_STR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_BLS12381SIGNATURE_FROM_STR +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_bls12381signature_from_str(RustBuffer s, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_BLS12381SIGNATURE_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_BLS12381SIGNATURE_GENERATE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_bls12381signature_generate(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_BLS12381SIGNATURE_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_BLS12381SIGNATURE_TO_BYTES +RustBuffer uniffi_iota_sdk_ffi_fn_method_bls12381signature_to_bytes(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_BN254FIELDELEMENT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_BN254FIELDELEMENT +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_bn254fieldelement(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_BN254FIELDELEMENT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_BN254FIELDELEMENT +void uniffi_iota_sdk_ffi_fn_free_bn254fieldelement(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_BN254FIELDELEMENT_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_BN254FIELDELEMENT_FROM_BYTES +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_bn254fieldelement_from_bytes(RustBuffer bytes, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_BN254FIELDELEMENT_FROM_STR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_BN254FIELDELEMENT_FROM_STR +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_bn254fieldelement_from_str(RustBuffer s, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_BN254FIELDELEMENT_FROM_STR_RADIX_10 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_BN254FIELDELEMENT_FROM_STR_RADIX_10 +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_bn254fieldelement_from_str_radix_10(RustBuffer s, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_BN254FIELDELEMENT_PADDED +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_BN254FIELDELEMENT_PADDED +RustBuffer uniffi_iota_sdk_ffi_fn_method_bn254fieldelement_padded(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_BN254FIELDELEMENT_UNPADDED +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_BN254FIELDELEMENT_UNPADDED +RustBuffer uniffi_iota_sdk_ffi_fn_method_bn254fieldelement_unpadded(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_CANCELLEDTRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_CANCELLEDTRANSACTION +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_cancelledtransaction(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_CANCELLEDTRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_CANCELLEDTRANSACTION +void uniffi_iota_sdk_ffi_fn_free_cancelledtransaction(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CANCELLEDTRANSACTION_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CANCELLEDTRANSACTION_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_cancelledtransaction_new(void*_Nonnull digest, RustBuffer version_assignments, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CANCELLEDTRANSACTION_DIGEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CANCELLEDTRANSACTION_DIGEST +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_cancelledtransaction_digest(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CANCELLEDTRANSACTION_VERSION_ASSIGNMENTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CANCELLEDTRANSACTION_VERSION_ASSIGNMENTS +RustBuffer uniffi_iota_sdk_ffi_fn_method_cancelledtransaction_version_assignments(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_CHANGEEPOCH +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_CHANGEEPOCH +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_changeepoch(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_CHANGEEPOCH +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_CHANGEEPOCH +void uniffi_iota_sdk_ffi_fn_free_changeepoch(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CHANGEEPOCH_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CHANGEEPOCH_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_changeepoch_new(uint64_t epoch, uint64_t protocol_version, uint64_t storage_charge, uint64_t computation_charge, uint64_t storage_rebate, uint64_t non_refundable_storage_fee, uint64_t epoch_start_timestamp_ms, RustBuffer system_packages, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCH_COMPUTATION_CHARGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCH_COMPUTATION_CHARGE +uint64_t uniffi_iota_sdk_ffi_fn_method_changeepoch_computation_charge(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCH_EPOCH +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCH_EPOCH +uint64_t uniffi_iota_sdk_ffi_fn_method_changeepoch_epoch(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCH_EPOCH_START_TIMESTAMP_MS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCH_EPOCH_START_TIMESTAMP_MS +uint64_t uniffi_iota_sdk_ffi_fn_method_changeepoch_epoch_start_timestamp_ms(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCH_NON_REFUNDABLE_STORAGE_FEE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCH_NON_REFUNDABLE_STORAGE_FEE +uint64_t uniffi_iota_sdk_ffi_fn_method_changeepoch_non_refundable_storage_fee(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCH_PROTOCOL_VERSION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCH_PROTOCOL_VERSION +uint64_t uniffi_iota_sdk_ffi_fn_method_changeepoch_protocol_version(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCH_STORAGE_CHARGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCH_STORAGE_CHARGE +uint64_t uniffi_iota_sdk_ffi_fn_method_changeepoch_storage_charge(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCH_STORAGE_REBATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCH_STORAGE_REBATE +uint64_t uniffi_iota_sdk_ffi_fn_method_changeepoch_storage_rebate(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCH_SYSTEM_PACKAGES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCH_SYSTEM_PACKAGES +RustBuffer uniffi_iota_sdk_ffi_fn_method_changeepoch_system_packages(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_CHANGEEPOCHV2 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_CHANGEEPOCHV2 +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_changeepochv2(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_CHANGEEPOCHV2 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_CHANGEEPOCHV2 +void uniffi_iota_sdk_ffi_fn_free_changeepochv2(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CHANGEEPOCHV2_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CHANGEEPOCHV2_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_changeepochv2_new(uint64_t epoch, uint64_t protocol_version, uint64_t storage_charge, uint64_t computation_charge, uint64_t computation_charge_burned, uint64_t storage_rebate, uint64_t non_refundable_storage_fee, uint64_t epoch_start_timestamp_ms, RustBuffer system_packages, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCHV2_COMPUTATION_CHARGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCHV2_COMPUTATION_CHARGE +uint64_t uniffi_iota_sdk_ffi_fn_method_changeepochv2_computation_charge(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCHV2_COMPUTATION_CHARGE_BURNED +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCHV2_COMPUTATION_CHARGE_BURNED +uint64_t uniffi_iota_sdk_ffi_fn_method_changeepochv2_computation_charge_burned(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCHV2_EPOCH +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCHV2_EPOCH +uint64_t uniffi_iota_sdk_ffi_fn_method_changeepochv2_epoch(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCHV2_EPOCH_START_TIMESTAMP_MS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCHV2_EPOCH_START_TIMESTAMP_MS +uint64_t uniffi_iota_sdk_ffi_fn_method_changeepochv2_epoch_start_timestamp_ms(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCHV2_NON_REFUNDABLE_STORAGE_FEE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCHV2_NON_REFUNDABLE_STORAGE_FEE +uint64_t uniffi_iota_sdk_ffi_fn_method_changeepochv2_non_refundable_storage_fee(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCHV2_PROTOCOL_VERSION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCHV2_PROTOCOL_VERSION +uint64_t uniffi_iota_sdk_ffi_fn_method_changeepochv2_protocol_version(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCHV2_STORAGE_CHARGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCHV2_STORAGE_CHARGE +uint64_t uniffi_iota_sdk_ffi_fn_method_changeepochv2_storage_charge(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCHV2_STORAGE_REBATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCHV2_STORAGE_REBATE +uint64_t uniffi_iota_sdk_ffi_fn_method_changeepochv2_storage_rebate(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCHV2_SYSTEM_PACKAGES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHANGEEPOCHV2_SYSTEM_PACKAGES +RustBuffer uniffi_iota_sdk_ffi_fn_method_changeepochv2_system_packages(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_CHECKPOINTCOMMITMENT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_CHECKPOINTCOMMITMENT +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_checkpointcommitment(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_CHECKPOINTCOMMITMENT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_CHECKPOINTCOMMITMENT +void uniffi_iota_sdk_ffi_fn_free_checkpointcommitment(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHECKPOINTCOMMITMENT_AS_ECMH_LIVE_OBJECT_SET_DIGEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHECKPOINTCOMMITMENT_AS_ECMH_LIVE_OBJECT_SET_DIGEST +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_checkpointcommitment_as_ecmh_live_object_set_digest(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHECKPOINTCOMMITMENT_IS_ECMH_LIVE_OBJECT_SET +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHECKPOINTCOMMITMENT_IS_ECMH_LIVE_OBJECT_SET +int8_t uniffi_iota_sdk_ffi_fn_method_checkpointcommitment_is_ecmh_live_object_set(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_CHECKPOINTCONTENTSDIGEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_CHECKPOINTCONTENTSDIGEST +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_checkpointcontentsdigest(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_CHECKPOINTCONTENTSDIGEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_CHECKPOINTCONTENTSDIGEST +void uniffi_iota_sdk_ffi_fn_free_checkpointcontentsdigest(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CHECKPOINTCONTENTSDIGEST_FROM_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CHECKPOINTCONTENTSDIGEST_FROM_BASE58 +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_checkpointcontentsdigest_from_base58(RustBuffer base58, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CHECKPOINTCONTENTSDIGEST_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CHECKPOINTCONTENTSDIGEST_FROM_BYTES +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_checkpointcontentsdigest_from_bytes(RustBuffer bytes, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CHECKPOINTCONTENTSDIGEST_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CHECKPOINTCONTENTSDIGEST_GENERATE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_checkpointcontentsdigest_generate(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHECKPOINTCONTENTSDIGEST_TO_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHECKPOINTCONTENTSDIGEST_TO_BASE58 +RustBuffer uniffi_iota_sdk_ffi_fn_method_checkpointcontentsdigest_to_base58(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHECKPOINTCONTENTSDIGEST_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHECKPOINTCONTENTSDIGEST_TO_BYTES +RustBuffer uniffi_iota_sdk_ffi_fn_method_checkpointcontentsdigest_to_bytes(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_CHECKPOINTDIGEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_CHECKPOINTDIGEST +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_checkpointdigest(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_CHECKPOINTDIGEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_CHECKPOINTDIGEST +void uniffi_iota_sdk_ffi_fn_free_checkpointdigest(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CHECKPOINTDIGEST_FROM_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CHECKPOINTDIGEST_FROM_BASE58 +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_checkpointdigest_from_base58(RustBuffer base58, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CHECKPOINTDIGEST_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CHECKPOINTDIGEST_FROM_BYTES +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_checkpointdigest_from_bytes(RustBuffer bytes, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CHECKPOINTDIGEST_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CHECKPOINTDIGEST_GENERATE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_checkpointdigest_generate(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHECKPOINTDIGEST_TO_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHECKPOINTDIGEST_TO_BASE58 +RustBuffer uniffi_iota_sdk_ffi_fn_method_checkpointdigest_to_base58(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHECKPOINTDIGEST_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CHECKPOINTDIGEST_TO_BYTES +RustBuffer uniffi_iota_sdk_ffi_fn_method_checkpointdigest_to_bytes(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_CIRCOMG1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_CIRCOMG1 +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_circomg1(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_CIRCOMG1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_CIRCOMG1 +void uniffi_iota_sdk_ffi_fn_free_circomg1(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CIRCOMG1_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CIRCOMG1_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_circomg1_new(void*_Nonnull el_0, void*_Nonnull el_1, void*_Nonnull el_2, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_CIRCOMG2 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_CIRCOMG2 +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_circomg2(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_CIRCOMG2 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_CIRCOMG2 +void uniffi_iota_sdk_ffi_fn_free_circomg2(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CIRCOMG2_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CIRCOMG2_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_circomg2_new(void*_Nonnull el_0_0, void*_Nonnull el_0_1, void*_Nonnull el_1_0, void*_Nonnull el_1_1, void*_Nonnull el_2_0, void*_Nonnull el_2_1, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_COIN +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_COIN +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_coin(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_COIN +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_COIN +void uniffi_iota_sdk_ffi_fn_free_coin(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_COIN_TRY_FROM_OBJECT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_COIN_TRY_FROM_OBJECT +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_coin_try_from_object(void*_Nonnull object, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_COIN_BALANCE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_COIN_BALANCE +uint64_t uniffi_iota_sdk_ffi_fn_method_coin_balance(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_COIN_COIN_TYPE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_COIN_COIN_TYPE +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_coin_coin_type(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_COIN_ID +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_COIN_ID +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_coin_id(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_COMMAND +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_COMMAND +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_command(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_COMMAND +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_COMMAND +void uniffi_iota_sdk_ffi_fn_free_command(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_COMMAND_NEW_MAKE_MOVE_VECTOR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_COMMAND_NEW_MAKE_MOVE_VECTOR +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_command_new_make_move_vector(void*_Nonnull make_move_vector, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_COMMAND_NEW_MERGE_COINS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_COMMAND_NEW_MERGE_COINS +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_command_new_merge_coins(void*_Nonnull merge_coins, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_COMMAND_NEW_MOVE_CALL +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_COMMAND_NEW_MOVE_CALL +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_command_new_move_call(void*_Nonnull move_call, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_COMMAND_NEW_PUBLISH +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_COMMAND_NEW_PUBLISH +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_command_new_publish(void*_Nonnull publish, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_COMMAND_NEW_SPLIT_COINS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_COMMAND_NEW_SPLIT_COINS +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_command_new_split_coins(void*_Nonnull split_coins, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_COMMAND_NEW_TRANSFER_OBJECTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_COMMAND_NEW_TRANSFER_OBJECTS +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_command_new_transfer_objects(void*_Nonnull transfer_objects, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_COMMAND_NEW_UPGRADE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_COMMAND_NEW_UPGRADE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_command_new_upgrade(void*_Nonnull upgrade, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_CONSENSUSCOMMITDIGEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_CONSENSUSCOMMITDIGEST +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_consensuscommitdigest(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_CONSENSUSCOMMITDIGEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_CONSENSUSCOMMITDIGEST +void uniffi_iota_sdk_ffi_fn_free_consensuscommitdigest(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CONSENSUSCOMMITDIGEST_FROM_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CONSENSUSCOMMITDIGEST_FROM_BASE58 +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_consensuscommitdigest_from_base58(RustBuffer base58, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CONSENSUSCOMMITDIGEST_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CONSENSUSCOMMITDIGEST_FROM_BYTES +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_consensuscommitdigest_from_bytes(RustBuffer bytes, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CONSENSUSCOMMITDIGEST_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CONSENSUSCOMMITDIGEST_GENERATE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_consensuscommitdigest_generate(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CONSENSUSCOMMITDIGEST_TO_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CONSENSUSCOMMITDIGEST_TO_BASE58 +RustBuffer uniffi_iota_sdk_ffi_fn_method_consensuscommitdigest_to_base58(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CONSENSUSCOMMITDIGEST_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CONSENSUSCOMMITDIGEST_TO_BYTES +RustBuffer uniffi_iota_sdk_ffi_fn_method_consensuscommitdigest_to_bytes(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_CONSENSUSCOMMITPROLOGUEV1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_CONSENSUSCOMMITPROLOGUEV1 +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_consensuscommitprologuev1(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_CONSENSUSCOMMITPROLOGUEV1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_CONSENSUSCOMMITPROLOGUEV1 +void uniffi_iota_sdk_ffi_fn_free_consensuscommitprologuev1(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CONSENSUSCOMMITPROLOGUEV1_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CONSENSUSCOMMITPROLOGUEV1_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_consensuscommitprologuev1_new(uint64_t epoch, uint64_t round, RustBuffer sub_dag_index, uint64_t commit_timestamp_ms, void*_Nonnull consensus_commit_digest, void*_Nonnull consensus_determined_version_assignments, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CONSENSUSCOMMITPROLOGUEV1_COMMIT_TIMESTAMP_MS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CONSENSUSCOMMITPROLOGUEV1_COMMIT_TIMESTAMP_MS +uint64_t uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_commit_timestamp_ms(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CONSENSUSCOMMITPROLOGUEV1_CONSENSUS_COMMIT_DIGEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CONSENSUSCOMMITPROLOGUEV1_CONSENSUS_COMMIT_DIGEST +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_consensus_commit_digest(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CONSENSUSCOMMITPROLOGUEV1_CONSENSUS_DETERMINED_VERSION_ASSIGNMENTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CONSENSUSCOMMITPROLOGUEV1_CONSENSUS_DETERMINED_VERSION_ASSIGNMENTS +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_consensus_determined_version_assignments(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CONSENSUSCOMMITPROLOGUEV1_EPOCH +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CONSENSUSCOMMITPROLOGUEV1_EPOCH +uint64_t uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_epoch(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CONSENSUSCOMMITPROLOGUEV1_ROUND +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CONSENSUSCOMMITPROLOGUEV1_ROUND +uint64_t uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_round(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CONSENSUSCOMMITPROLOGUEV1_SUB_DAG_INDEX +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CONSENSUSCOMMITPROLOGUEV1_SUB_DAG_INDEX +RustBuffer uniffi_iota_sdk_ffi_fn_method_consensuscommitprologuev1_sub_dag_index(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_CONSENSUSDETERMINEDVERSIONASSIGNMENTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_CONSENSUSDETERMINEDVERSIONASSIGNMENTS +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_consensusdeterminedversionassignments(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_CONSENSUSDETERMINEDVERSIONASSIGNMENTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_CONSENSUSDETERMINEDVERSIONASSIGNMENTS +void uniffi_iota_sdk_ffi_fn_free_consensusdeterminedversionassignments(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CONSENSUSDETERMINEDVERSIONASSIGNMENTS_NEW_CANCELLED_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_CONSENSUSDETERMINEDVERSIONASSIGNMENTS_NEW_CANCELLED_TRANSACTIONS +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_consensusdeterminedversionassignments_new_cancelled_transactions(RustBuffer cancelled_transactions, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CONSENSUSDETERMINEDVERSIONASSIGNMENTS_AS_CANCELLED_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CONSENSUSDETERMINEDVERSIONASSIGNMENTS_AS_CANCELLED_TRANSACTIONS +RustBuffer uniffi_iota_sdk_ffi_fn_method_consensusdeterminedversionassignments_as_cancelled_transactions(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CONSENSUSDETERMINEDVERSIONASSIGNMENTS_AS_CANCELLED_TRANSACTIONS_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CONSENSUSDETERMINEDVERSIONASSIGNMENTS_AS_CANCELLED_TRANSACTIONS_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_consensusdeterminedversionassignments_as_cancelled_transactions_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CONSENSUSDETERMINEDVERSIONASSIGNMENTS_IS_CANCELLED_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_CONSENSUSDETERMINEDVERSIONASSIGNMENTS_IS_CANCELLED_TRANSACTIONS +int8_t uniffi_iota_sdk_ffi_fn_method_consensusdeterminedversionassignments_is_cancelled_transactions(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_DIGEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_DIGEST +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_digest(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_DIGEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_DIGEST +void uniffi_iota_sdk_ffi_fn_free_digest(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_DIGEST_FROM_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_DIGEST_FROM_BASE58 +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_digest_from_base58(RustBuffer base58, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_DIGEST_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_DIGEST_FROM_BYTES +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_digest_from_bytes(RustBuffer bytes, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_DIGEST_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_DIGEST_GENERATE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_digest_generate(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_DIGEST_TO_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_DIGEST_TO_BASE58 +RustBuffer uniffi_iota_sdk_ffi_fn_method_digest_to_base58(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_DIGEST_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_DIGEST_TO_BYTES +RustBuffer uniffi_iota_sdk_ffi_fn_method_digest_to_bytes(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_ED25519PUBLICKEY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_ED25519PUBLICKEY +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_ed25519publickey(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_ED25519PUBLICKEY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_ED25519PUBLICKEY +void uniffi_iota_sdk_ffi_fn_free_ed25519publickey(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ED25519PUBLICKEY_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ED25519PUBLICKEY_FROM_BYTES +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_ed25519publickey_from_bytes(RustBuffer bytes, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ED25519PUBLICKEY_FROM_STR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ED25519PUBLICKEY_FROM_STR +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_ed25519publickey_from_str(RustBuffer s, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ED25519PUBLICKEY_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ED25519PUBLICKEY_GENERATE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_ed25519publickey_generate(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ED25519PUBLICKEY_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ED25519PUBLICKEY_TO_BYTES +RustBuffer uniffi_iota_sdk_ffi_fn_method_ed25519publickey_to_bytes(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_ED25519SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_ED25519SIGNATURE +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_ed25519signature(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_ED25519SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_ED25519SIGNATURE +void uniffi_iota_sdk_ffi_fn_free_ed25519signature(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ED25519SIGNATURE_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ED25519SIGNATURE_FROM_BYTES +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_ed25519signature_from_bytes(RustBuffer bytes, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ED25519SIGNATURE_FROM_STR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ED25519SIGNATURE_FROM_STR +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_ed25519signature_from_str(RustBuffer s, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ED25519SIGNATURE_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ED25519SIGNATURE_GENERATE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_ed25519signature_generate(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ED25519SIGNATURE_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ED25519SIGNATURE_TO_BYTES +RustBuffer uniffi_iota_sdk_ffi_fn_method_ed25519signature_to_bytes(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_EFFECTSAUXILIARYDATADIGEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_EFFECTSAUXILIARYDATADIGEST +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_effectsauxiliarydatadigest(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_EFFECTSAUXILIARYDATADIGEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_EFFECTSAUXILIARYDATADIGEST +void uniffi_iota_sdk_ffi_fn_free_effectsauxiliarydatadigest(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_EFFECTSAUXILIARYDATADIGEST_FROM_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_EFFECTSAUXILIARYDATADIGEST_FROM_BASE58 +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_effectsauxiliarydatadigest_from_base58(RustBuffer base58, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_EFFECTSAUXILIARYDATADIGEST_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_EFFECTSAUXILIARYDATADIGEST_FROM_BYTES +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_effectsauxiliarydatadigest_from_bytes(RustBuffer bytes, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_EFFECTSAUXILIARYDATADIGEST_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_EFFECTSAUXILIARYDATADIGEST_GENERATE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_effectsauxiliarydatadigest_generate(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_EFFECTSAUXILIARYDATADIGEST_TO_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_EFFECTSAUXILIARYDATADIGEST_TO_BASE58 +RustBuffer uniffi_iota_sdk_ffi_fn_method_effectsauxiliarydatadigest_to_base58(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_EFFECTSAUXILIARYDATADIGEST_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_EFFECTSAUXILIARYDATADIGEST_TO_BYTES +RustBuffer uniffi_iota_sdk_ffi_fn_method_effectsauxiliarydatadigest_to_bytes(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_ENDOFEPOCHTRANSACTIONKIND +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_ENDOFEPOCHTRANSACTIONKIND +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_endofepochtransactionkind(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_ENDOFEPOCHTRANSACTIONKIND +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_ENDOFEPOCHTRANSACTIONKIND +void uniffi_iota_sdk_ffi_fn_free_endofepochtransactionkind(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ENDOFEPOCHTRANSACTIONKIND_AUTHENTICATOR_STATE_CREATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ENDOFEPOCHTRANSACTIONKIND_AUTHENTICATOR_STATE_CREATE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_endofepochtransactionkind_authenticator_state_create(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ENDOFEPOCHTRANSACTIONKIND_AUTHENTICATOR_STATE_EXPIRE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ENDOFEPOCHTRANSACTIONKIND_AUTHENTICATOR_STATE_EXPIRE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_endofepochtransactionkind_authenticator_state_expire(RustBuffer tx, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ENDOFEPOCHTRANSACTIONKIND_CHANGE_EPOCH +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ENDOFEPOCHTRANSACTIONKIND_CHANGE_EPOCH +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_endofepochtransactionkind_change_epoch(void*_Nonnull tx, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ENDOFEPOCHTRANSACTIONKIND_CHANGE_EPOCH_V2 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ENDOFEPOCHTRANSACTIONKIND_CHANGE_EPOCH_V2 +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_endofepochtransactionkind_change_epoch_v2(void*_Nonnull tx, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_EPOCH +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_EPOCH +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_epoch(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_EPOCH +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_EPOCH +void uniffi_iota_sdk_ffi_fn_free_epoch(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_EXECUTIONTIMEOBSERVATION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_EXECUTIONTIMEOBSERVATION +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_executiontimeobservation(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_EXECUTIONTIMEOBSERVATION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_EXECUTIONTIMEOBSERVATION +void uniffi_iota_sdk_ffi_fn_free_executiontimeobservation(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_EXECUTIONTIMEOBSERVATION_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_EXECUTIONTIMEOBSERVATION_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservation_new(void*_Nonnull key, RustBuffer observations, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_EXECUTIONTIMEOBSERVATION_KEY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_EXECUTIONTIMEOBSERVATION_KEY +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_executiontimeobservation_key(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_EXECUTIONTIMEOBSERVATION_OBSERVATIONS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_EXECUTIONTIMEOBSERVATION_OBSERVATIONS +RustBuffer uniffi_iota_sdk_ffi_fn_method_executiontimeobservation_observations(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_EXECUTIONTIMEOBSERVATIONKEY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_EXECUTIONTIMEOBSERVATIONKEY +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_executiontimeobservationkey(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_EXECUTIONTIMEOBSERVATIONKEY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_EXECUTIONTIMEOBSERVATIONKEY +void uniffi_iota_sdk_ffi_fn_free_executiontimeobservationkey(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_MAKE_MOVE_VEC +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_MAKE_MOVE_VEC +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_make_move_vec(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_MERGE_COINS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_MERGE_COINS +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_merge_coins(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_MOVE_ENTRY_POINT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_MOVE_ENTRY_POINT +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_move_entry_point(void*_Nonnull package, RustBuffer module, RustBuffer function, RustBuffer type_arguments, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_PUBLISH +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_PUBLISH +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_publish(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_SPLIT_COINS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_SPLIT_COINS +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_split_coins(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_TRANSFER_OBJECTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_TRANSFER_OBJECTS +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_transfer_objects(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_UPGRADE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_UPGRADE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservationkey_new_upgrade(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_EXECUTIONTIMEOBSERVATIONS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_EXECUTIONTIMEOBSERVATIONS +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_executiontimeobservations(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_EXECUTIONTIMEOBSERVATIONS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_EXECUTIONTIMEOBSERVATIONS +void uniffi_iota_sdk_ffi_fn_free_executiontimeobservations(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONS_NEW_V1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONS_NEW_V1 +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_executiontimeobservations_new_v1(RustBuffer execution_time_observations, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_FAUCETCLIENT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_FAUCETCLIENT +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_faucetclient(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_FAUCETCLIENT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_FAUCETCLIENT +void uniffi_iota_sdk_ffi_fn_free_faucetclient(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_FAUCETCLIENT_DEVNET +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_FAUCETCLIENT_DEVNET +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_faucetclient_devnet(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_FAUCETCLIENT_LOCAL +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_FAUCETCLIENT_LOCAL +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_faucetclient_local(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_FAUCETCLIENT_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_FAUCETCLIENT_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_faucetclient_new(RustBuffer faucet_url, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_FAUCETCLIENT_TESTNET +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_FAUCETCLIENT_TESTNET +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_faucetclient_testnet(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_FAUCETCLIENT_REQUEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_FAUCETCLIENT_REQUEST +uint64_t uniffi_iota_sdk_ffi_fn_method_faucetclient_request(void*_Nonnull ptr, void*_Nonnull address +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_FAUCETCLIENT_REQUEST_AND_WAIT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_FAUCETCLIENT_REQUEST_AND_WAIT +uint64_t uniffi_iota_sdk_ffi_fn_method_faucetclient_request_and_wait(void*_Nonnull ptr, void*_Nonnull address +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_FAUCETCLIENT_REQUEST_STATUS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_FAUCETCLIENT_REQUEST_STATUS +uint64_t uniffi_iota_sdk_ffi_fn_method_faucetclient_request_status(void*_Nonnull ptr, RustBuffer id +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_FAUCETRECEIPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_FAUCETRECEIPT +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_faucetreceipt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_FAUCETRECEIPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_FAUCETRECEIPT +void uniffi_iota_sdk_ffi_fn_free_faucetreceipt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_GENESISOBJECT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_GENESISOBJECT +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_genesisobject(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_GENESISOBJECT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_GENESISOBJECT +void uniffi_iota_sdk_ffi_fn_free_genesisobject(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_GENESISOBJECT_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_GENESISOBJECT_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_genesisobject_new(void*_Nonnull data, void*_Nonnull owner, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GENESISOBJECT_DATA +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GENESISOBJECT_DATA +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_genesisobject_data(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GENESISOBJECT_OBJECT_ID +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GENESISOBJECT_OBJECT_ID +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_genesisobject_object_id(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GENESISOBJECT_OBJECT_TYPE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GENESISOBJECT_OBJECT_TYPE +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_genesisobject_object_type(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GENESISOBJECT_OWNER +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GENESISOBJECT_OWNER +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_genesisobject_owner(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GENESISOBJECT_VERSION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GENESISOBJECT_VERSION +uint64_t uniffi_iota_sdk_ffi_fn_method_genesisobject_version(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_GENESISTRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_GENESISTRANSACTION +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_genesistransaction(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_GENESISTRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_GENESISTRANSACTION +void uniffi_iota_sdk_ffi_fn_free_genesistransaction(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_GENESISTRANSACTION_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_GENESISTRANSACTION_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_genesistransaction_new(RustBuffer objects, RustBuffer events, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GENESISTRANSACTION_EVENTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GENESISTRANSACTION_EVENTS +RustBuffer uniffi_iota_sdk_ffi_fn_method_genesistransaction_events(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GENESISTRANSACTION_OBJECTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GENESISTRANSACTION_OBJECTS +RustBuffer uniffi_iota_sdk_ffi_fn_method_genesistransaction_objects(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_GRAPHQLCLIENT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_GRAPHQLCLIENT +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_graphqlclient(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_GRAPHQLCLIENT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_GRAPHQLCLIENT +void uniffi_iota_sdk_ffi_fn_free_graphqlclient(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_GRAPHQLCLIENT_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_GRAPHQLCLIENT_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_graphqlclient_new(RustBuffer server, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_GRAPHQLCLIENT_NEW_DEVNET +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_GRAPHQLCLIENT_NEW_DEVNET +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_graphqlclient_new_devnet(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_GRAPHQLCLIENT_NEW_LOCALHOST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_GRAPHQLCLIENT_NEW_LOCALHOST +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_graphqlclient_new_localhost(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_GRAPHQLCLIENT_NEW_MAINNET +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_GRAPHQLCLIENT_NEW_MAINNET +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_graphqlclient_new_mainnet(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_GRAPHQLCLIENT_NEW_TESTNET +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_GRAPHQLCLIENT_NEW_TESTNET +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_graphqlclient_new_testnet(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_ACTIVE_VALIDATORS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_ACTIVE_VALIDATORS +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_active_validators(void*_Nonnull ptr, RustBuffer pagination_filter, RustBuffer epoch +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_BALANCE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_BALANCE +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_balance(void*_Nonnull ptr, void*_Nonnull address, RustBuffer coin_type +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_CHAIN_ID +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_CHAIN_ID +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_chain_id(void*_Nonnull ptr +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_CHECKPOINT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_CHECKPOINT +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_checkpoint(void*_Nonnull ptr, RustBuffer digest, RustBuffer seq_num +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_CHECKPOINTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_CHECKPOINTS +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_checkpoints(void*_Nonnull ptr, RustBuffer pagination_filter +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_COIN_METADATA +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_COIN_METADATA +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_coin_metadata(void*_Nonnull ptr, RustBuffer coin_type +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_COINS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_COINS +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_coins(void*_Nonnull ptr, void*_Nonnull owner, RustBuffer pagination_filter, RustBuffer coin_type +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_DRY_RUN_TX +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_DRY_RUN_TX +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_dry_run_tx(void*_Nonnull ptr, void*_Nonnull tx, RustBuffer skip_checks +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_DRY_RUN_TX_KIND +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_DRY_RUN_TX_KIND +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_dry_run_tx_kind(void*_Nonnull ptr, void*_Nonnull tx_kind, RustBuffer tx_meta, RustBuffer skip_checks +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_DYNAMIC_FIELD +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_DYNAMIC_FIELD +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_dynamic_field(void*_Nonnull ptr, void*_Nonnull address, void*_Nonnull type_tag, RustBuffer name +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_DYNAMIC_FIELDS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_DYNAMIC_FIELDS +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_dynamic_fields(void*_Nonnull ptr, void*_Nonnull address, RustBuffer pagination_filter +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_DYNAMIC_OBJECT_FIELD +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_DYNAMIC_OBJECT_FIELD +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_dynamic_object_field(void*_Nonnull ptr, void*_Nonnull address, void*_Nonnull type_tag, RustBuffer name +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_EPOCH +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_EPOCH +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_epoch(void*_Nonnull ptr, RustBuffer epoch +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_EPOCH_TOTAL_CHECKPOINTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_EPOCH_TOTAL_CHECKPOINTS +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_epoch_total_checkpoints(void*_Nonnull ptr, RustBuffer epoch +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_EPOCH_TOTAL_TRANSACTION_BLOCKS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_EPOCH_TOTAL_TRANSACTION_BLOCKS +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_epoch_total_transaction_blocks(void*_Nonnull ptr, RustBuffer epoch +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_EVENTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_EVENTS +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_events(void*_Nonnull ptr, RustBuffer pagination_filter, RustBuffer filter +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_EXECUTE_TX +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_EXECUTE_TX +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_execute_tx(void*_Nonnull ptr, RustBuffer signatures, void*_Nonnull tx +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_LATEST_CHECKPOINT_SEQUENCE_NUMBER +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_LATEST_CHECKPOINT_SEQUENCE_NUMBER +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_latest_checkpoint_sequence_number(void*_Nonnull ptr +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_MAX_PAGE_SIZE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_MAX_PAGE_SIZE +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_max_page_size(void*_Nonnull ptr +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_MOVE_OBJECT_CONTENTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_MOVE_OBJECT_CONTENTS +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_move_object_contents(void*_Nonnull ptr, void*_Nonnull object_id, RustBuffer version +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_MOVE_OBJECT_CONTENTS_BCS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_MOVE_OBJECT_CONTENTS_BCS +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_move_object_contents_bcs(void*_Nonnull ptr, void*_Nonnull object_id, RustBuffer version +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_NORMALIZED_MOVE_FUNCTION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_NORMALIZED_MOVE_FUNCTION +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_normalized_move_function(void*_Nonnull ptr, RustBuffer package, RustBuffer module, RustBuffer function, RustBuffer version +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_NORMALIZED_MOVE_MODULE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_NORMALIZED_MOVE_MODULE +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_normalized_move_module(void*_Nonnull ptr, RustBuffer package, RustBuffer module, RustBuffer pagination_filter_enums, RustBuffer pagination_filter_friends, RustBuffer pagination_filter_functions, RustBuffer pagination_filter_structs, RustBuffer version +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_OBJECT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_OBJECT +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_object(void*_Nonnull ptr, void*_Nonnull object_id, RustBuffer version +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_OBJECT_BCS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_OBJECT_BCS +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_object_bcs(void*_Nonnull ptr, void*_Nonnull object_id +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_OBJECTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_OBJECTS +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_objects(void*_Nonnull ptr, RustBuffer pagination_filter, RustBuffer filter +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_PACKAGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_PACKAGE +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_package(void*_Nonnull ptr, void*_Nonnull address, RustBuffer version +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_PACKAGE_LATEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_PACKAGE_LATEST +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_package_latest(void*_Nonnull ptr, void*_Nonnull address +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_PACKAGE_VERSIONS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_PACKAGE_VERSIONS +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_package_versions(void*_Nonnull ptr, void*_Nonnull address, RustBuffer pagination_filter, RustBuffer after_version, RustBuffer before_version +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_PACKAGES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_PACKAGES +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_packages(void*_Nonnull ptr, RustBuffer pagination_filter, RustBuffer after_checkpoint, RustBuffer before_checkpoint +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_PROTOCOL_CONFIG +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_PROTOCOL_CONFIG +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_protocol_config(void*_Nonnull ptr, RustBuffer version +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_REFERENCE_GAS_PRICE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_REFERENCE_GAS_PRICE +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_reference_gas_price(void*_Nonnull ptr, RustBuffer epoch +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_SERVICE_CONFIG +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_SERVICE_CONFIG +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_service_config(void*_Nonnull ptr +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_SET_RPC_SERVER +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_SET_RPC_SERVER +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_set_rpc_server(void*_Nonnull ptr, RustBuffer server +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_TOTAL_SUPPLY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_TOTAL_SUPPLY +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_total_supply(void*_Nonnull ptr, RustBuffer coin_type +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_TOTAL_TRANSACTION_BLOCKS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_TOTAL_TRANSACTION_BLOCKS +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_total_transaction_blocks(void*_Nonnull ptr +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_TOTAL_TRANSACTION_BLOCKS_BY_DIGEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_TOTAL_TRANSACTION_BLOCKS_BY_DIGEST +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_total_transaction_blocks_by_digest(void*_Nonnull ptr, void*_Nonnull digest +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_TOTAL_TRANSACTION_BLOCKS_BY_SEQ_NUM +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_TOTAL_TRANSACTION_BLOCKS_BY_SEQ_NUM +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_total_transaction_blocks_by_seq_num(void*_Nonnull ptr, uint64_t seq_num +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_TRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_TRANSACTION +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_transaction(void*_Nonnull ptr, void*_Nonnull digest +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_TRANSACTION_DATA_EFFECTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_TRANSACTION_DATA_EFFECTS +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_transaction_data_effects(void*_Nonnull ptr, void*_Nonnull digest +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_TRANSACTION_EFFECTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_TRANSACTION_EFFECTS +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_transaction_effects(void*_Nonnull ptr, void*_Nonnull digest +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_TRANSACTIONS +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_transactions(void*_Nonnull ptr, RustBuffer pagination_filter, RustBuffer filter +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_TRANSACTIONS_DATA_EFFECTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_TRANSACTIONS_DATA_EFFECTS +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_transactions_data_effects(void*_Nonnull ptr, RustBuffer pagination_filter, RustBuffer filter +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_TRANSACTIONS_EFFECTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_GRAPHQLCLIENT_TRANSACTIONS_EFFECTS +uint64_t uniffi_iota_sdk_ffi_fn_method_graphqlclient_transactions_effects(void*_Nonnull ptr, RustBuffer pagination_filter, RustBuffer filter +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_IDENTIFIER +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_IDENTIFIER +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_identifier(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_IDENTIFIER +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_IDENTIFIER +void uniffi_iota_sdk_ffi_fn_free_identifier(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_IDENTIFIER_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_IDENTIFIER_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_identifier_new(RustBuffer identifier, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_IDENTIFIER_AS_STR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_IDENTIFIER_AS_STR +RustBuffer uniffi_iota_sdk_ffi_fn_method_identifier_as_str(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_INPUT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_INPUT +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_input(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_INPUT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_INPUT +void uniffi_iota_sdk_ffi_fn_free_input(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_INPUT_NEW_IMMUTABLE_OR_OWNED +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_INPUT_NEW_IMMUTABLE_OR_OWNED +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_input_new_immutable_or_owned(RustBuffer object_ref, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_INPUT_NEW_PURE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_INPUT_NEW_PURE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_input_new_pure(RustBuffer value, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_INPUT_NEW_RECEIVING +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_INPUT_NEW_RECEIVING +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_input_new_receiving(RustBuffer object_ref, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_INPUT_NEW_SHARED +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_INPUT_NEW_SHARED +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_input_new_shared(void*_Nonnull object_id, uint64_t initial_shared_version, int8_t mutable, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_MAKEMOVEVECTOR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_MAKEMOVEVECTOR +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_makemovevector(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_MAKEMOVEVECTOR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_MAKEMOVEVECTOR +void uniffi_iota_sdk_ffi_fn_free_makemovevector(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_MAKEMOVEVECTOR_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_MAKEMOVEVECTOR_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_makemovevector_new(RustBuffer type_tag, RustBuffer elements, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MAKEMOVEVECTOR_ELEMENTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MAKEMOVEVECTOR_ELEMENTS +RustBuffer uniffi_iota_sdk_ffi_fn_method_makemovevector_elements(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MAKEMOVEVECTOR_TYPE_TAG +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MAKEMOVEVECTOR_TYPE_TAG +RustBuffer uniffi_iota_sdk_ffi_fn_method_makemovevector_type_tag(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_MERGECOINS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_MERGECOINS +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_mergecoins(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_MERGECOINS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_MERGECOINS +void uniffi_iota_sdk_ffi_fn_free_mergecoins(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_MERGECOINS_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_MERGECOINS_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_mergecoins_new(void*_Nonnull coin, RustBuffer coins_to_merge, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MERGECOINS_COIN +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MERGECOINS_COIN +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_mergecoins_coin(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MERGECOINS_COINS_TO_MERGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MERGECOINS_COINS_TO_MERGE +RustBuffer uniffi_iota_sdk_ffi_fn_method_mergecoins_coins_to_merge(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_MOVECALL +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_MOVECALL +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_movecall(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_MOVECALL +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_MOVECALL +void uniffi_iota_sdk_ffi_fn_free_movecall(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_MOVECALL_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_MOVECALL_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_movecall_new(void*_Nonnull package, void*_Nonnull module, void*_Nonnull function, RustBuffer type_arguments, RustBuffer arguments, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MOVECALL_ARGUMENTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MOVECALL_ARGUMENTS +RustBuffer uniffi_iota_sdk_ffi_fn_method_movecall_arguments(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MOVECALL_FUNCTION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MOVECALL_FUNCTION +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_movecall_function(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MOVECALL_MODULE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MOVECALL_MODULE +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_movecall_module(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MOVECALL_PACKAGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MOVECALL_PACKAGE +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_movecall_package(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MOVECALL_TYPE_ARGUMENTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MOVECALL_TYPE_ARGUMENTS +RustBuffer uniffi_iota_sdk_ffi_fn_method_movecall_type_arguments(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_MOVEPACKAGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_MOVEPACKAGE +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_movepackage(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_MOVEPACKAGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_MOVEPACKAGE +void uniffi_iota_sdk_ffi_fn_free_movepackage(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_MOVEPACKAGE_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_MOVEPACKAGE_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_movepackage_new(void*_Nonnull id, uint64_t version, RustBuffer modules, RustBuffer type_origin_table, RustBuffer linkage_table, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_MULTISIGAGGREGATEDSIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_MULTISIGAGGREGATEDSIGNATURE +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_multisigaggregatedsignature(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_MULTISIGAGGREGATEDSIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_MULTISIGAGGREGATEDSIGNATURE +void uniffi_iota_sdk_ffi_fn_free_multisigaggregatedsignature(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_MULTISIGAGGREGATEDSIGNATURE_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_MULTISIGAGGREGATEDSIGNATURE_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_multisigaggregatedsignature_new(void*_Nonnull committee, RustBuffer signatures, uint16_t bitmap, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGAGGREGATEDSIGNATURE_BITMAP +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGAGGREGATEDSIGNATURE_BITMAP +uint16_t uniffi_iota_sdk_ffi_fn_method_multisigaggregatedsignature_bitmap(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGAGGREGATEDSIGNATURE_COMMITTEE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGAGGREGATEDSIGNATURE_COMMITTEE +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_multisigaggregatedsignature_committee(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGAGGREGATEDSIGNATURE_SIGNATURES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGAGGREGATEDSIGNATURE_SIGNATURES +RustBuffer uniffi_iota_sdk_ffi_fn_method_multisigaggregatedsignature_signatures(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_MULTISIGCOMMITTEE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_MULTISIGCOMMITTEE +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_multisigcommittee(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_MULTISIGCOMMITTEE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_MULTISIGCOMMITTEE +void uniffi_iota_sdk_ffi_fn_free_multisigcommittee(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_MULTISIGCOMMITTEE_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_MULTISIGCOMMITTEE_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_multisigcommittee_new(RustBuffer members, uint16_t threshold, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGCOMMITTEE_IS_VALID +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGCOMMITTEE_IS_VALID +int8_t uniffi_iota_sdk_ffi_fn_method_multisigcommittee_is_valid(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGCOMMITTEE_MEMBERS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGCOMMITTEE_MEMBERS +RustBuffer uniffi_iota_sdk_ffi_fn_method_multisigcommittee_members(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGCOMMITTEE_SCHEME +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGCOMMITTEE_SCHEME +RustBuffer uniffi_iota_sdk_ffi_fn_method_multisigcommittee_scheme(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGCOMMITTEE_THRESHOLD +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGCOMMITTEE_THRESHOLD +uint16_t uniffi_iota_sdk_ffi_fn_method_multisigcommittee_threshold(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_MULTISIGMEMBER +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_MULTISIGMEMBER +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_multisigmember(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_MULTISIGMEMBER +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_MULTISIGMEMBER +void uniffi_iota_sdk_ffi_fn_free_multisigmember(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_MULTISIGMEMBER_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_MULTISIGMEMBER_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_multisigmember_new(void*_Nonnull public_key, uint8_t weight, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBER_PUBLIC_KEY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBER_PUBLIC_KEY +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_multisigmember_public_key(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBER_WEIGHT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBER_WEIGHT +uint8_t uniffi_iota_sdk_ffi_fn_method_multisigmember_weight(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_MULTISIGMEMBERPUBLICKEY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_MULTISIGMEMBERPUBLICKEY +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_multisigmemberpublickey(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_MULTISIGMEMBERPUBLICKEY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_MULTISIGMEMBERPUBLICKEY +void uniffi_iota_sdk_ffi_fn_free_multisigmemberpublickey(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERPUBLICKEY_AS_ED25519 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERPUBLICKEY_AS_ED25519 +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_ed25519(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERPUBLICKEY_AS_ED25519_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERPUBLICKEY_AS_ED25519_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_ed25519_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERPUBLICKEY_AS_SECP256K1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERPUBLICKEY_AS_SECP256K1 +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_secp256k1(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERPUBLICKEY_AS_SECP256K1_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERPUBLICKEY_AS_SECP256K1_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_secp256k1_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERPUBLICKEY_AS_SECP256R1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERPUBLICKEY_AS_SECP256R1 +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_secp256r1(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERPUBLICKEY_AS_SECP256R1_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERPUBLICKEY_AS_SECP256R1_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_secp256r1_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERPUBLICKEY_AS_ZKLOGIN +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERPUBLICKEY_AS_ZKLOGIN +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_zklogin(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERPUBLICKEY_AS_ZKLOGIN_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERPUBLICKEY_AS_ZKLOGIN_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_as_zklogin_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERPUBLICKEY_IS_ED25519 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERPUBLICKEY_IS_ED25519 +int8_t uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_is_ed25519(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERPUBLICKEY_IS_SECP256K1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERPUBLICKEY_IS_SECP256K1 +int8_t uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_is_secp256k1(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERPUBLICKEY_IS_SECP256R1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERPUBLICKEY_IS_SECP256R1 +int8_t uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_is_secp256r1(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERPUBLICKEY_IS_ZKLOGIN +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERPUBLICKEY_IS_ZKLOGIN +int8_t uniffi_iota_sdk_ffi_fn_method_multisigmemberpublickey_is_zklogin(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_MULTISIGMEMBERSIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_MULTISIGMEMBERSIGNATURE +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_multisigmembersignature(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_MULTISIGMEMBERSIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_MULTISIGMEMBERSIGNATURE +void uniffi_iota_sdk_ffi_fn_free_multisigmembersignature(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERSIGNATURE_AS_ED25519 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERSIGNATURE_AS_ED25519 +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_ed25519(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERSIGNATURE_AS_ED25519_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERSIGNATURE_AS_ED25519_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_ed25519_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERSIGNATURE_AS_SECP256K1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERSIGNATURE_AS_SECP256K1 +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_secp256k1(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERSIGNATURE_AS_SECP256K1_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERSIGNATURE_AS_SECP256K1_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_secp256k1_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERSIGNATURE_AS_SECP256R1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERSIGNATURE_AS_SECP256R1 +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_secp256r1(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERSIGNATURE_AS_SECP256R1_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERSIGNATURE_AS_SECP256R1_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_secp256r1_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERSIGNATURE_AS_ZKLOGIN +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERSIGNATURE_AS_ZKLOGIN +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_zklogin(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERSIGNATURE_AS_ZKLOGIN_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERSIGNATURE_AS_ZKLOGIN_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_as_zklogin_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERSIGNATURE_IS_ED25519 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERSIGNATURE_IS_ED25519 +int8_t uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_is_ed25519(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERSIGNATURE_IS_SECP256K1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERSIGNATURE_IS_SECP256K1 +int8_t uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_is_secp256k1(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERSIGNATURE_IS_SECP256R1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERSIGNATURE_IS_SECP256R1 +int8_t uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_is_secp256r1(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERSIGNATURE_IS_ZKLOGIN +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_MULTISIGMEMBERSIGNATURE_IS_ZKLOGIN +int8_t uniffi_iota_sdk_ffi_fn_method_multisigmembersignature_is_zklogin(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_OBJECT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_OBJECT +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_object(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_OBJECT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_OBJECT +void uniffi_iota_sdk_ffi_fn_free_object(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OBJECT_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OBJECT_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_object_new(void*_Nonnull data, void*_Nonnull owner, void*_Nonnull previous_transaction, uint64_t storage_rebate, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECT_AS_STRUCT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECT_AS_STRUCT +RustBuffer uniffi_iota_sdk_ffi_fn_method_object_as_struct(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECT_DATA +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECT_DATA +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_object_data(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECT_OBJECT_ID +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECT_OBJECT_ID +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_object_object_id(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECT_OBJECT_TYPE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECT_OBJECT_TYPE +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_object_object_type(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECT_OWNER +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECT_OWNER +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_object_owner(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECT_PREVIOUS_TRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECT_PREVIOUS_TRANSACTION +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_object_previous_transaction(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECT_STORAGE_REBATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECT_STORAGE_REBATE +uint64_t uniffi_iota_sdk_ffi_fn_method_object_storage_rebate(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECT_VERSION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECT_VERSION +uint64_t uniffi_iota_sdk_ffi_fn_method_object_version(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_OBJECTDATA +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_OBJECTDATA +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_objectdata(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_OBJECTDATA +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_OBJECTDATA +void uniffi_iota_sdk_ffi_fn_free_objectdata(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OBJECTDATA_NEW_MOVE_PACKAGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OBJECTDATA_NEW_MOVE_PACKAGE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_objectdata_new_move_package(void*_Nonnull move_package, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OBJECTDATA_NEW_MOVE_STRUCT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OBJECTDATA_NEW_MOVE_STRUCT +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_objectdata_new_move_struct(RustBuffer move_struct, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECTDATA_AS_PACKAGE_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECTDATA_AS_PACKAGE_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_objectdata_as_package_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECTDATA_AS_STRUCT_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECTDATA_AS_STRUCT_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_objectdata_as_struct_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECTDATA_IS_PACKAGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECTDATA_IS_PACKAGE +int8_t uniffi_iota_sdk_ffi_fn_method_objectdata_is_package(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECTDATA_IS_STRUCT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECTDATA_IS_STRUCT +int8_t uniffi_iota_sdk_ffi_fn_method_objectdata_is_struct(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_OBJECTDIGEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_OBJECTDIGEST +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_objectdigest(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_OBJECTDIGEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_OBJECTDIGEST +void uniffi_iota_sdk_ffi_fn_free_objectdigest(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OBJECTDIGEST_FROM_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OBJECTDIGEST_FROM_BASE58 +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_objectdigest_from_base58(RustBuffer base58, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OBJECTDIGEST_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OBJECTDIGEST_FROM_BYTES +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_objectdigest_from_bytes(RustBuffer bytes, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OBJECTDIGEST_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OBJECTDIGEST_GENERATE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_objectdigest_generate(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECTDIGEST_TO_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECTDIGEST_TO_BASE58 +RustBuffer uniffi_iota_sdk_ffi_fn_method_objectdigest_to_base58(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECTDIGEST_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECTDIGEST_TO_BYTES +RustBuffer uniffi_iota_sdk_ffi_fn_method_objectdigest_to_bytes(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_OBJECTID +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_OBJECTID +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_objectid(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_OBJECTID +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_OBJECTID +void uniffi_iota_sdk_ffi_fn_free_objectid(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OBJECTID_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OBJECTID_FROM_BYTES +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_objectid_from_bytes(RustBuffer bytes, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OBJECTID_FROM_HEX +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OBJECTID_FROM_HEX +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_objectid_from_hex(RustBuffer hex, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECTID_TO_ADDRESS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECTID_TO_ADDRESS +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_objectid_to_address(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECTID_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECTID_TO_BYTES +RustBuffer uniffi_iota_sdk_ffi_fn_method_objectid_to_bytes(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECTID_TO_HEX +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECTID_TO_HEX +RustBuffer uniffi_iota_sdk_ffi_fn_method_objectid_to_hex(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_OBJECTTYPE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_OBJECTTYPE +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_objecttype(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_OBJECTTYPE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_OBJECTTYPE +void uniffi_iota_sdk_ffi_fn_free_objecttype(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OBJECTTYPE_NEW_PACKAGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OBJECTTYPE_NEW_PACKAGE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_objecttype_new_package(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OBJECTTYPE_NEW_STRUCT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OBJECTTYPE_NEW_STRUCT +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_objecttype_new_struct(void*_Nonnull struct_tag, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECTTYPE_AS_STRUCT_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECTTYPE_AS_STRUCT_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_objecttype_as_struct_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECTTYPE_IS_PACKAGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECTTYPE_IS_PACKAGE +int8_t uniffi_iota_sdk_ffi_fn_method_objecttype_is_package(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECTTYPE_IS_STRUCT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OBJECTTYPE_IS_STRUCT +int8_t uniffi_iota_sdk_ffi_fn_method_objecttype_is_struct(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_OWNER +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_OWNER +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_owner(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_OWNER +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_OWNER +void uniffi_iota_sdk_ffi_fn_free_owner(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OWNER_NEW_ADDRESS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OWNER_NEW_ADDRESS +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_owner_new_address(void*_Nonnull address, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OWNER_NEW_IMMUTABLE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OWNER_NEW_IMMUTABLE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_owner_new_immutable(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OWNER_NEW_OBJECT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OWNER_NEW_OBJECT +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_owner_new_object(void*_Nonnull id, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OWNER_NEW_SHARED +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_OWNER_NEW_SHARED +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_owner_new_shared(uint64_t version, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OWNER_AS_ADDRESS_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OWNER_AS_ADDRESS_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_owner_as_address_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OWNER_AS_OBJECT_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OWNER_AS_OBJECT_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_owner_as_object_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OWNER_AS_SHARED_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OWNER_AS_SHARED_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_owner_as_shared_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OWNER_IS_ADDRESS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OWNER_IS_ADDRESS +int8_t uniffi_iota_sdk_ffi_fn_method_owner_is_address(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OWNER_IS_IMMUTABLE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OWNER_IS_IMMUTABLE +int8_t uniffi_iota_sdk_ffi_fn_method_owner_is_immutable(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OWNER_IS_OBJECT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OWNER_IS_OBJECT +int8_t uniffi_iota_sdk_ffi_fn_method_owner_is_object(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OWNER_IS_SHARED +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_OWNER_IS_SHARED +int8_t uniffi_iota_sdk_ffi_fn_method_owner_is_shared(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_PASSKEYAUTHENTICATOR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_PASSKEYAUTHENTICATOR +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_passkeyauthenticator(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_PASSKEYAUTHENTICATOR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_PASSKEYAUTHENTICATOR +void uniffi_iota_sdk_ffi_fn_free_passkeyauthenticator(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_PASSKEYAUTHENTICATOR_AUTHENTICATOR_DATA +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_PASSKEYAUTHENTICATOR_AUTHENTICATOR_DATA +RustBuffer uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_authenticator_data(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_PASSKEYAUTHENTICATOR_CHALLENGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_PASSKEYAUTHENTICATOR_CHALLENGE +RustBuffer uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_challenge(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_PASSKEYAUTHENTICATOR_CLIENT_DATA_JSON +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_PASSKEYAUTHENTICATOR_CLIENT_DATA_JSON +RustBuffer uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_client_data_json(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_PASSKEYAUTHENTICATOR_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_PASSKEYAUTHENTICATOR_SIGNATURE +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_passkeyauthenticator_signature(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_PROGRAMMABLETRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_PROGRAMMABLETRANSACTION +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_programmabletransaction(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_PROGRAMMABLETRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_PROGRAMMABLETRANSACTION +void uniffi_iota_sdk_ffi_fn_free_programmabletransaction(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_PROGRAMMABLETRANSACTION_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_PROGRAMMABLETRANSACTION_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_programmabletransaction_new(RustBuffer inputs, RustBuffer commands, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_PROGRAMMABLETRANSACTION_COMMANDS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_PROGRAMMABLETRANSACTION_COMMANDS +RustBuffer uniffi_iota_sdk_ffi_fn_method_programmabletransaction_commands(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_PROGRAMMABLETRANSACTION_INPUTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_PROGRAMMABLETRANSACTION_INPUTS +RustBuffer uniffi_iota_sdk_ffi_fn_method_programmabletransaction_inputs(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_PUBLISH +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_PUBLISH +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_publish(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_PUBLISH +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_PUBLISH +void uniffi_iota_sdk_ffi_fn_free_publish(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_PUBLISH_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_PUBLISH_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_publish_new(RustBuffer modules, RustBuffer dependencies, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_PUBLISH_DEPENDENCIES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_PUBLISH_DEPENDENCIES +RustBuffer uniffi_iota_sdk_ffi_fn_method_publish_dependencies(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_PUBLISH_MODULES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_PUBLISH_MODULES +RustBuffer uniffi_iota_sdk_ffi_fn_method_publish_modules(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_SECP256K1PUBLICKEY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_SECP256K1PUBLICKEY +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_secp256k1publickey(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_SECP256K1PUBLICKEY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_SECP256K1PUBLICKEY +void uniffi_iota_sdk_ffi_fn_free_secp256k1publickey(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SECP256K1PUBLICKEY_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SECP256K1PUBLICKEY_FROM_BYTES +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_secp256k1publickey_from_bytes(RustBuffer bytes, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SECP256K1PUBLICKEY_FROM_STR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SECP256K1PUBLICKEY_FROM_STR +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_secp256k1publickey_from_str(RustBuffer s, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SECP256K1PUBLICKEY_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SECP256K1PUBLICKEY_GENERATE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_secp256k1publickey_generate(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SECP256K1PUBLICKEY_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SECP256K1PUBLICKEY_TO_BYTES +RustBuffer uniffi_iota_sdk_ffi_fn_method_secp256k1publickey_to_bytes(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_SECP256K1SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_SECP256K1SIGNATURE +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_secp256k1signature(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_SECP256K1SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_SECP256K1SIGNATURE +void uniffi_iota_sdk_ffi_fn_free_secp256k1signature(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SECP256K1SIGNATURE_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SECP256K1SIGNATURE_FROM_BYTES +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_secp256k1signature_from_bytes(RustBuffer bytes, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SECP256K1SIGNATURE_FROM_STR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SECP256K1SIGNATURE_FROM_STR +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_secp256k1signature_from_str(RustBuffer s, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SECP256K1SIGNATURE_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SECP256K1SIGNATURE_GENERATE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_secp256k1signature_generate(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SECP256K1SIGNATURE_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SECP256K1SIGNATURE_TO_BYTES +RustBuffer uniffi_iota_sdk_ffi_fn_method_secp256k1signature_to_bytes(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_SECP256R1PUBLICKEY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_SECP256R1PUBLICKEY +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_secp256r1publickey(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_SECP256R1PUBLICKEY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_SECP256R1PUBLICKEY +void uniffi_iota_sdk_ffi_fn_free_secp256r1publickey(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SECP256R1PUBLICKEY_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SECP256R1PUBLICKEY_FROM_BYTES +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_secp256r1publickey_from_bytes(RustBuffer bytes, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SECP256R1PUBLICKEY_FROM_STR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SECP256R1PUBLICKEY_FROM_STR +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_secp256r1publickey_from_str(RustBuffer s, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SECP256R1PUBLICKEY_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SECP256R1PUBLICKEY_GENERATE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_secp256r1publickey_generate(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SECP256R1PUBLICKEY_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SECP256R1PUBLICKEY_TO_BYTES +RustBuffer uniffi_iota_sdk_ffi_fn_method_secp256r1publickey_to_bytes(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_SECP256R1SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_SECP256R1SIGNATURE +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_secp256r1signature(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_SECP256R1SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_SECP256R1SIGNATURE +void uniffi_iota_sdk_ffi_fn_free_secp256r1signature(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SECP256R1SIGNATURE_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SECP256R1SIGNATURE_FROM_BYTES +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_secp256r1signature_from_bytes(RustBuffer bytes, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SECP256R1SIGNATURE_FROM_STR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SECP256R1SIGNATURE_FROM_STR +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_secp256r1signature_from_str(RustBuffer s, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SECP256R1SIGNATURE_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SECP256R1SIGNATURE_GENERATE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_secp256r1signature_generate(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SECP256R1SIGNATURE_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SECP256R1SIGNATURE_TO_BYTES +RustBuffer uniffi_iota_sdk_ffi_fn_method_secp256r1signature_to_bytes(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_SIMPLESIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_SIMPLESIGNATURE +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_simplesignature(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_SIMPLESIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_SIMPLESIGNATURE +void uniffi_iota_sdk_ffi_fn_free_simplesignature(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_ED25519_PUB_KEY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_ED25519_PUB_KEY +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_simplesignature_ed25519_pub_key(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_ED25519_PUB_KEY_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_ED25519_PUB_KEY_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_simplesignature_ed25519_pub_key_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_ED25519_SIG +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_ED25519_SIG +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_simplesignature_ed25519_sig(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_ED25519_SIG_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_ED25519_SIG_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_simplesignature_ed25519_sig_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_IS_ED25519 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_IS_ED25519 +int8_t uniffi_iota_sdk_ffi_fn_method_simplesignature_is_ed25519(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_IS_SECP256K1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_IS_SECP256K1 +int8_t uniffi_iota_sdk_ffi_fn_method_simplesignature_is_secp256k1(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_IS_SECP256R1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_IS_SECP256R1 +int8_t uniffi_iota_sdk_ffi_fn_method_simplesignature_is_secp256r1(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_SCHEME +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_SCHEME +RustBuffer uniffi_iota_sdk_ffi_fn_method_simplesignature_scheme(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_SECP256K1_PUB_KEY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_SECP256K1_PUB_KEY +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256k1_pub_key(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_SECP256K1_PUB_KEY_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_SECP256K1_PUB_KEY_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256k1_pub_key_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_SECP256K1_SIG +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_SECP256K1_SIG +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256k1_sig(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_SECP256K1_SIG_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_SECP256K1_SIG_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256k1_sig_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_SECP256R1_PUB_KEY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_SECP256R1_PUB_KEY +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256r1_pub_key(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_SECP256R1_PUB_KEY_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_SECP256R1_PUB_KEY_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256r1_pub_key_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_SECP256R1_SIG +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_SECP256R1_SIG +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256r1_sig(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_SECP256R1_SIG_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_SECP256R1_SIG_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_simplesignature_secp256r1_sig_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SIMPLESIGNATURE_TO_BYTES +RustBuffer uniffi_iota_sdk_ffi_fn_method_simplesignature_to_bytes(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_SPLITCOINS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_SPLITCOINS +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_splitcoins(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_SPLITCOINS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_SPLITCOINS +void uniffi_iota_sdk_ffi_fn_free_splitcoins(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SPLITCOINS_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SPLITCOINS_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_splitcoins_new(void*_Nonnull coin, RustBuffer amounts, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SPLITCOINS_AMOUNTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SPLITCOINS_AMOUNTS +RustBuffer uniffi_iota_sdk_ffi_fn_method_splitcoins_amounts(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SPLITCOINS_COIN +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SPLITCOINS_COIN +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_splitcoins_coin(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_STRUCTTAG +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_STRUCTTAG +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_structtag(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_STRUCTTAG +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_STRUCTTAG +void uniffi_iota_sdk_ffi_fn_free_structtag(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_STRUCTTAG_COIN +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_STRUCTTAG_COIN +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_structtag_coin(void*_Nonnull type_tag, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_STRUCTTAG_GAS_COIN +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_STRUCTTAG_GAS_COIN +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_structtag_gas_coin(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_STRUCTTAG_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_STRUCTTAG_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_structtag_new(void*_Nonnull address, void*_Nonnull module, void*_Nonnull name, RustBuffer type_params, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_STRUCTTAG_STAKED_IOTA +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_STRUCTTAG_STAKED_IOTA +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_structtag_staked_iota(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_STRUCTTAG_ADDRESS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_STRUCTTAG_ADDRESS +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_structtag_address(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_STRUCTTAG_COIN_TYPE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_STRUCTTAG_COIN_TYPE +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_structtag_coin_type(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_STRUCTTAG_COIN_TYPE_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_STRUCTTAG_COIN_TYPE_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_structtag_coin_type_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_SYSTEMPACKAGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_SYSTEMPACKAGE +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_systempackage(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_SYSTEMPACKAGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_SYSTEMPACKAGE +void uniffi_iota_sdk_ffi_fn_free_systempackage(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SYSTEMPACKAGE_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_SYSTEMPACKAGE_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_systempackage_new(uint64_t version, RustBuffer modules, RustBuffer dependencies, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SYSTEMPACKAGE_DEPENDENCIES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SYSTEMPACKAGE_DEPENDENCIES +RustBuffer uniffi_iota_sdk_ffi_fn_method_systempackage_dependencies(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SYSTEMPACKAGE_MODULES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SYSTEMPACKAGE_MODULES +RustBuffer uniffi_iota_sdk_ffi_fn_method_systempackage_modules(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SYSTEMPACKAGE_VERSION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_SYSTEMPACKAGE_VERSION +uint64_t uniffi_iota_sdk_ffi_fn_method_systempackage_version(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_TRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_TRANSACTION +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_transaction(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_TRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_TRANSACTION +void uniffi_iota_sdk_ffi_fn_free_transaction(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTION_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTION_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_transaction_new(void*_Nonnull kind, void*_Nonnull sender, RustBuffer gas_payment, RustBuffer expiration, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSACTION_EXPIRATION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSACTION_EXPIRATION +RustBuffer uniffi_iota_sdk_ffi_fn_method_transaction_expiration(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSACTION_GAS_PAYMENT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSACTION_GAS_PAYMENT +RustBuffer uniffi_iota_sdk_ffi_fn_method_transaction_gas_payment(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSACTION_KIND +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSACTION_KIND +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_transaction_kind(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSACTION_SENDER +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSACTION_SENDER +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_transaction_sender(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_TRANSACTIONDIGEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_TRANSACTIONDIGEST +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_transactiondigest(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_TRANSACTIONDIGEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_TRANSACTIONDIGEST +void uniffi_iota_sdk_ffi_fn_free_transactiondigest(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONDIGEST_FROM_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONDIGEST_FROM_BASE58 +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_transactiondigest_from_base58(RustBuffer base58, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONDIGEST_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONDIGEST_FROM_BYTES +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_transactiondigest_from_bytes(RustBuffer bytes, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONDIGEST_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONDIGEST_GENERATE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_transactiondigest_generate(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSACTIONDIGEST_TO_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSACTIONDIGEST_TO_BASE58 +RustBuffer uniffi_iota_sdk_ffi_fn_method_transactiondigest_to_base58(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSACTIONDIGEST_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSACTIONDIGEST_TO_BYTES +RustBuffer uniffi_iota_sdk_ffi_fn_method_transactiondigest_to_bytes(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_TRANSACTIONEFFECTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_TRANSACTIONEFFECTS +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_transactioneffects(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_TRANSACTIONEFFECTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_TRANSACTIONEFFECTS +void uniffi_iota_sdk_ffi_fn_free_transactioneffects(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONEFFECTS_NEW_V1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONEFFECTS_NEW_V1 +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_transactioneffects_new_v1(RustBuffer effects, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSACTIONEFFECTS_AS_V1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSACTIONEFFECTS_AS_V1 +RustBuffer uniffi_iota_sdk_ffi_fn_method_transactioneffects_as_v1(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSACTIONEFFECTS_IS_V1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSACTIONEFFECTS_IS_V1 +int8_t uniffi_iota_sdk_ffi_fn_method_transactioneffects_is_v1(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_TRANSACTIONEFFECTSDIGEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_TRANSACTIONEFFECTSDIGEST +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_transactioneffectsdigest(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_TRANSACTIONEFFECTSDIGEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_TRANSACTIONEFFECTSDIGEST +void uniffi_iota_sdk_ffi_fn_free_transactioneffectsdigest(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONEFFECTSDIGEST_FROM_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONEFFECTSDIGEST_FROM_BASE58 +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_transactioneffectsdigest_from_base58(RustBuffer base58, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONEFFECTSDIGEST_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONEFFECTSDIGEST_FROM_BYTES +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_transactioneffectsdigest_from_bytes(RustBuffer bytes, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONEFFECTSDIGEST_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONEFFECTSDIGEST_GENERATE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_transactioneffectsdigest_generate(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSACTIONEFFECTSDIGEST_TO_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSACTIONEFFECTSDIGEST_TO_BASE58 +RustBuffer uniffi_iota_sdk_ffi_fn_method_transactioneffectsdigest_to_base58(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSACTIONEFFECTSDIGEST_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSACTIONEFFECTSDIGEST_TO_BYTES +RustBuffer uniffi_iota_sdk_ffi_fn_method_transactioneffectsdigest_to_bytes(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_TRANSACTIONEVENTSDIGEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_TRANSACTIONEVENTSDIGEST +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_transactioneventsdigest(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_TRANSACTIONEVENTSDIGEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_TRANSACTIONEVENTSDIGEST +void uniffi_iota_sdk_ffi_fn_free_transactioneventsdigest(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONEVENTSDIGEST_FROM_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONEVENTSDIGEST_FROM_BASE58 +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_transactioneventsdigest_from_base58(RustBuffer base58, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONEVENTSDIGEST_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONEVENTSDIGEST_FROM_BYTES +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_transactioneventsdigest_from_bytes(RustBuffer bytes, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONEVENTSDIGEST_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONEVENTSDIGEST_GENERATE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_transactioneventsdigest_generate(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSACTIONEVENTSDIGEST_TO_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSACTIONEVENTSDIGEST_TO_BASE58 +RustBuffer uniffi_iota_sdk_ffi_fn_method_transactioneventsdigest_to_base58(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSACTIONEVENTSDIGEST_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSACTIONEVENTSDIGEST_TO_BYTES +RustBuffer uniffi_iota_sdk_ffi_fn_method_transactioneventsdigest_to_bytes(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_TRANSACTIONKIND +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_TRANSACTIONKIND +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_transactionkind(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_TRANSACTIONKIND +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_TRANSACTIONKIND +void uniffi_iota_sdk_ffi_fn_free_transactionkind(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONKIND_AUTHENTICATOR_STATE_UPDATE_V1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONKIND_AUTHENTICATOR_STATE_UPDATE_V1 +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_transactionkind_authenticator_state_update_v1(RustBuffer tx, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONKIND_CONSENSUS_COMMIT_PROLOGUE_V1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONKIND_CONSENSUS_COMMIT_PROLOGUE_V1 +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_transactionkind_consensus_commit_prologue_v1(void*_Nonnull tx, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONKIND_END_OF_EPOCH +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONKIND_END_OF_EPOCH +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_transactionkind_end_of_epoch(RustBuffer tx, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONKIND_GENESIS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONKIND_GENESIS +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_transactionkind_genesis(void*_Nonnull tx, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONKIND_PROGRAMMABLE_TRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONKIND_PROGRAMMABLE_TRANSACTION +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_transactionkind_programmable_transaction(void*_Nonnull tx, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONKIND_RANDOMNESS_STATE_UPDATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSACTIONKIND_RANDOMNESS_STATE_UPDATE +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_transactionkind_randomness_state_update(RustBuffer tx, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_TRANSFEROBJECTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_TRANSFEROBJECTS +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_transferobjects(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_TRANSFEROBJECTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_TRANSFEROBJECTS +void uniffi_iota_sdk_ffi_fn_free_transferobjects(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSFEROBJECTS_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TRANSFEROBJECTS_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_transferobjects_new(RustBuffer objects, void*_Nonnull address, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSFEROBJECTS_ADDRESS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSFEROBJECTS_ADDRESS +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_transferobjects_address(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSFEROBJECTS_OBJECTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TRANSFEROBJECTS_OBJECTS +RustBuffer uniffi_iota_sdk_ffi_fn_method_transferobjects_objects(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_TYPETAG +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_TYPETAG +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_typetag(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_TYPETAG +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_TYPETAG +void uniffi_iota_sdk_ffi_fn_free_typetag(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TYPETAG_ADDRESS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TYPETAG_ADDRESS +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_typetag_address(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TYPETAG_BOOL +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TYPETAG_BOOL +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_typetag_bool(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TYPETAG_SIGNER +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TYPETAG_SIGNER +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_typetag_signer(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TYPETAG_STRUCT_TAG +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TYPETAG_STRUCT_TAG +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_typetag_struct_tag(void*_Nonnull struct_tag, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TYPETAG_U128 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TYPETAG_U128 +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_typetag_u128(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TYPETAG_U16 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TYPETAG_U16 +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_typetag_u16(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TYPETAG_U256 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TYPETAG_U256 +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_typetag_u256(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TYPETAG_U32 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TYPETAG_U32 +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_typetag_u32(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TYPETAG_U64 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TYPETAG_U64 +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_typetag_u64(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TYPETAG_U8 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TYPETAG_U8 +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_typetag_u8(RustCallStatus *_Nonnull out_status + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TYPETAG_VECTOR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_TYPETAG_VECTOR +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_typetag_vector(void*_Nonnull type_tag, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_AS_STRUCT_TAG +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_AS_STRUCT_TAG +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_typetag_as_struct_tag(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_AS_STRUCT_TAG_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_AS_STRUCT_TAG_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_typetag_as_struct_tag_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_AS_VECTOR_TYPE_TAG +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_AS_VECTOR_TYPE_TAG +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_typetag_as_vector_type_tag(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_AS_VECTOR_TYPE_TAG_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_AS_VECTOR_TYPE_TAG_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_typetag_as_vector_type_tag_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_IS_ADDRESS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_IS_ADDRESS +int8_t uniffi_iota_sdk_ffi_fn_method_typetag_is_address(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_IS_BOOL +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_IS_BOOL +int8_t uniffi_iota_sdk_ffi_fn_method_typetag_is_bool(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_IS_SIGNER +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_IS_SIGNER +int8_t uniffi_iota_sdk_ffi_fn_method_typetag_is_signer(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_IS_STRUCT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_IS_STRUCT +int8_t uniffi_iota_sdk_ffi_fn_method_typetag_is_struct(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_IS_U128 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_IS_U128 +int8_t uniffi_iota_sdk_ffi_fn_method_typetag_is_u128(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_IS_U16 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_IS_U16 +int8_t uniffi_iota_sdk_ffi_fn_method_typetag_is_u16(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_IS_U256 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_IS_U256 +int8_t uniffi_iota_sdk_ffi_fn_method_typetag_is_u256(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_IS_U32 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_IS_U32 +int8_t uniffi_iota_sdk_ffi_fn_method_typetag_is_u32(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_IS_U64 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_IS_U64 +int8_t uniffi_iota_sdk_ffi_fn_method_typetag_is_u64(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_IS_U8 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_IS_U8 +int8_t uniffi_iota_sdk_ffi_fn_method_typetag_is_u8(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_IS_VECTOR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_TYPETAG_IS_VECTOR +int8_t uniffi_iota_sdk_ffi_fn_method_typetag_is_vector(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_UPGRADE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_UPGRADE +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_upgrade(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_UPGRADE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_UPGRADE +void uniffi_iota_sdk_ffi_fn_free_upgrade(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_UPGRADE_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_UPGRADE_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_upgrade_new(RustBuffer modules, RustBuffer dependencies, void*_Nonnull package, void*_Nonnull ticket, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_UPGRADE_DEPENDENCIES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_UPGRADE_DEPENDENCIES +RustBuffer uniffi_iota_sdk_ffi_fn_method_upgrade_dependencies(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_UPGRADE_MODULES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_UPGRADE_MODULES +RustBuffer uniffi_iota_sdk_ffi_fn_method_upgrade_modules(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_UPGRADE_PACKAGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_UPGRADE_PACKAGE +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_upgrade_package(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_UPGRADE_TICKET +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_UPGRADE_TICKET +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_upgrade_ticket(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_USERSIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_USERSIGNATURE +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_usersignature(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_USERSIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_USERSIGNATURE +void uniffi_iota_sdk_ffi_fn_free_usersignature(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_USERSIGNATURE_FROM_BASE64 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_USERSIGNATURE_FROM_BASE64 +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_usersignature_from_base64(RustBuffer base64, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_USERSIGNATURE_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_USERSIGNATURE_FROM_BYTES +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_usersignature_from_bytes(RustBuffer bytes, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_AS_MULTISIG +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_AS_MULTISIG +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_usersignature_as_multisig(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_AS_MULTISIG_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_AS_MULTISIG_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_usersignature_as_multisig_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_AS_PASSKEY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_AS_PASSKEY +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_usersignature_as_passkey(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_AS_PASSKEY_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_AS_PASSKEY_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_usersignature_as_passkey_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_AS_SIMPLE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_AS_SIMPLE +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_usersignature_as_simple(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_AS_SIMPLE_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_AS_SIMPLE_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_usersignature_as_simple_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_AS_ZKLOGIN +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_AS_ZKLOGIN +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_usersignature_as_zklogin(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_AS_ZKLOGIN_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_AS_ZKLOGIN_OPT +RustBuffer uniffi_iota_sdk_ffi_fn_method_usersignature_as_zklogin_opt(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_IS_MULTISIG +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_IS_MULTISIG +int8_t uniffi_iota_sdk_ffi_fn_method_usersignature_is_multisig(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_IS_PASSKEY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_IS_PASSKEY +int8_t uniffi_iota_sdk_ffi_fn_method_usersignature_is_passkey(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_IS_SIMPLE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_IS_SIMPLE +int8_t uniffi_iota_sdk_ffi_fn_method_usersignature_is_simple(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_IS_ZKLOGIN +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_IS_ZKLOGIN +int8_t uniffi_iota_sdk_ffi_fn_method_usersignature_is_zklogin(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_SCHEME +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_SCHEME +RustBuffer uniffi_iota_sdk_ffi_fn_method_usersignature_scheme(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_TO_BASE64 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_TO_BASE64 +RustBuffer uniffi_iota_sdk_ffi_fn_method_usersignature_to_base64(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_USERSIGNATURE_TO_BYTES +RustBuffer uniffi_iota_sdk_ffi_fn_method_usersignature_to_bytes(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_VALIDATOREXECUTIONTIMEOBSERVATION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_VALIDATOREXECUTIONTIMEOBSERVATION +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_validatorexecutiontimeobservation(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_VALIDATOREXECUTIONTIMEOBSERVATION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_VALIDATOREXECUTIONTIMEOBSERVATION +void uniffi_iota_sdk_ffi_fn_free_validatorexecutiontimeobservation(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_VALIDATOREXECUTIONTIMEOBSERVATION_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_VALIDATOREXECUTIONTIMEOBSERVATION_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_validatorexecutiontimeobservation_new(void*_Nonnull validator, RustBuffer duration, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_VALIDATOREXECUTIONTIMEOBSERVATION_DURATION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_VALIDATOREXECUTIONTIMEOBSERVATION_DURATION +RustBuffer uniffi_iota_sdk_ffi_fn_method_validatorexecutiontimeobservation_duration(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_VALIDATOREXECUTIONTIMEOBSERVATION_VALIDATOR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_VALIDATOREXECUTIONTIMEOBSERVATION_VALIDATOR +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_validatorexecutiontimeobservation_validator(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_VERSIONASSIGNMENT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_VERSIONASSIGNMENT +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_versionassignment(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_VERSIONASSIGNMENT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_VERSIONASSIGNMENT +void uniffi_iota_sdk_ffi_fn_free_versionassignment(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_VERSIONASSIGNMENT_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_VERSIONASSIGNMENT_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_versionassignment_new(void*_Nonnull object_id, uint64_t version, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_VERSIONASSIGNMENT_OBJECT_ID +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_VERSIONASSIGNMENT_OBJECT_ID +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_versionassignment_object_id(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_VERSIONASSIGNMENT_VERSION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_VERSIONASSIGNMENT_VERSION +uint64_t uniffi_iota_sdk_ffi_fn_method_versionassignment_version(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_ZKLOGINAUTHENTICATOR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_ZKLOGINAUTHENTICATOR +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_zkloginauthenticator(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_ZKLOGINAUTHENTICATOR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_ZKLOGINAUTHENTICATOR +void uniffi_iota_sdk_ffi_fn_free_zkloginauthenticator(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ZKLOGINAUTHENTICATOR_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ZKLOGINAUTHENTICATOR_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_zkloginauthenticator_new(void*_Nonnull inputs, uint64_t max_epoch, void*_Nonnull signature, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ZKLOGINAUTHENTICATOR_INPUTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ZKLOGINAUTHENTICATOR_INPUTS +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_zkloginauthenticator_inputs(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ZKLOGINAUTHENTICATOR_MAX_EPOCH +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ZKLOGINAUTHENTICATOR_MAX_EPOCH +uint64_t uniffi_iota_sdk_ffi_fn_method_zkloginauthenticator_max_epoch(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ZKLOGINAUTHENTICATOR_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ZKLOGINAUTHENTICATOR_SIGNATURE +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_zkloginauthenticator_signature(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_ZKLOGININPUTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_ZKLOGININPUTS +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_zklogininputs(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_ZKLOGININPUTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_ZKLOGININPUTS +void uniffi_iota_sdk_ffi_fn_free_zklogininputs(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ZKLOGININPUTS_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ZKLOGININPUTS_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_zklogininputs_new(void*_Nonnull proof_points, RustBuffer iss_base64_details, RustBuffer header_base64, void*_Nonnull address_seed, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ZKLOGININPUTS_ADDRESS_SEED +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ZKLOGININPUTS_ADDRESS_SEED +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_zklogininputs_address_seed(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ZKLOGININPUTS_HEADER_BASE64 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ZKLOGININPUTS_HEADER_BASE64 +RustBuffer uniffi_iota_sdk_ffi_fn_method_zklogininputs_header_base64(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ZKLOGININPUTS_ISS_BASE64_DETAILS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ZKLOGININPUTS_ISS_BASE64_DETAILS +RustBuffer uniffi_iota_sdk_ffi_fn_method_zklogininputs_iss_base64_details(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ZKLOGININPUTS_PROOF_POINTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ZKLOGININPUTS_PROOF_POINTS +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_zklogininputs_proof_points(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_ZKLOGINPROOF +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_ZKLOGINPROOF +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_zkloginproof(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_ZKLOGINPROOF +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_ZKLOGINPROOF +void uniffi_iota_sdk_ffi_fn_free_zkloginproof(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ZKLOGINPROOF_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ZKLOGINPROOF_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_zkloginproof_new(void*_Nonnull a, void*_Nonnull b, void*_Nonnull c, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ZKLOGINPROOF_A +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ZKLOGINPROOF_A +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_zkloginproof_a(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ZKLOGINPROOF_B +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ZKLOGINPROOF_B +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_zkloginproof_b(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ZKLOGINPROOF_C +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ZKLOGINPROOF_C +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_zkloginproof_c(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_ZKLOGINPUBLICIDENTIFIER +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CLONE_ZKLOGINPUBLICIDENTIFIER +void*_Nonnull uniffi_iota_sdk_ffi_fn_clone_zkloginpublicidentifier(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_ZKLOGINPUBLICIDENTIFIER +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_FREE_ZKLOGINPUBLICIDENTIFIER +void uniffi_iota_sdk_ffi_fn_free_zkloginpublicidentifier(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ZKLOGINPUBLICIDENTIFIER_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_CONSTRUCTOR_ZKLOGINPUBLICIDENTIFIER_NEW +void*_Nonnull uniffi_iota_sdk_ffi_fn_constructor_zkloginpublicidentifier_new(RustBuffer iss, void*_Nonnull address_seed, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ZKLOGINPUBLICIDENTIFIER_ADDRESS_SEED +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ZKLOGINPUBLICIDENTIFIER_ADDRESS_SEED +void*_Nonnull uniffi_iota_sdk_ffi_fn_method_zkloginpublicidentifier_address_seed(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ZKLOGINPUBLICIDENTIFIER_ISS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_FN_METHOD_ZKLOGINPUBLICIDENTIFIER_ISS +RustBuffer uniffi_iota_sdk_ffi_fn_method_zkloginpublicidentifier_iss(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUSTBUFFER_ALLOC +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUSTBUFFER_ALLOC +RustBuffer ffi_iota_sdk_ffi_rustbuffer_alloc(uint64_t size, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUSTBUFFER_FROM_BYTES +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUSTBUFFER_FROM_BYTES +RustBuffer ffi_iota_sdk_ffi_rustbuffer_from_bytes(ForeignBytes bytes, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUSTBUFFER_FREE +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUSTBUFFER_FREE +void ffi_iota_sdk_ffi_rustbuffer_free(RustBuffer buf, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUSTBUFFER_RESERVE +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUSTBUFFER_RESERVE +RustBuffer ffi_iota_sdk_ffi_rustbuffer_reserve(RustBuffer buf, uint64_t additional, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_POLL_U8 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_POLL_U8 +void ffi_iota_sdk_ffi_rust_future_poll_u8(uint64_t handle, UniffiRustFutureContinuationCallback _Nonnull callback, uint64_t callback_data +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_CANCEL_U8 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_CANCEL_U8 +void ffi_iota_sdk_ffi_rust_future_cancel_u8(uint64_t handle +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_FREE_U8 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_FREE_U8 +void ffi_iota_sdk_ffi_rust_future_free_u8(uint64_t handle +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_COMPLETE_U8 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_COMPLETE_U8 +uint8_t ffi_iota_sdk_ffi_rust_future_complete_u8(uint64_t handle, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_POLL_I8 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_POLL_I8 +void ffi_iota_sdk_ffi_rust_future_poll_i8(uint64_t handle, UniffiRustFutureContinuationCallback _Nonnull callback, uint64_t callback_data +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_CANCEL_I8 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_CANCEL_I8 +void ffi_iota_sdk_ffi_rust_future_cancel_i8(uint64_t handle +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_FREE_I8 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_FREE_I8 +void ffi_iota_sdk_ffi_rust_future_free_i8(uint64_t handle +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_COMPLETE_I8 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_COMPLETE_I8 +int8_t ffi_iota_sdk_ffi_rust_future_complete_i8(uint64_t handle, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_POLL_U16 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_POLL_U16 +void ffi_iota_sdk_ffi_rust_future_poll_u16(uint64_t handle, UniffiRustFutureContinuationCallback _Nonnull callback, uint64_t callback_data +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_CANCEL_U16 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_CANCEL_U16 +void ffi_iota_sdk_ffi_rust_future_cancel_u16(uint64_t handle +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_FREE_U16 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_FREE_U16 +void ffi_iota_sdk_ffi_rust_future_free_u16(uint64_t handle +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_COMPLETE_U16 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_COMPLETE_U16 +uint16_t ffi_iota_sdk_ffi_rust_future_complete_u16(uint64_t handle, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_POLL_I16 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_POLL_I16 +void ffi_iota_sdk_ffi_rust_future_poll_i16(uint64_t handle, UniffiRustFutureContinuationCallback _Nonnull callback, uint64_t callback_data +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_CANCEL_I16 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_CANCEL_I16 +void ffi_iota_sdk_ffi_rust_future_cancel_i16(uint64_t handle +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_FREE_I16 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_FREE_I16 +void ffi_iota_sdk_ffi_rust_future_free_i16(uint64_t handle +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_COMPLETE_I16 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_COMPLETE_I16 +int16_t ffi_iota_sdk_ffi_rust_future_complete_i16(uint64_t handle, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_POLL_U32 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_POLL_U32 +void ffi_iota_sdk_ffi_rust_future_poll_u32(uint64_t handle, UniffiRustFutureContinuationCallback _Nonnull callback, uint64_t callback_data +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_CANCEL_U32 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_CANCEL_U32 +void ffi_iota_sdk_ffi_rust_future_cancel_u32(uint64_t handle +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_FREE_U32 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_FREE_U32 +void ffi_iota_sdk_ffi_rust_future_free_u32(uint64_t handle +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_COMPLETE_U32 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_COMPLETE_U32 +uint32_t ffi_iota_sdk_ffi_rust_future_complete_u32(uint64_t handle, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_POLL_I32 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_POLL_I32 +void ffi_iota_sdk_ffi_rust_future_poll_i32(uint64_t handle, UniffiRustFutureContinuationCallback _Nonnull callback, uint64_t callback_data +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_CANCEL_I32 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_CANCEL_I32 +void ffi_iota_sdk_ffi_rust_future_cancel_i32(uint64_t handle +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_FREE_I32 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_FREE_I32 +void ffi_iota_sdk_ffi_rust_future_free_i32(uint64_t handle +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_COMPLETE_I32 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_COMPLETE_I32 +int32_t ffi_iota_sdk_ffi_rust_future_complete_i32(uint64_t handle, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_POLL_U64 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_POLL_U64 +void ffi_iota_sdk_ffi_rust_future_poll_u64(uint64_t handle, UniffiRustFutureContinuationCallback _Nonnull callback, uint64_t callback_data +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_CANCEL_U64 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_CANCEL_U64 +void ffi_iota_sdk_ffi_rust_future_cancel_u64(uint64_t handle +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_FREE_U64 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_FREE_U64 +void ffi_iota_sdk_ffi_rust_future_free_u64(uint64_t handle +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_COMPLETE_U64 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_COMPLETE_U64 +uint64_t ffi_iota_sdk_ffi_rust_future_complete_u64(uint64_t handle, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_POLL_I64 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_POLL_I64 +void ffi_iota_sdk_ffi_rust_future_poll_i64(uint64_t handle, UniffiRustFutureContinuationCallback _Nonnull callback, uint64_t callback_data +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_CANCEL_I64 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_CANCEL_I64 +void ffi_iota_sdk_ffi_rust_future_cancel_i64(uint64_t handle +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_FREE_I64 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_FREE_I64 +void ffi_iota_sdk_ffi_rust_future_free_i64(uint64_t handle +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_COMPLETE_I64 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_COMPLETE_I64 +int64_t ffi_iota_sdk_ffi_rust_future_complete_i64(uint64_t handle, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_POLL_F32 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_POLL_F32 +void ffi_iota_sdk_ffi_rust_future_poll_f32(uint64_t handle, UniffiRustFutureContinuationCallback _Nonnull callback, uint64_t callback_data +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_CANCEL_F32 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_CANCEL_F32 +void ffi_iota_sdk_ffi_rust_future_cancel_f32(uint64_t handle +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_FREE_F32 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_FREE_F32 +void ffi_iota_sdk_ffi_rust_future_free_f32(uint64_t handle +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_COMPLETE_F32 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_COMPLETE_F32 +float ffi_iota_sdk_ffi_rust_future_complete_f32(uint64_t handle, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_POLL_F64 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_POLL_F64 +void ffi_iota_sdk_ffi_rust_future_poll_f64(uint64_t handle, UniffiRustFutureContinuationCallback _Nonnull callback, uint64_t callback_data +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_CANCEL_F64 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_CANCEL_F64 +void ffi_iota_sdk_ffi_rust_future_cancel_f64(uint64_t handle +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_FREE_F64 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_FREE_F64 +void ffi_iota_sdk_ffi_rust_future_free_f64(uint64_t handle +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_COMPLETE_F64 +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_COMPLETE_F64 +double ffi_iota_sdk_ffi_rust_future_complete_f64(uint64_t handle, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_POLL_POINTER +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_POLL_POINTER +void ffi_iota_sdk_ffi_rust_future_poll_pointer(uint64_t handle, UniffiRustFutureContinuationCallback _Nonnull callback, uint64_t callback_data +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_CANCEL_POINTER +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_CANCEL_POINTER +void ffi_iota_sdk_ffi_rust_future_cancel_pointer(uint64_t handle +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_FREE_POINTER +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_FREE_POINTER +void ffi_iota_sdk_ffi_rust_future_free_pointer(uint64_t handle +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_COMPLETE_POINTER +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_COMPLETE_POINTER +void*_Nonnull ffi_iota_sdk_ffi_rust_future_complete_pointer(uint64_t handle, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_POLL_RUST_BUFFER +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_POLL_RUST_BUFFER +void ffi_iota_sdk_ffi_rust_future_poll_rust_buffer(uint64_t handle, UniffiRustFutureContinuationCallback _Nonnull callback, uint64_t callback_data +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_CANCEL_RUST_BUFFER +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_CANCEL_RUST_BUFFER +void ffi_iota_sdk_ffi_rust_future_cancel_rust_buffer(uint64_t handle +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_FREE_RUST_BUFFER +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_FREE_RUST_BUFFER +void ffi_iota_sdk_ffi_rust_future_free_rust_buffer(uint64_t handle +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_COMPLETE_RUST_BUFFER +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_COMPLETE_RUST_BUFFER +RustBuffer ffi_iota_sdk_ffi_rust_future_complete_rust_buffer(uint64_t handle, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_POLL_VOID +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_POLL_VOID +void ffi_iota_sdk_ffi_rust_future_poll_void(uint64_t handle, UniffiRustFutureContinuationCallback _Nonnull callback, uint64_t callback_data +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_CANCEL_VOID +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_CANCEL_VOID +void ffi_iota_sdk_ffi_rust_future_cancel_void(uint64_t handle +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_FREE_VOID +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_FREE_VOID +void ffi_iota_sdk_ffi_rust_future_free_void(uint64_t handle +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_COMPLETE_VOID +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_RUST_FUTURE_COMPLETE_VOID +void ffi_iota_sdk_ffi_rust_future_complete_void(uint64_t handle, RustCallStatus *_Nonnull out_status +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ADDRESS_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ADDRESS_TO_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_method_address_to_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ADDRESS_TO_HEX +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ADDRESS_TO_HEX +uint16_t uniffi_iota_sdk_ffi_checksum_method_address_to_hex(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ARGUMENT_NESTED +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ARGUMENT_NESTED +uint16_t uniffi_iota_sdk_ffi_checksum_method_argument_nested(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_BLS12381PUBLICKEY_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_BLS12381PUBLICKEY_TO_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_method_bls12381publickey_to_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_BLS12381SIGNATURE_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_BLS12381SIGNATURE_TO_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_method_bls12381signature_to_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_BN254FIELDELEMENT_PADDED +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_BN254FIELDELEMENT_PADDED +uint16_t uniffi_iota_sdk_ffi_checksum_method_bn254fieldelement_padded(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_BN254FIELDELEMENT_UNPADDED +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_BN254FIELDELEMENT_UNPADDED +uint16_t uniffi_iota_sdk_ffi_checksum_method_bn254fieldelement_unpadded(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CANCELLEDTRANSACTION_DIGEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CANCELLEDTRANSACTION_DIGEST +uint16_t uniffi_iota_sdk_ffi_checksum_method_cancelledtransaction_digest(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CANCELLEDTRANSACTION_VERSION_ASSIGNMENTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CANCELLEDTRANSACTION_VERSION_ASSIGNMENTS +uint16_t uniffi_iota_sdk_ffi_checksum_method_cancelledtransaction_version_assignments(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCH_COMPUTATION_CHARGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCH_COMPUTATION_CHARGE +uint16_t uniffi_iota_sdk_ffi_checksum_method_changeepoch_computation_charge(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCH_EPOCH +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCH_EPOCH +uint16_t uniffi_iota_sdk_ffi_checksum_method_changeepoch_epoch(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCH_EPOCH_START_TIMESTAMP_MS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCH_EPOCH_START_TIMESTAMP_MS +uint16_t uniffi_iota_sdk_ffi_checksum_method_changeepoch_epoch_start_timestamp_ms(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCH_NON_REFUNDABLE_STORAGE_FEE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCH_NON_REFUNDABLE_STORAGE_FEE +uint16_t uniffi_iota_sdk_ffi_checksum_method_changeepoch_non_refundable_storage_fee(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCH_PROTOCOL_VERSION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCH_PROTOCOL_VERSION +uint16_t uniffi_iota_sdk_ffi_checksum_method_changeepoch_protocol_version(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCH_STORAGE_CHARGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCH_STORAGE_CHARGE +uint16_t uniffi_iota_sdk_ffi_checksum_method_changeepoch_storage_charge(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCH_STORAGE_REBATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCH_STORAGE_REBATE +uint16_t uniffi_iota_sdk_ffi_checksum_method_changeepoch_storage_rebate(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCH_SYSTEM_PACKAGES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCH_SYSTEM_PACKAGES +uint16_t uniffi_iota_sdk_ffi_checksum_method_changeepoch_system_packages(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCHV2_COMPUTATION_CHARGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCHV2_COMPUTATION_CHARGE +uint16_t uniffi_iota_sdk_ffi_checksum_method_changeepochv2_computation_charge(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCHV2_COMPUTATION_CHARGE_BURNED +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCHV2_COMPUTATION_CHARGE_BURNED +uint16_t uniffi_iota_sdk_ffi_checksum_method_changeepochv2_computation_charge_burned(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCHV2_EPOCH +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCHV2_EPOCH +uint16_t uniffi_iota_sdk_ffi_checksum_method_changeepochv2_epoch(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCHV2_EPOCH_START_TIMESTAMP_MS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCHV2_EPOCH_START_TIMESTAMP_MS +uint16_t uniffi_iota_sdk_ffi_checksum_method_changeepochv2_epoch_start_timestamp_ms(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCHV2_NON_REFUNDABLE_STORAGE_FEE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCHV2_NON_REFUNDABLE_STORAGE_FEE +uint16_t uniffi_iota_sdk_ffi_checksum_method_changeepochv2_non_refundable_storage_fee(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCHV2_PROTOCOL_VERSION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCHV2_PROTOCOL_VERSION +uint16_t uniffi_iota_sdk_ffi_checksum_method_changeepochv2_protocol_version(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCHV2_STORAGE_CHARGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCHV2_STORAGE_CHARGE +uint16_t uniffi_iota_sdk_ffi_checksum_method_changeepochv2_storage_charge(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCHV2_STORAGE_REBATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCHV2_STORAGE_REBATE +uint16_t uniffi_iota_sdk_ffi_checksum_method_changeepochv2_storage_rebate(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCHV2_SYSTEM_PACKAGES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHANGEEPOCHV2_SYSTEM_PACKAGES +uint16_t uniffi_iota_sdk_ffi_checksum_method_changeepochv2_system_packages(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHECKPOINTCOMMITMENT_AS_ECMH_LIVE_OBJECT_SET_DIGEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHECKPOINTCOMMITMENT_AS_ECMH_LIVE_OBJECT_SET_DIGEST +uint16_t uniffi_iota_sdk_ffi_checksum_method_checkpointcommitment_as_ecmh_live_object_set_digest(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHECKPOINTCOMMITMENT_IS_ECMH_LIVE_OBJECT_SET +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHECKPOINTCOMMITMENT_IS_ECMH_LIVE_OBJECT_SET +uint16_t uniffi_iota_sdk_ffi_checksum_method_checkpointcommitment_is_ecmh_live_object_set(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHECKPOINTCONTENTSDIGEST_TO_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHECKPOINTCONTENTSDIGEST_TO_BASE58 +uint16_t uniffi_iota_sdk_ffi_checksum_method_checkpointcontentsdigest_to_base58(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHECKPOINTCONTENTSDIGEST_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHECKPOINTCONTENTSDIGEST_TO_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_method_checkpointcontentsdigest_to_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHECKPOINTDIGEST_TO_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHECKPOINTDIGEST_TO_BASE58 +uint16_t uniffi_iota_sdk_ffi_checksum_method_checkpointdigest_to_base58(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHECKPOINTDIGEST_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CHECKPOINTDIGEST_TO_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_method_checkpointdigest_to_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_COIN_BALANCE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_COIN_BALANCE +uint16_t uniffi_iota_sdk_ffi_checksum_method_coin_balance(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_COIN_COIN_TYPE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_COIN_COIN_TYPE +uint16_t uniffi_iota_sdk_ffi_checksum_method_coin_coin_type(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_COIN_ID +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_COIN_ID +uint16_t uniffi_iota_sdk_ffi_checksum_method_coin_id(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CONSENSUSCOMMITDIGEST_TO_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CONSENSUSCOMMITDIGEST_TO_BASE58 +uint16_t uniffi_iota_sdk_ffi_checksum_method_consensuscommitdigest_to_base58(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CONSENSUSCOMMITDIGEST_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CONSENSUSCOMMITDIGEST_TO_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_method_consensuscommitdigest_to_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CONSENSUSCOMMITPROLOGUEV1_COMMIT_TIMESTAMP_MS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CONSENSUSCOMMITPROLOGUEV1_COMMIT_TIMESTAMP_MS +uint16_t uniffi_iota_sdk_ffi_checksum_method_consensuscommitprologuev1_commit_timestamp_ms(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CONSENSUSCOMMITPROLOGUEV1_CONSENSUS_COMMIT_DIGEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CONSENSUSCOMMITPROLOGUEV1_CONSENSUS_COMMIT_DIGEST +uint16_t uniffi_iota_sdk_ffi_checksum_method_consensuscommitprologuev1_consensus_commit_digest(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CONSENSUSCOMMITPROLOGUEV1_CONSENSUS_DETERMINED_VERSION_ASSIGNMENTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CONSENSUSCOMMITPROLOGUEV1_CONSENSUS_DETERMINED_VERSION_ASSIGNMENTS +uint16_t uniffi_iota_sdk_ffi_checksum_method_consensuscommitprologuev1_consensus_determined_version_assignments(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CONSENSUSCOMMITPROLOGUEV1_EPOCH +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CONSENSUSCOMMITPROLOGUEV1_EPOCH +uint16_t uniffi_iota_sdk_ffi_checksum_method_consensuscommitprologuev1_epoch(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CONSENSUSCOMMITPROLOGUEV1_ROUND +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CONSENSUSCOMMITPROLOGUEV1_ROUND +uint16_t uniffi_iota_sdk_ffi_checksum_method_consensuscommitprologuev1_round(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CONSENSUSCOMMITPROLOGUEV1_SUB_DAG_INDEX +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CONSENSUSCOMMITPROLOGUEV1_SUB_DAG_INDEX +uint16_t uniffi_iota_sdk_ffi_checksum_method_consensuscommitprologuev1_sub_dag_index(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CONSENSUSDETERMINEDVERSIONASSIGNMENTS_AS_CANCELLED_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CONSENSUSDETERMINEDVERSIONASSIGNMENTS_AS_CANCELLED_TRANSACTIONS +uint16_t uniffi_iota_sdk_ffi_checksum_method_consensusdeterminedversionassignments_as_cancelled_transactions(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CONSENSUSDETERMINEDVERSIONASSIGNMENTS_AS_CANCELLED_TRANSACTIONS_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CONSENSUSDETERMINEDVERSIONASSIGNMENTS_AS_CANCELLED_TRANSACTIONS_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_consensusdeterminedversionassignments_as_cancelled_transactions_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CONSENSUSDETERMINEDVERSIONASSIGNMENTS_IS_CANCELLED_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_CONSENSUSDETERMINEDVERSIONASSIGNMENTS_IS_CANCELLED_TRANSACTIONS +uint16_t uniffi_iota_sdk_ffi_checksum_method_consensusdeterminedversionassignments_is_cancelled_transactions(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_DIGEST_TO_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_DIGEST_TO_BASE58 +uint16_t uniffi_iota_sdk_ffi_checksum_method_digest_to_base58(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_DIGEST_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_DIGEST_TO_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_method_digest_to_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ED25519PUBLICKEY_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ED25519PUBLICKEY_TO_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_method_ed25519publickey_to_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ED25519SIGNATURE_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ED25519SIGNATURE_TO_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_method_ed25519signature_to_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_EFFECTSAUXILIARYDATADIGEST_TO_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_EFFECTSAUXILIARYDATADIGEST_TO_BASE58 +uint16_t uniffi_iota_sdk_ffi_checksum_method_effectsauxiliarydatadigest_to_base58(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_EFFECTSAUXILIARYDATADIGEST_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_EFFECTSAUXILIARYDATADIGEST_TO_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_method_effectsauxiliarydatadigest_to_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_EXECUTIONTIMEOBSERVATION_KEY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_EXECUTIONTIMEOBSERVATION_KEY +uint16_t uniffi_iota_sdk_ffi_checksum_method_executiontimeobservation_key(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_EXECUTIONTIMEOBSERVATION_OBSERVATIONS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_EXECUTIONTIMEOBSERVATION_OBSERVATIONS +uint16_t uniffi_iota_sdk_ffi_checksum_method_executiontimeobservation_observations(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_FAUCETCLIENT_REQUEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_FAUCETCLIENT_REQUEST +uint16_t uniffi_iota_sdk_ffi_checksum_method_faucetclient_request(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_FAUCETCLIENT_REQUEST_AND_WAIT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_FAUCETCLIENT_REQUEST_AND_WAIT +uint16_t uniffi_iota_sdk_ffi_checksum_method_faucetclient_request_and_wait(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_FAUCETCLIENT_REQUEST_STATUS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_FAUCETCLIENT_REQUEST_STATUS +uint16_t uniffi_iota_sdk_ffi_checksum_method_faucetclient_request_status(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GENESISOBJECT_DATA +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GENESISOBJECT_DATA +uint16_t uniffi_iota_sdk_ffi_checksum_method_genesisobject_data(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GENESISOBJECT_OBJECT_ID +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GENESISOBJECT_OBJECT_ID +uint16_t uniffi_iota_sdk_ffi_checksum_method_genesisobject_object_id(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GENESISOBJECT_OBJECT_TYPE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GENESISOBJECT_OBJECT_TYPE +uint16_t uniffi_iota_sdk_ffi_checksum_method_genesisobject_object_type(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GENESISOBJECT_OWNER +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GENESISOBJECT_OWNER +uint16_t uniffi_iota_sdk_ffi_checksum_method_genesisobject_owner(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GENESISOBJECT_VERSION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GENESISOBJECT_VERSION +uint16_t uniffi_iota_sdk_ffi_checksum_method_genesisobject_version(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GENESISTRANSACTION_EVENTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GENESISTRANSACTION_EVENTS +uint16_t uniffi_iota_sdk_ffi_checksum_method_genesistransaction_events(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GENESISTRANSACTION_OBJECTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GENESISTRANSACTION_OBJECTS +uint16_t uniffi_iota_sdk_ffi_checksum_method_genesistransaction_objects(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_ACTIVE_VALIDATORS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_ACTIVE_VALIDATORS +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_active_validators(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_BALANCE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_BALANCE +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_balance(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_CHAIN_ID +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_CHAIN_ID +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_chain_id(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_CHECKPOINT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_CHECKPOINT +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_checkpoint(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_CHECKPOINTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_CHECKPOINTS +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_checkpoints(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_COIN_METADATA +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_COIN_METADATA +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_coin_metadata(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_COINS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_COINS +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_coins(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_DRY_RUN_TX +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_DRY_RUN_TX +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_dry_run_tx(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_DRY_RUN_TX_KIND +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_DRY_RUN_TX_KIND +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_dry_run_tx_kind(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_DYNAMIC_FIELD +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_DYNAMIC_FIELD +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_dynamic_field(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_DYNAMIC_FIELDS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_DYNAMIC_FIELDS +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_dynamic_fields(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_DYNAMIC_OBJECT_FIELD +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_DYNAMIC_OBJECT_FIELD +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_dynamic_object_field(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_EPOCH +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_EPOCH +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_epoch(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_EPOCH_TOTAL_CHECKPOINTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_EPOCH_TOTAL_CHECKPOINTS +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_epoch_total_checkpoints(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_EPOCH_TOTAL_TRANSACTION_BLOCKS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_EPOCH_TOTAL_TRANSACTION_BLOCKS +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_epoch_total_transaction_blocks(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_EVENTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_EVENTS +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_events(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_EXECUTE_TX +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_EXECUTE_TX +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_execute_tx(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_LATEST_CHECKPOINT_SEQUENCE_NUMBER +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_LATEST_CHECKPOINT_SEQUENCE_NUMBER +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_latest_checkpoint_sequence_number(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_MAX_PAGE_SIZE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_MAX_PAGE_SIZE +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_max_page_size(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_MOVE_OBJECT_CONTENTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_MOVE_OBJECT_CONTENTS +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_move_object_contents(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_MOVE_OBJECT_CONTENTS_BCS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_MOVE_OBJECT_CONTENTS_BCS +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_move_object_contents_bcs(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_NORMALIZED_MOVE_FUNCTION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_NORMALIZED_MOVE_FUNCTION +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_normalized_move_function(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_NORMALIZED_MOVE_MODULE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_NORMALIZED_MOVE_MODULE +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_normalized_move_module(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_OBJECT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_OBJECT +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_object(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_OBJECT_BCS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_OBJECT_BCS +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_object_bcs(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_OBJECTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_OBJECTS +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_objects(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_PACKAGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_PACKAGE +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_package(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_PACKAGE_LATEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_PACKAGE_LATEST +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_package_latest(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_PACKAGE_VERSIONS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_PACKAGE_VERSIONS +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_package_versions(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_PACKAGES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_PACKAGES +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_packages(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_PROTOCOL_CONFIG +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_PROTOCOL_CONFIG +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_protocol_config(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_REFERENCE_GAS_PRICE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_REFERENCE_GAS_PRICE +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_reference_gas_price(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_SERVICE_CONFIG +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_SERVICE_CONFIG +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_service_config(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_SET_RPC_SERVER +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_SET_RPC_SERVER +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_set_rpc_server(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_TOTAL_SUPPLY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_TOTAL_SUPPLY +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_total_supply(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_TOTAL_TRANSACTION_BLOCKS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_TOTAL_TRANSACTION_BLOCKS +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_total_transaction_blocks(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_TOTAL_TRANSACTION_BLOCKS_BY_DIGEST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_TOTAL_TRANSACTION_BLOCKS_BY_DIGEST +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_total_transaction_blocks_by_digest(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_TOTAL_TRANSACTION_BLOCKS_BY_SEQ_NUM +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_TOTAL_TRANSACTION_BLOCKS_BY_SEQ_NUM +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_total_transaction_blocks_by_seq_num(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_TRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_TRANSACTION +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_transaction(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_TRANSACTION_DATA_EFFECTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_TRANSACTION_DATA_EFFECTS +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_transaction_data_effects(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_TRANSACTION_EFFECTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_TRANSACTION_EFFECTS +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_transaction_effects(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_TRANSACTIONS +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_transactions(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_TRANSACTIONS_DATA_EFFECTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_TRANSACTIONS_DATA_EFFECTS +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_transactions_data_effects(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_TRANSACTIONS_EFFECTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_GRAPHQLCLIENT_TRANSACTIONS_EFFECTS +uint16_t uniffi_iota_sdk_ffi_checksum_method_graphqlclient_transactions_effects(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_IDENTIFIER_AS_STR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_IDENTIFIER_AS_STR +uint16_t uniffi_iota_sdk_ffi_checksum_method_identifier_as_str(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MAKEMOVEVECTOR_ELEMENTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MAKEMOVEVECTOR_ELEMENTS +uint16_t uniffi_iota_sdk_ffi_checksum_method_makemovevector_elements(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MAKEMOVEVECTOR_TYPE_TAG +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MAKEMOVEVECTOR_TYPE_TAG +uint16_t uniffi_iota_sdk_ffi_checksum_method_makemovevector_type_tag(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MERGECOINS_COIN +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MERGECOINS_COIN +uint16_t uniffi_iota_sdk_ffi_checksum_method_mergecoins_coin(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MERGECOINS_COINS_TO_MERGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MERGECOINS_COINS_TO_MERGE +uint16_t uniffi_iota_sdk_ffi_checksum_method_mergecoins_coins_to_merge(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MOVECALL_ARGUMENTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MOVECALL_ARGUMENTS +uint16_t uniffi_iota_sdk_ffi_checksum_method_movecall_arguments(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MOVECALL_FUNCTION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MOVECALL_FUNCTION +uint16_t uniffi_iota_sdk_ffi_checksum_method_movecall_function(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MOVECALL_MODULE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MOVECALL_MODULE +uint16_t uniffi_iota_sdk_ffi_checksum_method_movecall_module(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MOVECALL_PACKAGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MOVECALL_PACKAGE +uint16_t uniffi_iota_sdk_ffi_checksum_method_movecall_package(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MOVECALL_TYPE_ARGUMENTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MOVECALL_TYPE_ARGUMENTS +uint16_t uniffi_iota_sdk_ffi_checksum_method_movecall_type_arguments(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGAGGREGATEDSIGNATURE_BITMAP +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGAGGREGATEDSIGNATURE_BITMAP +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigaggregatedsignature_bitmap(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGAGGREGATEDSIGNATURE_COMMITTEE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGAGGREGATEDSIGNATURE_COMMITTEE +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigaggregatedsignature_committee(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGAGGREGATEDSIGNATURE_SIGNATURES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGAGGREGATEDSIGNATURE_SIGNATURES +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigaggregatedsignature_signatures(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGCOMMITTEE_IS_VALID +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGCOMMITTEE_IS_VALID +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigcommittee_is_valid(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGCOMMITTEE_MEMBERS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGCOMMITTEE_MEMBERS +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigcommittee_members(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGCOMMITTEE_SCHEME +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGCOMMITTEE_SCHEME +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigcommittee_scheme(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGCOMMITTEE_THRESHOLD +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGCOMMITTEE_THRESHOLD +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigcommittee_threshold(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBER_PUBLIC_KEY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBER_PUBLIC_KEY +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigmember_public_key(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBER_WEIGHT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBER_WEIGHT +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigmember_weight(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERPUBLICKEY_AS_ED25519 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERPUBLICKEY_AS_ED25519 +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_ed25519(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERPUBLICKEY_AS_ED25519_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERPUBLICKEY_AS_ED25519_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_ed25519_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERPUBLICKEY_AS_SECP256K1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERPUBLICKEY_AS_SECP256K1 +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_secp256k1(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERPUBLICKEY_AS_SECP256K1_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERPUBLICKEY_AS_SECP256K1_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_secp256k1_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERPUBLICKEY_AS_SECP256R1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERPUBLICKEY_AS_SECP256R1 +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_secp256r1(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERPUBLICKEY_AS_SECP256R1_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERPUBLICKEY_AS_SECP256R1_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_secp256r1_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERPUBLICKEY_AS_ZKLOGIN +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERPUBLICKEY_AS_ZKLOGIN +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_zklogin(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERPUBLICKEY_AS_ZKLOGIN_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERPUBLICKEY_AS_ZKLOGIN_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_as_zklogin_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERPUBLICKEY_IS_ED25519 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERPUBLICKEY_IS_ED25519 +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_is_ed25519(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERPUBLICKEY_IS_SECP256K1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERPUBLICKEY_IS_SECP256K1 +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_is_secp256k1(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERPUBLICKEY_IS_SECP256R1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERPUBLICKEY_IS_SECP256R1 +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_is_secp256r1(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERPUBLICKEY_IS_ZKLOGIN +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERPUBLICKEY_IS_ZKLOGIN +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigmemberpublickey_is_zklogin(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERSIGNATURE_AS_ED25519 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERSIGNATURE_AS_ED25519 +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_ed25519(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERSIGNATURE_AS_ED25519_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERSIGNATURE_AS_ED25519_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_ed25519_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERSIGNATURE_AS_SECP256K1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERSIGNATURE_AS_SECP256K1 +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_secp256k1(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERSIGNATURE_AS_SECP256K1_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERSIGNATURE_AS_SECP256K1_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_secp256k1_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERSIGNATURE_AS_SECP256R1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERSIGNATURE_AS_SECP256R1 +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_secp256r1(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERSIGNATURE_AS_SECP256R1_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERSIGNATURE_AS_SECP256R1_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_secp256r1_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERSIGNATURE_AS_ZKLOGIN +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERSIGNATURE_AS_ZKLOGIN +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_zklogin(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERSIGNATURE_AS_ZKLOGIN_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERSIGNATURE_AS_ZKLOGIN_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_as_zklogin_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERSIGNATURE_IS_ED25519 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERSIGNATURE_IS_ED25519 +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_is_ed25519(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERSIGNATURE_IS_SECP256K1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERSIGNATURE_IS_SECP256K1 +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_is_secp256k1(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERSIGNATURE_IS_SECP256R1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERSIGNATURE_IS_SECP256R1 +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_is_secp256r1(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERSIGNATURE_IS_ZKLOGIN +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_MULTISIGMEMBERSIGNATURE_IS_ZKLOGIN +uint16_t uniffi_iota_sdk_ffi_checksum_method_multisigmembersignature_is_zklogin(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECT_AS_STRUCT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECT_AS_STRUCT +uint16_t uniffi_iota_sdk_ffi_checksum_method_object_as_struct(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECT_DATA +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECT_DATA +uint16_t uniffi_iota_sdk_ffi_checksum_method_object_data(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECT_OBJECT_ID +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECT_OBJECT_ID +uint16_t uniffi_iota_sdk_ffi_checksum_method_object_object_id(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECT_OBJECT_TYPE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECT_OBJECT_TYPE +uint16_t uniffi_iota_sdk_ffi_checksum_method_object_object_type(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECT_OWNER +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECT_OWNER +uint16_t uniffi_iota_sdk_ffi_checksum_method_object_owner(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECT_PREVIOUS_TRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECT_PREVIOUS_TRANSACTION +uint16_t uniffi_iota_sdk_ffi_checksum_method_object_previous_transaction(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECT_STORAGE_REBATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECT_STORAGE_REBATE +uint16_t uniffi_iota_sdk_ffi_checksum_method_object_storage_rebate(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECT_VERSION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECT_VERSION +uint16_t uniffi_iota_sdk_ffi_checksum_method_object_version(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECTDATA_AS_PACKAGE_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECTDATA_AS_PACKAGE_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_objectdata_as_package_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECTDATA_AS_STRUCT_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECTDATA_AS_STRUCT_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_objectdata_as_struct_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECTDATA_IS_PACKAGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECTDATA_IS_PACKAGE +uint16_t uniffi_iota_sdk_ffi_checksum_method_objectdata_is_package(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECTDATA_IS_STRUCT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECTDATA_IS_STRUCT +uint16_t uniffi_iota_sdk_ffi_checksum_method_objectdata_is_struct(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECTDIGEST_TO_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECTDIGEST_TO_BASE58 +uint16_t uniffi_iota_sdk_ffi_checksum_method_objectdigest_to_base58(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECTDIGEST_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECTDIGEST_TO_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_method_objectdigest_to_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECTID_TO_ADDRESS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECTID_TO_ADDRESS +uint16_t uniffi_iota_sdk_ffi_checksum_method_objectid_to_address(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECTID_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECTID_TO_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_method_objectid_to_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECTID_TO_HEX +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECTID_TO_HEX +uint16_t uniffi_iota_sdk_ffi_checksum_method_objectid_to_hex(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECTTYPE_AS_STRUCT_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECTTYPE_AS_STRUCT_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_objecttype_as_struct_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECTTYPE_IS_PACKAGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECTTYPE_IS_PACKAGE +uint16_t uniffi_iota_sdk_ffi_checksum_method_objecttype_is_package(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECTTYPE_IS_STRUCT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OBJECTTYPE_IS_STRUCT +uint16_t uniffi_iota_sdk_ffi_checksum_method_objecttype_is_struct(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OWNER_AS_ADDRESS_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OWNER_AS_ADDRESS_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_owner_as_address_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OWNER_AS_OBJECT_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OWNER_AS_OBJECT_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_owner_as_object_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OWNER_AS_SHARED_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OWNER_AS_SHARED_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_owner_as_shared_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OWNER_IS_ADDRESS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OWNER_IS_ADDRESS +uint16_t uniffi_iota_sdk_ffi_checksum_method_owner_is_address(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OWNER_IS_IMMUTABLE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OWNER_IS_IMMUTABLE +uint16_t uniffi_iota_sdk_ffi_checksum_method_owner_is_immutable(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OWNER_IS_OBJECT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OWNER_IS_OBJECT +uint16_t uniffi_iota_sdk_ffi_checksum_method_owner_is_object(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OWNER_IS_SHARED +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_OWNER_IS_SHARED +uint16_t uniffi_iota_sdk_ffi_checksum_method_owner_is_shared(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_PASSKEYAUTHENTICATOR_AUTHENTICATOR_DATA +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_PASSKEYAUTHENTICATOR_AUTHENTICATOR_DATA +uint16_t uniffi_iota_sdk_ffi_checksum_method_passkeyauthenticator_authenticator_data(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_PASSKEYAUTHENTICATOR_CHALLENGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_PASSKEYAUTHENTICATOR_CHALLENGE +uint16_t uniffi_iota_sdk_ffi_checksum_method_passkeyauthenticator_challenge(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_PASSKEYAUTHENTICATOR_CLIENT_DATA_JSON +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_PASSKEYAUTHENTICATOR_CLIENT_DATA_JSON +uint16_t uniffi_iota_sdk_ffi_checksum_method_passkeyauthenticator_client_data_json(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_PASSKEYAUTHENTICATOR_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_PASSKEYAUTHENTICATOR_SIGNATURE +uint16_t uniffi_iota_sdk_ffi_checksum_method_passkeyauthenticator_signature(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_PROGRAMMABLETRANSACTION_COMMANDS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_PROGRAMMABLETRANSACTION_COMMANDS +uint16_t uniffi_iota_sdk_ffi_checksum_method_programmabletransaction_commands(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_PROGRAMMABLETRANSACTION_INPUTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_PROGRAMMABLETRANSACTION_INPUTS +uint16_t uniffi_iota_sdk_ffi_checksum_method_programmabletransaction_inputs(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_PUBLISH_DEPENDENCIES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_PUBLISH_DEPENDENCIES +uint16_t uniffi_iota_sdk_ffi_checksum_method_publish_dependencies(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_PUBLISH_MODULES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_PUBLISH_MODULES +uint16_t uniffi_iota_sdk_ffi_checksum_method_publish_modules(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SECP256K1PUBLICKEY_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SECP256K1PUBLICKEY_TO_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_method_secp256k1publickey_to_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SECP256K1SIGNATURE_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SECP256K1SIGNATURE_TO_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_method_secp256k1signature_to_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SECP256R1PUBLICKEY_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SECP256R1PUBLICKEY_TO_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_method_secp256r1publickey_to_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SECP256R1SIGNATURE_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SECP256R1SIGNATURE_TO_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_method_secp256r1signature_to_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_ED25519_PUB_KEY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_ED25519_PUB_KEY +uint16_t uniffi_iota_sdk_ffi_checksum_method_simplesignature_ed25519_pub_key(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_ED25519_PUB_KEY_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_ED25519_PUB_KEY_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_simplesignature_ed25519_pub_key_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_ED25519_SIG +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_ED25519_SIG +uint16_t uniffi_iota_sdk_ffi_checksum_method_simplesignature_ed25519_sig(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_ED25519_SIG_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_ED25519_SIG_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_simplesignature_ed25519_sig_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_IS_ED25519 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_IS_ED25519 +uint16_t uniffi_iota_sdk_ffi_checksum_method_simplesignature_is_ed25519(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_IS_SECP256K1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_IS_SECP256K1 +uint16_t uniffi_iota_sdk_ffi_checksum_method_simplesignature_is_secp256k1(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_IS_SECP256R1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_IS_SECP256R1 +uint16_t uniffi_iota_sdk_ffi_checksum_method_simplesignature_is_secp256r1(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_SCHEME +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_SCHEME +uint16_t uniffi_iota_sdk_ffi_checksum_method_simplesignature_scheme(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_SECP256K1_PUB_KEY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_SECP256K1_PUB_KEY +uint16_t uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256k1_pub_key(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_SECP256K1_PUB_KEY_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_SECP256K1_PUB_KEY_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256k1_pub_key_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_SECP256K1_SIG +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_SECP256K1_SIG +uint16_t uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256k1_sig(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_SECP256K1_SIG_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_SECP256K1_SIG_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256k1_sig_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_SECP256R1_PUB_KEY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_SECP256R1_PUB_KEY +uint16_t uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256r1_pub_key(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_SECP256R1_PUB_KEY_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_SECP256R1_PUB_KEY_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256r1_pub_key_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_SECP256R1_SIG +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_SECP256R1_SIG +uint16_t uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256r1_sig(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_SECP256R1_SIG_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_SECP256R1_SIG_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_simplesignature_secp256r1_sig_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SIMPLESIGNATURE_TO_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_method_simplesignature_to_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SPLITCOINS_AMOUNTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SPLITCOINS_AMOUNTS +uint16_t uniffi_iota_sdk_ffi_checksum_method_splitcoins_amounts(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SPLITCOINS_COIN +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SPLITCOINS_COIN +uint16_t uniffi_iota_sdk_ffi_checksum_method_splitcoins_coin(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_STRUCTTAG_ADDRESS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_STRUCTTAG_ADDRESS +uint16_t uniffi_iota_sdk_ffi_checksum_method_structtag_address(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_STRUCTTAG_COIN_TYPE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_STRUCTTAG_COIN_TYPE +uint16_t uniffi_iota_sdk_ffi_checksum_method_structtag_coin_type(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_STRUCTTAG_COIN_TYPE_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_STRUCTTAG_COIN_TYPE_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_structtag_coin_type_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SYSTEMPACKAGE_DEPENDENCIES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SYSTEMPACKAGE_DEPENDENCIES +uint16_t uniffi_iota_sdk_ffi_checksum_method_systempackage_dependencies(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SYSTEMPACKAGE_MODULES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SYSTEMPACKAGE_MODULES +uint16_t uniffi_iota_sdk_ffi_checksum_method_systempackage_modules(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SYSTEMPACKAGE_VERSION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_SYSTEMPACKAGE_VERSION +uint16_t uniffi_iota_sdk_ffi_checksum_method_systempackage_version(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSACTION_EXPIRATION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSACTION_EXPIRATION +uint16_t uniffi_iota_sdk_ffi_checksum_method_transaction_expiration(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSACTION_GAS_PAYMENT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSACTION_GAS_PAYMENT +uint16_t uniffi_iota_sdk_ffi_checksum_method_transaction_gas_payment(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSACTION_KIND +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSACTION_KIND +uint16_t uniffi_iota_sdk_ffi_checksum_method_transaction_kind(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSACTION_SENDER +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSACTION_SENDER +uint16_t uniffi_iota_sdk_ffi_checksum_method_transaction_sender(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSACTIONDIGEST_TO_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSACTIONDIGEST_TO_BASE58 +uint16_t uniffi_iota_sdk_ffi_checksum_method_transactiondigest_to_base58(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSACTIONDIGEST_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSACTIONDIGEST_TO_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_method_transactiondigest_to_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSACTIONEFFECTS_AS_V1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSACTIONEFFECTS_AS_V1 +uint16_t uniffi_iota_sdk_ffi_checksum_method_transactioneffects_as_v1(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSACTIONEFFECTS_IS_V1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSACTIONEFFECTS_IS_V1 +uint16_t uniffi_iota_sdk_ffi_checksum_method_transactioneffects_is_v1(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSACTIONEFFECTSDIGEST_TO_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSACTIONEFFECTSDIGEST_TO_BASE58 +uint16_t uniffi_iota_sdk_ffi_checksum_method_transactioneffectsdigest_to_base58(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSACTIONEFFECTSDIGEST_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSACTIONEFFECTSDIGEST_TO_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_method_transactioneffectsdigest_to_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSACTIONEVENTSDIGEST_TO_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSACTIONEVENTSDIGEST_TO_BASE58 +uint16_t uniffi_iota_sdk_ffi_checksum_method_transactioneventsdigest_to_base58(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSACTIONEVENTSDIGEST_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSACTIONEVENTSDIGEST_TO_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_method_transactioneventsdigest_to_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSFEROBJECTS_ADDRESS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSFEROBJECTS_ADDRESS +uint16_t uniffi_iota_sdk_ffi_checksum_method_transferobjects_address(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSFEROBJECTS_OBJECTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TRANSFEROBJECTS_OBJECTS +uint16_t uniffi_iota_sdk_ffi_checksum_method_transferobjects_objects(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_AS_STRUCT_TAG +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_AS_STRUCT_TAG +uint16_t uniffi_iota_sdk_ffi_checksum_method_typetag_as_struct_tag(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_AS_STRUCT_TAG_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_AS_STRUCT_TAG_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_typetag_as_struct_tag_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_AS_VECTOR_TYPE_TAG +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_AS_VECTOR_TYPE_TAG +uint16_t uniffi_iota_sdk_ffi_checksum_method_typetag_as_vector_type_tag(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_AS_VECTOR_TYPE_TAG_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_AS_VECTOR_TYPE_TAG_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_typetag_as_vector_type_tag_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_IS_ADDRESS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_IS_ADDRESS +uint16_t uniffi_iota_sdk_ffi_checksum_method_typetag_is_address(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_IS_BOOL +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_IS_BOOL +uint16_t uniffi_iota_sdk_ffi_checksum_method_typetag_is_bool(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_IS_SIGNER +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_IS_SIGNER +uint16_t uniffi_iota_sdk_ffi_checksum_method_typetag_is_signer(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_IS_STRUCT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_IS_STRUCT +uint16_t uniffi_iota_sdk_ffi_checksum_method_typetag_is_struct(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_IS_U128 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_IS_U128 +uint16_t uniffi_iota_sdk_ffi_checksum_method_typetag_is_u128(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_IS_U16 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_IS_U16 +uint16_t uniffi_iota_sdk_ffi_checksum_method_typetag_is_u16(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_IS_U256 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_IS_U256 +uint16_t uniffi_iota_sdk_ffi_checksum_method_typetag_is_u256(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_IS_U32 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_IS_U32 +uint16_t uniffi_iota_sdk_ffi_checksum_method_typetag_is_u32(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_IS_U64 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_IS_U64 +uint16_t uniffi_iota_sdk_ffi_checksum_method_typetag_is_u64(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_IS_U8 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_IS_U8 +uint16_t uniffi_iota_sdk_ffi_checksum_method_typetag_is_u8(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_IS_VECTOR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_TYPETAG_IS_VECTOR +uint16_t uniffi_iota_sdk_ffi_checksum_method_typetag_is_vector(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_UPGRADE_DEPENDENCIES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_UPGRADE_DEPENDENCIES +uint16_t uniffi_iota_sdk_ffi_checksum_method_upgrade_dependencies(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_UPGRADE_MODULES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_UPGRADE_MODULES +uint16_t uniffi_iota_sdk_ffi_checksum_method_upgrade_modules(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_UPGRADE_PACKAGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_UPGRADE_PACKAGE +uint16_t uniffi_iota_sdk_ffi_checksum_method_upgrade_package(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_UPGRADE_TICKET +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_UPGRADE_TICKET +uint16_t uniffi_iota_sdk_ffi_checksum_method_upgrade_ticket(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_AS_MULTISIG +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_AS_MULTISIG +uint16_t uniffi_iota_sdk_ffi_checksum_method_usersignature_as_multisig(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_AS_MULTISIG_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_AS_MULTISIG_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_usersignature_as_multisig_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_AS_PASSKEY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_AS_PASSKEY +uint16_t uniffi_iota_sdk_ffi_checksum_method_usersignature_as_passkey(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_AS_PASSKEY_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_AS_PASSKEY_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_usersignature_as_passkey_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_AS_SIMPLE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_AS_SIMPLE +uint16_t uniffi_iota_sdk_ffi_checksum_method_usersignature_as_simple(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_AS_SIMPLE_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_AS_SIMPLE_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_usersignature_as_simple_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_AS_ZKLOGIN +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_AS_ZKLOGIN +uint16_t uniffi_iota_sdk_ffi_checksum_method_usersignature_as_zklogin(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_AS_ZKLOGIN_OPT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_AS_ZKLOGIN_OPT +uint16_t uniffi_iota_sdk_ffi_checksum_method_usersignature_as_zklogin_opt(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_IS_MULTISIG +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_IS_MULTISIG +uint16_t uniffi_iota_sdk_ffi_checksum_method_usersignature_is_multisig(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_IS_PASSKEY +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_IS_PASSKEY +uint16_t uniffi_iota_sdk_ffi_checksum_method_usersignature_is_passkey(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_IS_SIMPLE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_IS_SIMPLE +uint16_t uniffi_iota_sdk_ffi_checksum_method_usersignature_is_simple(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_IS_ZKLOGIN +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_IS_ZKLOGIN +uint16_t uniffi_iota_sdk_ffi_checksum_method_usersignature_is_zklogin(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_SCHEME +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_SCHEME +uint16_t uniffi_iota_sdk_ffi_checksum_method_usersignature_scheme(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_TO_BASE64 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_TO_BASE64 +uint16_t uniffi_iota_sdk_ffi_checksum_method_usersignature_to_base64(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_TO_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_USERSIGNATURE_TO_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_method_usersignature_to_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_VALIDATOREXECUTIONTIMEOBSERVATION_DURATION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_VALIDATOREXECUTIONTIMEOBSERVATION_DURATION +uint16_t uniffi_iota_sdk_ffi_checksum_method_validatorexecutiontimeobservation_duration(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_VALIDATOREXECUTIONTIMEOBSERVATION_VALIDATOR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_VALIDATOREXECUTIONTIMEOBSERVATION_VALIDATOR +uint16_t uniffi_iota_sdk_ffi_checksum_method_validatorexecutiontimeobservation_validator(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_VERSIONASSIGNMENT_OBJECT_ID +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_VERSIONASSIGNMENT_OBJECT_ID +uint16_t uniffi_iota_sdk_ffi_checksum_method_versionassignment_object_id(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_VERSIONASSIGNMENT_VERSION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_VERSIONASSIGNMENT_VERSION +uint16_t uniffi_iota_sdk_ffi_checksum_method_versionassignment_version(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ZKLOGINAUTHENTICATOR_INPUTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ZKLOGINAUTHENTICATOR_INPUTS +uint16_t uniffi_iota_sdk_ffi_checksum_method_zkloginauthenticator_inputs(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ZKLOGINAUTHENTICATOR_MAX_EPOCH +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ZKLOGINAUTHENTICATOR_MAX_EPOCH +uint16_t uniffi_iota_sdk_ffi_checksum_method_zkloginauthenticator_max_epoch(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ZKLOGINAUTHENTICATOR_SIGNATURE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ZKLOGINAUTHENTICATOR_SIGNATURE +uint16_t uniffi_iota_sdk_ffi_checksum_method_zkloginauthenticator_signature(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ZKLOGININPUTS_ADDRESS_SEED +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ZKLOGININPUTS_ADDRESS_SEED +uint16_t uniffi_iota_sdk_ffi_checksum_method_zklogininputs_address_seed(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ZKLOGININPUTS_HEADER_BASE64 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ZKLOGININPUTS_HEADER_BASE64 +uint16_t uniffi_iota_sdk_ffi_checksum_method_zklogininputs_header_base64(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ZKLOGININPUTS_ISS_BASE64_DETAILS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ZKLOGININPUTS_ISS_BASE64_DETAILS +uint16_t uniffi_iota_sdk_ffi_checksum_method_zklogininputs_iss_base64_details(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ZKLOGININPUTS_PROOF_POINTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ZKLOGININPUTS_PROOF_POINTS +uint16_t uniffi_iota_sdk_ffi_checksum_method_zklogininputs_proof_points(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ZKLOGINPROOF_A +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ZKLOGINPROOF_A +uint16_t uniffi_iota_sdk_ffi_checksum_method_zkloginproof_a(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ZKLOGINPROOF_B +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ZKLOGINPROOF_B +uint16_t uniffi_iota_sdk_ffi_checksum_method_zkloginproof_b(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ZKLOGINPROOF_C +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ZKLOGINPROOF_C +uint16_t uniffi_iota_sdk_ffi_checksum_method_zkloginproof_c(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ZKLOGINPUBLICIDENTIFIER_ADDRESS_SEED +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ZKLOGINPUBLICIDENTIFIER_ADDRESS_SEED +uint16_t uniffi_iota_sdk_ffi_checksum_method_zkloginpublicidentifier_address_seed(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ZKLOGINPUBLICIDENTIFIER_ISS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_METHOD_ZKLOGINPUBLICIDENTIFIER_ISS +uint16_t uniffi_iota_sdk_ffi_checksum_method_zkloginpublicidentifier_iss(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ADDRESS_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ADDRESS_FROM_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_address_from_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ADDRESS_FROM_HEX +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ADDRESS_FROM_HEX +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_address_from_hex(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ADDRESS_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ADDRESS_GENERATE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_address_generate(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ARGUMENT_NEW_GAS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ARGUMENT_NEW_GAS +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_argument_new_gas(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ARGUMENT_NEW_INPUT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ARGUMENT_NEW_INPUT +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_argument_new_input(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ARGUMENT_NEW_NESTED_RESULT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ARGUMENT_NEW_NESTED_RESULT +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_argument_new_nested_result(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ARGUMENT_NEW_RESULT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ARGUMENT_NEW_RESULT +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_argument_new_result(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_BLS12381PUBLICKEY_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_BLS12381PUBLICKEY_FROM_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_bls12381publickey_from_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_BLS12381PUBLICKEY_FROM_STR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_BLS12381PUBLICKEY_FROM_STR +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_bls12381publickey_from_str(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_BLS12381PUBLICKEY_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_BLS12381PUBLICKEY_GENERATE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_bls12381publickey_generate(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_BLS12381SIGNATURE_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_BLS12381SIGNATURE_FROM_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_bls12381signature_from_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_BLS12381SIGNATURE_FROM_STR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_BLS12381SIGNATURE_FROM_STR +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_bls12381signature_from_str(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_BLS12381SIGNATURE_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_BLS12381SIGNATURE_GENERATE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_bls12381signature_generate(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_BN254FIELDELEMENT_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_BN254FIELDELEMENT_FROM_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_bn254fieldelement_from_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_BN254FIELDELEMENT_FROM_STR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_BN254FIELDELEMENT_FROM_STR +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_bn254fieldelement_from_str(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_BN254FIELDELEMENT_FROM_STR_RADIX_10 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_BN254FIELDELEMENT_FROM_STR_RADIX_10 +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_bn254fieldelement_from_str_radix_10(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CANCELLEDTRANSACTION_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CANCELLEDTRANSACTION_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_cancelledtransaction_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CHANGEEPOCH_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CHANGEEPOCH_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_changeepoch_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CHANGEEPOCHV2_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CHANGEEPOCHV2_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_changeepochv2_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CHECKPOINTCONTENTSDIGEST_FROM_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CHECKPOINTCONTENTSDIGEST_FROM_BASE58 +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_checkpointcontentsdigest_from_base58(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CHECKPOINTCONTENTSDIGEST_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CHECKPOINTCONTENTSDIGEST_FROM_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_checkpointcontentsdigest_from_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CHECKPOINTCONTENTSDIGEST_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CHECKPOINTCONTENTSDIGEST_GENERATE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_checkpointcontentsdigest_generate(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CHECKPOINTDIGEST_FROM_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CHECKPOINTDIGEST_FROM_BASE58 +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_checkpointdigest_from_base58(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CHECKPOINTDIGEST_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CHECKPOINTDIGEST_FROM_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_checkpointdigest_from_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CHECKPOINTDIGEST_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CHECKPOINTDIGEST_GENERATE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_checkpointdigest_generate(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CIRCOMG1_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CIRCOMG1_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_circomg1_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CIRCOMG2_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CIRCOMG2_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_circomg2_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_COIN_TRY_FROM_OBJECT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_COIN_TRY_FROM_OBJECT +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_coin_try_from_object(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_COMMAND_NEW_MAKE_MOVE_VECTOR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_COMMAND_NEW_MAKE_MOVE_VECTOR +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_command_new_make_move_vector(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_COMMAND_NEW_MERGE_COINS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_COMMAND_NEW_MERGE_COINS +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_command_new_merge_coins(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_COMMAND_NEW_MOVE_CALL +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_COMMAND_NEW_MOVE_CALL +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_command_new_move_call(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_COMMAND_NEW_PUBLISH +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_COMMAND_NEW_PUBLISH +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_command_new_publish(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_COMMAND_NEW_SPLIT_COINS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_COMMAND_NEW_SPLIT_COINS +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_command_new_split_coins(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_COMMAND_NEW_TRANSFER_OBJECTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_COMMAND_NEW_TRANSFER_OBJECTS +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_command_new_transfer_objects(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_COMMAND_NEW_UPGRADE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_COMMAND_NEW_UPGRADE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_command_new_upgrade(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CONSENSUSCOMMITDIGEST_FROM_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CONSENSUSCOMMITDIGEST_FROM_BASE58 +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_consensuscommitdigest_from_base58(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CONSENSUSCOMMITDIGEST_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CONSENSUSCOMMITDIGEST_FROM_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_consensuscommitdigest_from_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CONSENSUSCOMMITDIGEST_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CONSENSUSCOMMITDIGEST_GENERATE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_consensuscommitdigest_generate(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CONSENSUSCOMMITPROLOGUEV1_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CONSENSUSCOMMITPROLOGUEV1_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_consensuscommitprologuev1_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CONSENSUSDETERMINEDVERSIONASSIGNMENTS_NEW_CANCELLED_TRANSACTIONS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_CONSENSUSDETERMINEDVERSIONASSIGNMENTS_NEW_CANCELLED_TRANSACTIONS +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_consensusdeterminedversionassignments_new_cancelled_transactions(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_DIGEST_FROM_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_DIGEST_FROM_BASE58 +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_digest_from_base58(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_DIGEST_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_DIGEST_FROM_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_digest_from_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_DIGEST_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_DIGEST_GENERATE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_digest_generate(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ED25519PUBLICKEY_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ED25519PUBLICKEY_FROM_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_ed25519publickey_from_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ED25519PUBLICKEY_FROM_STR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ED25519PUBLICKEY_FROM_STR +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_ed25519publickey_from_str(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ED25519PUBLICKEY_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ED25519PUBLICKEY_GENERATE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_ed25519publickey_generate(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ED25519SIGNATURE_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ED25519SIGNATURE_FROM_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_ed25519signature_from_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ED25519SIGNATURE_FROM_STR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ED25519SIGNATURE_FROM_STR +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_ed25519signature_from_str(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ED25519SIGNATURE_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ED25519SIGNATURE_GENERATE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_ed25519signature_generate(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_EFFECTSAUXILIARYDATADIGEST_FROM_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_EFFECTSAUXILIARYDATADIGEST_FROM_BASE58 +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_effectsauxiliarydatadigest_from_base58(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_EFFECTSAUXILIARYDATADIGEST_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_EFFECTSAUXILIARYDATADIGEST_FROM_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_effectsauxiliarydatadigest_from_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_EFFECTSAUXILIARYDATADIGEST_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_EFFECTSAUXILIARYDATADIGEST_GENERATE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_effectsauxiliarydatadigest_generate(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ENDOFEPOCHTRANSACTIONKIND_AUTHENTICATOR_STATE_CREATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ENDOFEPOCHTRANSACTIONKIND_AUTHENTICATOR_STATE_CREATE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_endofepochtransactionkind_authenticator_state_create(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ENDOFEPOCHTRANSACTIONKIND_AUTHENTICATOR_STATE_EXPIRE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ENDOFEPOCHTRANSACTIONKIND_AUTHENTICATOR_STATE_EXPIRE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_endofepochtransactionkind_authenticator_state_expire(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ENDOFEPOCHTRANSACTIONKIND_CHANGE_EPOCH +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ENDOFEPOCHTRANSACTIONKIND_CHANGE_EPOCH +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_endofepochtransactionkind_change_epoch(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ENDOFEPOCHTRANSACTIONKIND_CHANGE_EPOCH_V2 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ENDOFEPOCHTRANSACTIONKIND_CHANGE_EPOCH_V2 +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_endofepochtransactionkind_change_epoch_v2(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_EXECUTIONTIMEOBSERVATION_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_EXECUTIONTIMEOBSERVATION_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservation_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_MAKE_MOVE_VEC +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_MAKE_MOVE_VEC +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_make_move_vec(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_MERGE_COINS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_MERGE_COINS +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_merge_coins(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_MOVE_ENTRY_POINT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_MOVE_ENTRY_POINT +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_move_entry_point(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_PUBLISH +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_PUBLISH +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_publish(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_SPLIT_COINS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_SPLIT_COINS +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_split_coins(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_TRANSFER_OBJECTS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_TRANSFER_OBJECTS +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_transfer_objects(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_UPGRADE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONKEY_NEW_UPGRADE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservationkey_new_upgrade(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONS_NEW_V1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_EXECUTIONTIMEOBSERVATIONS_NEW_V1 +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_executiontimeobservations_new_v1(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_FAUCETCLIENT_DEVNET +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_FAUCETCLIENT_DEVNET +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_faucetclient_devnet(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_FAUCETCLIENT_LOCAL +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_FAUCETCLIENT_LOCAL +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_faucetclient_local(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_FAUCETCLIENT_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_FAUCETCLIENT_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_faucetclient_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_FAUCETCLIENT_TESTNET +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_FAUCETCLIENT_TESTNET +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_faucetclient_testnet(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_GENESISOBJECT_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_GENESISOBJECT_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_genesisobject_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_GENESISTRANSACTION_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_GENESISTRANSACTION_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_genesistransaction_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_GRAPHQLCLIENT_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_GRAPHQLCLIENT_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_graphqlclient_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_GRAPHQLCLIENT_NEW_DEVNET +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_GRAPHQLCLIENT_NEW_DEVNET +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_graphqlclient_new_devnet(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_GRAPHQLCLIENT_NEW_LOCALHOST +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_GRAPHQLCLIENT_NEW_LOCALHOST +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_graphqlclient_new_localhost(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_GRAPHQLCLIENT_NEW_MAINNET +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_GRAPHQLCLIENT_NEW_MAINNET +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_graphqlclient_new_mainnet(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_GRAPHQLCLIENT_NEW_TESTNET +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_GRAPHQLCLIENT_NEW_TESTNET +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_graphqlclient_new_testnet(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_IDENTIFIER_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_IDENTIFIER_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_identifier_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_INPUT_NEW_IMMUTABLE_OR_OWNED +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_INPUT_NEW_IMMUTABLE_OR_OWNED +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_input_new_immutable_or_owned(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_INPUT_NEW_PURE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_INPUT_NEW_PURE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_input_new_pure(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_INPUT_NEW_RECEIVING +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_INPUT_NEW_RECEIVING +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_input_new_receiving(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_INPUT_NEW_SHARED +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_INPUT_NEW_SHARED +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_input_new_shared(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_MAKEMOVEVECTOR_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_MAKEMOVEVECTOR_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_makemovevector_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_MERGECOINS_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_MERGECOINS_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_mergecoins_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_MOVECALL_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_MOVECALL_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_movecall_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_MOVEPACKAGE_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_MOVEPACKAGE_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_movepackage_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_MULTISIGAGGREGATEDSIGNATURE_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_MULTISIGAGGREGATEDSIGNATURE_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_multisigaggregatedsignature_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_MULTISIGCOMMITTEE_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_MULTISIGCOMMITTEE_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_multisigcommittee_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_MULTISIGMEMBER_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_MULTISIGMEMBER_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_multisigmember_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OBJECT_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OBJECT_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_object_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OBJECTDATA_NEW_MOVE_PACKAGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OBJECTDATA_NEW_MOVE_PACKAGE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_objectdata_new_move_package(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OBJECTDATA_NEW_MOVE_STRUCT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OBJECTDATA_NEW_MOVE_STRUCT +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_objectdata_new_move_struct(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OBJECTDIGEST_FROM_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OBJECTDIGEST_FROM_BASE58 +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_objectdigest_from_base58(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OBJECTDIGEST_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OBJECTDIGEST_FROM_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_objectdigest_from_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OBJECTDIGEST_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OBJECTDIGEST_GENERATE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_objectdigest_generate(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OBJECTID_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OBJECTID_FROM_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_objectid_from_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OBJECTID_FROM_HEX +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OBJECTID_FROM_HEX +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_objectid_from_hex(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OBJECTTYPE_NEW_PACKAGE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OBJECTTYPE_NEW_PACKAGE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_objecttype_new_package(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OBJECTTYPE_NEW_STRUCT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OBJECTTYPE_NEW_STRUCT +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_objecttype_new_struct(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OWNER_NEW_ADDRESS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OWNER_NEW_ADDRESS +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_owner_new_address(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OWNER_NEW_IMMUTABLE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OWNER_NEW_IMMUTABLE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_owner_new_immutable(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OWNER_NEW_OBJECT +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OWNER_NEW_OBJECT +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_owner_new_object(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OWNER_NEW_SHARED +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_OWNER_NEW_SHARED +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_owner_new_shared(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_PROGRAMMABLETRANSACTION_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_PROGRAMMABLETRANSACTION_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_programmabletransaction_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_PUBLISH_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_PUBLISH_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_publish_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SECP256K1PUBLICKEY_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SECP256K1PUBLICKEY_FROM_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_secp256k1publickey_from_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SECP256K1PUBLICKEY_FROM_STR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SECP256K1PUBLICKEY_FROM_STR +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_secp256k1publickey_from_str(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SECP256K1PUBLICKEY_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SECP256K1PUBLICKEY_GENERATE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_secp256k1publickey_generate(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SECP256K1SIGNATURE_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SECP256K1SIGNATURE_FROM_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_secp256k1signature_from_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SECP256K1SIGNATURE_FROM_STR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SECP256K1SIGNATURE_FROM_STR +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_secp256k1signature_from_str(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SECP256K1SIGNATURE_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SECP256K1SIGNATURE_GENERATE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_secp256k1signature_generate(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SECP256R1PUBLICKEY_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SECP256R1PUBLICKEY_FROM_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_secp256r1publickey_from_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SECP256R1PUBLICKEY_FROM_STR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SECP256R1PUBLICKEY_FROM_STR +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_secp256r1publickey_from_str(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SECP256R1PUBLICKEY_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SECP256R1PUBLICKEY_GENERATE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_secp256r1publickey_generate(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SECP256R1SIGNATURE_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SECP256R1SIGNATURE_FROM_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_secp256r1signature_from_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SECP256R1SIGNATURE_FROM_STR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SECP256R1SIGNATURE_FROM_STR +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_secp256r1signature_from_str(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SECP256R1SIGNATURE_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SECP256R1SIGNATURE_GENERATE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_secp256r1signature_generate(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SPLITCOINS_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SPLITCOINS_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_splitcoins_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_STRUCTTAG_COIN +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_STRUCTTAG_COIN +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_structtag_coin(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_STRUCTTAG_GAS_COIN +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_STRUCTTAG_GAS_COIN +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_structtag_gas_coin(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_STRUCTTAG_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_STRUCTTAG_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_structtag_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_STRUCTTAG_STAKED_IOTA +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_STRUCTTAG_STAKED_IOTA +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_structtag_staked_iota(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SYSTEMPACKAGE_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_SYSTEMPACKAGE_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_systempackage_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTION_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTION_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_transaction_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONDIGEST_FROM_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONDIGEST_FROM_BASE58 +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_transactiondigest_from_base58(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONDIGEST_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONDIGEST_FROM_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_transactiondigest_from_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONDIGEST_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONDIGEST_GENERATE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_transactiondigest_generate(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONEFFECTS_NEW_V1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONEFFECTS_NEW_V1 +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_transactioneffects_new_v1(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONEFFECTSDIGEST_FROM_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONEFFECTSDIGEST_FROM_BASE58 +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_transactioneffectsdigest_from_base58(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONEFFECTSDIGEST_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONEFFECTSDIGEST_FROM_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_transactioneffectsdigest_from_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONEFFECTSDIGEST_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONEFFECTSDIGEST_GENERATE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_transactioneffectsdigest_generate(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONEVENTSDIGEST_FROM_BASE58 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONEVENTSDIGEST_FROM_BASE58 +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_transactioneventsdigest_from_base58(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONEVENTSDIGEST_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONEVENTSDIGEST_FROM_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_transactioneventsdigest_from_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONEVENTSDIGEST_GENERATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONEVENTSDIGEST_GENERATE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_transactioneventsdigest_generate(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONKIND_AUTHENTICATOR_STATE_UPDATE_V1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONKIND_AUTHENTICATOR_STATE_UPDATE_V1 +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_transactionkind_authenticator_state_update_v1(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONKIND_CONSENSUS_COMMIT_PROLOGUE_V1 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONKIND_CONSENSUS_COMMIT_PROLOGUE_V1 +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_transactionkind_consensus_commit_prologue_v1(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONKIND_END_OF_EPOCH +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONKIND_END_OF_EPOCH +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_transactionkind_end_of_epoch(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONKIND_GENESIS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONKIND_GENESIS +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_transactionkind_genesis(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONKIND_PROGRAMMABLE_TRANSACTION +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONKIND_PROGRAMMABLE_TRANSACTION +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_transactionkind_programmable_transaction(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONKIND_RANDOMNESS_STATE_UPDATE +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSACTIONKIND_RANDOMNESS_STATE_UPDATE +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_transactionkind_randomness_state_update(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSFEROBJECTS_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TRANSFEROBJECTS_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_transferobjects_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TYPETAG_ADDRESS +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TYPETAG_ADDRESS +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_typetag_address(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TYPETAG_BOOL +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TYPETAG_BOOL +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_typetag_bool(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TYPETAG_SIGNER +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TYPETAG_SIGNER +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_typetag_signer(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TYPETAG_STRUCT_TAG +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TYPETAG_STRUCT_TAG +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_typetag_struct_tag(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TYPETAG_U128 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TYPETAG_U128 +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_typetag_u128(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TYPETAG_U16 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TYPETAG_U16 +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_typetag_u16(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TYPETAG_U256 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TYPETAG_U256 +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_typetag_u256(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TYPETAG_U32 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TYPETAG_U32 +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_typetag_u32(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TYPETAG_U64 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TYPETAG_U64 +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_typetag_u64(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TYPETAG_U8 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TYPETAG_U8 +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_typetag_u8(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TYPETAG_VECTOR +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_TYPETAG_VECTOR +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_typetag_vector(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_UPGRADE_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_UPGRADE_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_upgrade_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_USERSIGNATURE_FROM_BASE64 +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_USERSIGNATURE_FROM_BASE64 +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_usersignature_from_base64(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_USERSIGNATURE_FROM_BYTES +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_USERSIGNATURE_FROM_BYTES +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_usersignature_from_bytes(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_VALIDATOREXECUTIONTIMEOBSERVATION_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_VALIDATOREXECUTIONTIMEOBSERVATION_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_validatorexecutiontimeobservation_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_VERSIONASSIGNMENT_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_VERSIONASSIGNMENT_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_versionassignment_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ZKLOGINAUTHENTICATOR_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ZKLOGINAUTHENTICATOR_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_zkloginauthenticator_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ZKLOGININPUTS_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ZKLOGININPUTS_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_zklogininputs_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ZKLOGINPROOF_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ZKLOGINPROOF_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_zkloginproof_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ZKLOGINPUBLICIDENTIFIER_NEW +#define UNIFFI_FFIDEF_UNIFFI_IOTA_SDK_FFI_CHECKSUM_CONSTRUCTOR_ZKLOGINPUBLICIDENTIFIER_NEW +uint16_t uniffi_iota_sdk_ffi_checksum_constructor_zkloginpublicidentifier_new(void + +); +#endif +#ifndef UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_UNIFFI_CONTRACT_VERSION +#define UNIFFI_FFIDEF_FFI_IOTA_SDK_FFI_UNIFFI_CONTRACT_VERSION +uint32_t ffi_iota_sdk_ffi_uniffi_contract_version(void + +); +#endif + diff --git a/bindings/swift/lib/iota_sdk_ffiFFI.modulemap b/bindings/swift/lib/iota_sdk_ffiFFI.modulemap new file mode 100644 index 000000000..03e0d1af6 --- /dev/null +++ b/bindings/swift/lib/iota_sdk_ffiFFI.modulemap @@ -0,0 +1,7 @@ +module iota_sdk_ffiFFI { + header "iota_sdk_ffiFFI.h" + export * + use "Darwin" + use "_Builtin_stdbool" + use "_Builtin_stdint" +} \ No newline at end of file From a55b9effdb1a1173ded13ae3ab285685d00fc313 Mon Sep 17 00:00:00 2001 From: Thibault Martinez Date: Fri, 15 Aug 2025 13:20:16 +0200 Subject: [PATCH 2/2] add CI --- .github/workflows/bindings.yml | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/.github/workflows/bindings.yml b/.github/workflows/bindings.yml index cc75e8b87..cef855b40 100644 --- a/.github/workflows/bindings.yml +++ b/.github/workflows/bindings.yml @@ -55,3 +55,14 @@ jobs: run: git diff --exit-code - name: Run the example run: make test-python + swift: + runs-on: ubuntu-latest + steps: + - name: Checkout repository + uses: actions/checkout@v4 + - name: Build the bindings + run: make swift + - name: Checks for uncommitted changes + run: git diff --exit-code + - name: Run the example + run: make test-swift