3379 lines
102 KiB
Swift
3379 lines
102 KiB
Swift
// This file was autogenerated by some hot garbage in the `uniffi` crate.
|
|
// Trust me, you don't want to mess with it!
|
|
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(bdkFFI)
|
|
import bdkFFI
|
|
#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 from(_ ptr: UnsafeBufferPointer<UInt8>) -> RustBuffer {
|
|
try! rustCall { ffi_bdk_1724_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_bdk_1724_rustbuffer_free(self, $0) }
|
|
}
|
|
}
|
|
|
|
fileprivate extension ForeignBytes {
|
|
init(bufferPointer: UnsafeBufferPointer<UInt8>) {
|
|
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 libray of its own.
|
|
|
|
fileprivate extension Data {
|
|
init(rustBuffer: RustBuffer) {
|
|
// TODO: This copies the buffer. Can we read directly from a
|
|
// Rust buffer?
|
|
self.init(bytes: rustBuffer.data!, count: Int(rustBuffer.len))
|
|
}
|
|
}
|
|
|
|
// A helper class to read values out of a byte buffer.
|
|
fileprivate class Reader {
|
|
let data: Data
|
|
var offset: Data.Index
|
|
|
|
init(data: Data) {
|
|
self.data = data
|
|
self.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.
|
|
func readInt<T: FixedWidthInteger>() throws -> T {
|
|
let range = offset..<offset + MemoryLayout<T>.size
|
|
guard data.count >= range.upperBound else {
|
|
throw UniffiInternalError.bufferOverflow
|
|
}
|
|
if T.self == UInt8.self {
|
|
let value = data[offset]
|
|
offset += 1
|
|
return value as! T
|
|
}
|
|
var value: T = 0
|
|
let _ = withUnsafeMutableBytes(of: &value, { data.copyBytes(to: $0, from: range)})
|
|
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
|
|
func readBytes(count: Int) throws -> Array<UInt8> {
|
|
let range = offset..<(offset+count)
|
|
guard data.count >= range.upperBound else {
|
|
throw UniffiInternalError.bufferOverflow
|
|
}
|
|
var value = [UInt8](repeating: 0, count: count)
|
|
value.withUnsafeMutableBufferPointer({ buffer in
|
|
data.copyBytes(to: buffer, from: range)
|
|
})
|
|
offset = range.upperBound
|
|
return value
|
|
}
|
|
|
|
// Reads a float at the current offset.
|
|
@inlinable
|
|
func readFloat() throws -> Float {
|
|
return Float(bitPattern: try readInt())
|
|
}
|
|
|
|
// Reads a float at the current offset.
|
|
@inlinable
|
|
func readDouble() throws -> Double {
|
|
return Double(bitPattern: try readInt())
|
|
}
|
|
|
|
// Indicates if the offset has reached the end of the buffer.
|
|
@inlinable
|
|
func hasRemaining() -> Bool {
|
|
return offset < data.count
|
|
}
|
|
}
|
|
|
|
// A helper class to write values into a byte buffer.
|
|
fileprivate class Writer {
|
|
var bytes: [UInt8]
|
|
var offset: Array<UInt8>.Index
|
|
|
|
init() {
|
|
self.bytes = []
|
|
self.offset = 0
|
|
}
|
|
|
|
func writeBytes<S>(_ byteArr: S) where S: Sequence, S.Element == UInt8 {
|
|
bytes.append(contentsOf: byteArr)
|
|
}
|
|
|
|
// Writes an integer in big-endian order.
|
|
//
|
|
// Warning: make sure what you are trying to write
|
|
// is in the correct type!
|
|
func writeInt<T: FixedWidthInteger>(_ value: T) {
|
|
var value = value.bigEndian
|
|
withUnsafeBytes(of: &value) { bytes.append(contentsOf: $0) }
|
|
}
|
|
|
|
@inlinable
|
|
func writeFloat(_ value: Float) {
|
|
writeInt(value.bitPattern)
|
|
}
|
|
|
|
@inlinable
|
|
func writeDouble(_ value: Double) {
|
|
writeInt(value.bitPattern)
|
|
}
|
|
}
|
|
|
|
// Protocol for types that transfer other types across the FFI. This is
|
|
// analogous go 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: Reader) throws -> SwiftType
|
|
static func write(_ value: SwiftType, into buf: Writer)
|
|
}
|
|
|
|
// Types conforming to `Primitive` pass themselves directly over the FFI.
|
|
fileprivate protocol FfiConverterPrimitive: FfiConverter where FfiType == SwiftType { }
|
|
|
|
extension FfiConverterPrimitive {
|
|
static func lift(_ value: FfiType) throws -> SwiftType {
|
|
return value
|
|
}
|
|
|
|
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 {
|
|
static func lift(_ buf: RustBuffer) throws -> SwiftType {
|
|
let reader = Reader(data: Data(rustBuffer: buf))
|
|
let value = try read(from: reader)
|
|
if reader.hasRemaining() {
|
|
throw UniffiInternalError.incompleteData
|
|
}
|
|
buf.deallocate()
|
|
return value
|
|
}
|
|
|
|
static func lower(_ value: SwiftType) -> RustBuffer {
|
|
let writer = Writer()
|
|
write(value, into: writer)
|
|
return RustBuffer(bytes: writer.bytes)
|
|
}
|
|
}
|
|
// 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 let CALL_SUCCESS: Int8 = 0
|
|
fileprivate let CALL_ERROR: Int8 = 1
|
|
fileprivate let CALL_PANIC: Int8 = 2
|
|
|
|
fileprivate extension RustCallStatus {
|
|
init() {
|
|
self.init(
|
|
code: CALL_SUCCESS,
|
|
errorBuf: RustBuffer.init(
|
|
capacity: 0,
|
|
len: 0,
|
|
data: nil
|
|
)
|
|
)
|
|
}
|
|
}
|
|
|
|
private func rustCall<T>(_ callback: (UnsafeMutablePointer<RustCallStatus>) -> T) throws -> T {
|
|
try makeRustCall(callback, errorHandler: {
|
|
$0.deallocate()
|
|
return UniffiInternalError.unexpectedRustCallError
|
|
})
|
|
}
|
|
|
|
private func rustCallWithError<T, F: FfiConverter>
|
|
(_ errorFfiConverter: F.Type, _ callback: (UnsafeMutablePointer<RustCallStatus>) -> T) throws -> T
|
|
where F.SwiftType: Error, F.FfiType == RustBuffer
|
|
{
|
|
try makeRustCall(callback, errorHandler: { return try errorFfiConverter.lift($0) })
|
|
}
|
|
|
|
private func makeRustCall<T>(_ callback: (UnsafeMutablePointer<RustCallStatus>) -> T, errorHandler: (RustBuffer) throws -> Error) throws -> T {
|
|
var callStatus = RustCallStatus.init()
|
|
let returnedVal = callback(&callStatus)
|
|
switch callStatus.code {
|
|
case CALL_SUCCESS:
|
|
return returnedVal
|
|
|
|
case CALL_ERROR:
|
|
throw try errorHandler(callStatus.errorBuf)
|
|
|
|
case CALL_PANIC:
|
|
// 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")
|
|
}
|
|
|
|
default:
|
|
throw UniffiInternalError.unexpectedRustCallStatusCode
|
|
}
|
|
}
|
|
|
|
// Public interface members begin here.
|
|
|
|
|
|
fileprivate struct FfiConverterUInt8: FfiConverterPrimitive {
|
|
typealias FfiType = UInt8
|
|
typealias SwiftType = UInt8
|
|
|
|
static func read(from buf: Reader) throws -> UInt8 {
|
|
return try lift(buf.readInt())
|
|
}
|
|
|
|
static func write(_ value: UInt8, into buf: Writer) {
|
|
buf.writeInt(lower(value))
|
|
}
|
|
}
|
|
|
|
fileprivate struct FfiConverterUInt32: FfiConverterPrimitive {
|
|
typealias FfiType = UInt32
|
|
typealias SwiftType = UInt32
|
|
|
|
static func read(from buf: Reader) throws -> UInt32 {
|
|
return try lift(buf.readInt())
|
|
}
|
|
|
|
static func write(_ value: SwiftType, into buf: Writer) {
|
|
buf.writeInt(lower(value))
|
|
}
|
|
}
|
|
|
|
fileprivate struct FfiConverterUInt64: FfiConverterPrimitive {
|
|
typealias FfiType = UInt64
|
|
typealias SwiftType = UInt64
|
|
|
|
static func read(from buf: Reader) throws -> UInt64 {
|
|
return try lift(buf.readInt())
|
|
}
|
|
|
|
static func write(_ value: SwiftType, into buf: Writer) {
|
|
buf.writeInt(lower(value))
|
|
}
|
|
}
|
|
|
|
fileprivate struct FfiConverterFloat: FfiConverterPrimitive {
|
|
typealias FfiType = Float
|
|
typealias SwiftType = Float
|
|
|
|
static func read(from buf: Reader) throws -> Float {
|
|
return try lift(buf.readFloat())
|
|
}
|
|
|
|
static func write(_ value: Float, into buf: Writer) {
|
|
buf.writeFloat(lower(value))
|
|
}
|
|
}
|
|
|
|
fileprivate struct FfiConverterBool : FfiConverter {
|
|
typealias FfiType = Int8
|
|
typealias SwiftType = Bool
|
|
|
|
static func lift(_ value: Int8) throws -> Bool {
|
|
return value != 0
|
|
}
|
|
|
|
static func lower(_ value: Bool) -> Int8 {
|
|
return value ? 1 : 0
|
|
}
|
|
|
|
static func read(from buf: Reader) throws -> Bool {
|
|
return try lift(buf.readInt())
|
|
}
|
|
|
|
static func write(_ value: Bool, into buf: Writer) {
|
|
buf.writeInt(lower(value))
|
|
}
|
|
}
|
|
|
|
fileprivate struct FfiConverterString: FfiConverter {
|
|
typealias SwiftType = String
|
|
typealias FfiType = RustBuffer
|
|
|
|
static func lift(_ value: RustBuffer) throws -> String {
|
|
defer {
|
|
value.deallocate()
|
|
}
|
|
if value.data == nil {
|
|
return String()
|
|
}
|
|
let bytes = UnsafeBufferPointer<UInt8>(start: value.data!, count: Int(value.len))
|
|
return String(bytes: bytes, encoding: String.Encoding.utf8)!
|
|
}
|
|
|
|
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)
|
|
}
|
|
}
|
|
}
|
|
|
|
static func read(from buf: Reader) throws -> String {
|
|
let len: Int32 = try buf.readInt()
|
|
return String(bytes: try buf.readBytes(count: Int(len)), encoding: String.Encoding.utf8)!
|
|
}
|
|
|
|
static func write(_ value: String, into buf: Writer) {
|
|
let len = Int32(value.utf8.count)
|
|
buf.writeInt(len)
|
|
buf.writeBytes(value.utf8)
|
|
}
|
|
}
|
|
|
|
|
|
public protocol AddressProtocol {
|
|
func `scriptPubkey`() -> Script
|
|
|
|
}
|
|
|
|
public class Address: AddressProtocol {
|
|
fileprivate let pointer: UnsafeMutableRawPointer
|
|
|
|
// 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`.
|
|
required init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
|
|
self.pointer = pointer
|
|
}
|
|
public convenience init(`address`: String) throws {
|
|
self.init(unsafeFromRawPointer: try
|
|
|
|
rustCallWithError(FfiConverterTypeBdkError.self) {
|
|
|
|
bdk_1724_Address_new(
|
|
FfiConverterString.lower(`address`), $0)
|
|
})
|
|
}
|
|
|
|
deinit {
|
|
try! rustCall { ffi_bdk_1724_Address_object_free(pointer, $0) }
|
|
}
|
|
|
|
|
|
|
|
|
|
public func `scriptPubkey`() -> Script {
|
|
return try! FfiConverterTypeScript.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_Address_script_pubkey(self.pointer, $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
|
|
}
|
|
|
|
|
|
fileprivate struct FfiConverterTypeAddress: FfiConverter {
|
|
typealias FfiType = UnsafeMutableRawPointer
|
|
typealias SwiftType = Address
|
|
|
|
static func read(from buf: Reader) throws -> Address {
|
|
let v: UInt64 = try buf.readInt()
|
|
// 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!)
|
|
}
|
|
|
|
static func write(_ value: Address, into buf: Writer) {
|
|
// 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`.
|
|
buf.writeInt(UInt64(bitPattern: Int64(Int(bitPattern: lower(value)))))
|
|
}
|
|
|
|
static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Address {
|
|
return Address(unsafeFromRawPointer: pointer)
|
|
}
|
|
|
|
static func lower(_ value: Address) -> UnsafeMutableRawPointer {
|
|
return value.pointer
|
|
}
|
|
}
|
|
|
|
|
|
public protocol BlockchainProtocol {
|
|
func `broadcast`(`psbt`: PartiallySignedBitcoinTransaction) throws
|
|
func `getHeight`() throws -> UInt32
|
|
func `getBlockHash`(`height`: UInt32) throws -> String
|
|
|
|
}
|
|
|
|
public class Blockchain: BlockchainProtocol {
|
|
fileprivate let pointer: UnsafeMutableRawPointer
|
|
|
|
// 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`.
|
|
required init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
|
|
self.pointer = pointer
|
|
}
|
|
public convenience init(`config`: BlockchainConfig) throws {
|
|
self.init(unsafeFromRawPointer: try
|
|
|
|
rustCallWithError(FfiConverterTypeBdkError.self) {
|
|
|
|
bdk_1724_Blockchain_new(
|
|
FfiConverterTypeBlockchainConfig.lower(`config`), $0)
|
|
})
|
|
}
|
|
|
|
deinit {
|
|
try! rustCall { ffi_bdk_1724_Blockchain_object_free(pointer, $0) }
|
|
}
|
|
|
|
|
|
|
|
|
|
public func `broadcast`(`psbt`: PartiallySignedBitcoinTransaction) throws {
|
|
try
|
|
rustCallWithError(FfiConverterTypeBdkError.self) {
|
|
bdk_1724_Blockchain_broadcast(self.pointer,
|
|
FfiConverterTypePartiallySignedBitcoinTransaction.lower(`psbt`), $0
|
|
)
|
|
}
|
|
}
|
|
public func `getHeight`() throws -> UInt32 {
|
|
return try FfiConverterUInt32.lift(
|
|
try
|
|
rustCallWithError(FfiConverterTypeBdkError.self) {
|
|
bdk_1724_Blockchain_get_height(self.pointer, $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `getBlockHash`(`height`: UInt32) throws -> String {
|
|
return try FfiConverterString.lift(
|
|
try
|
|
rustCallWithError(FfiConverterTypeBdkError.self) {
|
|
bdk_1724_Blockchain_get_block_hash(self.pointer,
|
|
FfiConverterUInt32.lower(`height`), $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
|
|
}
|
|
|
|
|
|
fileprivate struct FfiConverterTypeBlockchain: FfiConverter {
|
|
typealias FfiType = UnsafeMutableRawPointer
|
|
typealias SwiftType = Blockchain
|
|
|
|
static func read(from buf: Reader) throws -> Blockchain {
|
|
let v: UInt64 = try buf.readInt()
|
|
// 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!)
|
|
}
|
|
|
|
static func write(_ value: Blockchain, into buf: Writer) {
|
|
// 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`.
|
|
buf.writeInt(UInt64(bitPattern: Int64(Int(bitPattern: lower(value)))))
|
|
}
|
|
|
|
static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Blockchain {
|
|
return Blockchain(unsafeFromRawPointer: pointer)
|
|
}
|
|
|
|
static func lower(_ value: Blockchain) -> UnsafeMutableRawPointer {
|
|
return value.pointer
|
|
}
|
|
}
|
|
|
|
|
|
public protocol BumpFeeTxBuilderProtocol {
|
|
func `allowShrinking`(`address`: String) -> BumpFeeTxBuilder
|
|
func `enableRbf`() -> BumpFeeTxBuilder
|
|
func `enableRbfWithSequence`(`nsequence`: UInt32) -> BumpFeeTxBuilder
|
|
func `finish`(`wallet`: Wallet) throws -> PartiallySignedBitcoinTransaction
|
|
|
|
}
|
|
|
|
public class BumpFeeTxBuilder: BumpFeeTxBuilderProtocol {
|
|
fileprivate let pointer: UnsafeMutableRawPointer
|
|
|
|
// 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`.
|
|
required init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
|
|
self.pointer = pointer
|
|
}
|
|
public convenience init(`txid`: String, `newFeeRate`: Float) {
|
|
self.init(unsafeFromRawPointer: try!
|
|
|
|
rustCall() {
|
|
|
|
bdk_1724_BumpFeeTxBuilder_new(
|
|
FfiConverterString.lower(`txid`),
|
|
FfiConverterFloat.lower(`newFeeRate`), $0)
|
|
})
|
|
}
|
|
|
|
deinit {
|
|
try! rustCall { ffi_bdk_1724_BumpFeeTxBuilder_object_free(pointer, $0) }
|
|
}
|
|
|
|
|
|
|
|
|
|
public func `allowShrinking`(`address`: String) -> BumpFeeTxBuilder {
|
|
return try! FfiConverterTypeBumpFeeTxBuilder.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_BumpFeeTxBuilder_allow_shrinking(self.pointer,
|
|
FfiConverterString.lower(`address`), $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `enableRbf`() -> BumpFeeTxBuilder {
|
|
return try! FfiConverterTypeBumpFeeTxBuilder.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_BumpFeeTxBuilder_enable_rbf(self.pointer, $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `enableRbfWithSequence`(`nsequence`: UInt32) -> BumpFeeTxBuilder {
|
|
return try! FfiConverterTypeBumpFeeTxBuilder.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_BumpFeeTxBuilder_enable_rbf_with_sequence(self.pointer,
|
|
FfiConverterUInt32.lower(`nsequence`), $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `finish`(`wallet`: Wallet) throws -> PartiallySignedBitcoinTransaction {
|
|
return try FfiConverterTypePartiallySignedBitcoinTransaction.lift(
|
|
try
|
|
rustCallWithError(FfiConverterTypeBdkError.self) {
|
|
bdk_1724_BumpFeeTxBuilder_finish(self.pointer,
|
|
FfiConverterTypeWallet.lower(`wallet`), $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
|
|
}
|
|
|
|
|
|
fileprivate struct FfiConverterTypeBumpFeeTxBuilder: FfiConverter {
|
|
typealias FfiType = UnsafeMutableRawPointer
|
|
typealias SwiftType = BumpFeeTxBuilder
|
|
|
|
static func read(from buf: Reader) throws -> BumpFeeTxBuilder {
|
|
let v: UInt64 = try buf.readInt()
|
|
// 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!)
|
|
}
|
|
|
|
static func write(_ value: BumpFeeTxBuilder, into buf: Writer) {
|
|
// 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`.
|
|
buf.writeInt(UInt64(bitPattern: Int64(Int(bitPattern: lower(value)))))
|
|
}
|
|
|
|
static func lift(_ pointer: UnsafeMutableRawPointer) throws -> BumpFeeTxBuilder {
|
|
return BumpFeeTxBuilder(unsafeFromRawPointer: pointer)
|
|
}
|
|
|
|
static func lower(_ value: BumpFeeTxBuilder) -> UnsafeMutableRawPointer {
|
|
return value.pointer
|
|
}
|
|
}
|
|
|
|
|
|
public protocol DerivationPathProtocol {
|
|
|
|
}
|
|
|
|
public class DerivationPath: DerivationPathProtocol {
|
|
fileprivate let pointer: UnsafeMutableRawPointer
|
|
|
|
// 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`.
|
|
required init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
|
|
self.pointer = pointer
|
|
}
|
|
public convenience init(`path`: String) throws {
|
|
self.init(unsafeFromRawPointer: try
|
|
|
|
rustCallWithError(FfiConverterTypeBdkError.self) {
|
|
|
|
bdk_1724_DerivationPath_new(
|
|
FfiConverterString.lower(`path`), $0)
|
|
})
|
|
}
|
|
|
|
deinit {
|
|
try! rustCall { ffi_bdk_1724_DerivationPath_object_free(pointer, $0) }
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
fileprivate struct FfiConverterTypeDerivationPath: FfiConverter {
|
|
typealias FfiType = UnsafeMutableRawPointer
|
|
typealias SwiftType = DerivationPath
|
|
|
|
static func read(from buf: Reader) throws -> DerivationPath {
|
|
let v: UInt64 = try buf.readInt()
|
|
// 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!)
|
|
}
|
|
|
|
static func write(_ value: DerivationPath, into buf: Writer) {
|
|
// 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`.
|
|
buf.writeInt(UInt64(bitPattern: Int64(Int(bitPattern: lower(value)))))
|
|
}
|
|
|
|
static func lift(_ pointer: UnsafeMutableRawPointer) throws -> DerivationPath {
|
|
return DerivationPath(unsafeFromRawPointer: pointer)
|
|
}
|
|
|
|
static func lower(_ value: DerivationPath) -> UnsafeMutableRawPointer {
|
|
return value.pointer
|
|
}
|
|
}
|
|
|
|
|
|
public protocol DescriptorPublicKeyProtocol {
|
|
func `derive`(`path`: DerivationPath) throws -> DescriptorPublicKey
|
|
func `extend`(`path`: DerivationPath) -> DescriptorPublicKey
|
|
func `asString`() -> String
|
|
|
|
}
|
|
|
|
public class DescriptorPublicKey: DescriptorPublicKeyProtocol {
|
|
fileprivate let pointer: UnsafeMutableRawPointer
|
|
|
|
// 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`.
|
|
required init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
|
|
self.pointer = pointer
|
|
}
|
|
|
|
deinit {
|
|
try! rustCall { ffi_bdk_1724_DescriptorPublicKey_object_free(pointer, $0) }
|
|
}
|
|
|
|
|
|
|
|
|
|
public func `derive`(`path`: DerivationPath) throws -> DescriptorPublicKey {
|
|
return try FfiConverterTypeDescriptorPublicKey.lift(
|
|
try
|
|
rustCallWithError(FfiConverterTypeBdkError.self) {
|
|
bdk_1724_DescriptorPublicKey_derive(self.pointer,
|
|
FfiConverterTypeDerivationPath.lower(`path`), $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `extend`(`path`: DerivationPath) -> DescriptorPublicKey {
|
|
return try! FfiConverterTypeDescriptorPublicKey.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_DescriptorPublicKey_extend(self.pointer,
|
|
FfiConverterTypeDerivationPath.lower(`path`), $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `asString`() -> String {
|
|
return try! FfiConverterString.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_DescriptorPublicKey_as_string(self.pointer, $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
|
|
}
|
|
|
|
|
|
fileprivate struct FfiConverterTypeDescriptorPublicKey: FfiConverter {
|
|
typealias FfiType = UnsafeMutableRawPointer
|
|
typealias SwiftType = DescriptorPublicKey
|
|
|
|
static func read(from buf: Reader) throws -> DescriptorPublicKey {
|
|
let v: UInt64 = try buf.readInt()
|
|
// 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!)
|
|
}
|
|
|
|
static func write(_ value: DescriptorPublicKey, into buf: Writer) {
|
|
// 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`.
|
|
buf.writeInt(UInt64(bitPattern: Int64(Int(bitPattern: lower(value)))))
|
|
}
|
|
|
|
static func lift(_ pointer: UnsafeMutableRawPointer) throws -> DescriptorPublicKey {
|
|
return DescriptorPublicKey(unsafeFromRawPointer: pointer)
|
|
}
|
|
|
|
static func lower(_ value: DescriptorPublicKey) -> UnsafeMutableRawPointer {
|
|
return value.pointer
|
|
}
|
|
}
|
|
|
|
|
|
public protocol DescriptorSecretKeyProtocol {
|
|
func `derive`(`path`: DerivationPath) throws -> DescriptorSecretKey
|
|
func `extend`(`path`: DerivationPath) -> DescriptorSecretKey
|
|
func `asPublic`() -> DescriptorPublicKey
|
|
func `secretBytes`() -> [UInt8]
|
|
func `asString`() -> String
|
|
|
|
}
|
|
|
|
public class DescriptorSecretKey: DescriptorSecretKeyProtocol {
|
|
fileprivate let pointer: UnsafeMutableRawPointer
|
|
|
|
// 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`.
|
|
required init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
|
|
self.pointer = pointer
|
|
}
|
|
public convenience init(`network`: Network, `mnemonic`: String, `password`: String?) throws {
|
|
self.init(unsafeFromRawPointer: try
|
|
|
|
rustCallWithError(FfiConverterTypeBdkError.self) {
|
|
|
|
bdk_1724_DescriptorSecretKey_new(
|
|
FfiConverterTypeNetwork.lower(`network`),
|
|
FfiConverterString.lower(`mnemonic`),
|
|
FfiConverterOptionString.lower(`password`), $0)
|
|
})
|
|
}
|
|
|
|
deinit {
|
|
try! rustCall { ffi_bdk_1724_DescriptorSecretKey_object_free(pointer, $0) }
|
|
}
|
|
|
|
|
|
|
|
|
|
public func `derive`(`path`: DerivationPath) throws -> DescriptorSecretKey {
|
|
return try FfiConverterTypeDescriptorSecretKey.lift(
|
|
try
|
|
rustCallWithError(FfiConverterTypeBdkError.self) {
|
|
bdk_1724_DescriptorSecretKey_derive(self.pointer,
|
|
FfiConverterTypeDerivationPath.lower(`path`), $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `extend`(`path`: DerivationPath) -> DescriptorSecretKey {
|
|
return try! FfiConverterTypeDescriptorSecretKey.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_DescriptorSecretKey_extend(self.pointer,
|
|
FfiConverterTypeDerivationPath.lower(`path`), $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `asPublic`() -> DescriptorPublicKey {
|
|
return try! FfiConverterTypeDescriptorPublicKey.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_DescriptorSecretKey_as_public(self.pointer, $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `secretBytes`() -> [UInt8] {
|
|
return try! FfiConverterSequenceUInt8.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_DescriptorSecretKey_secret_bytes(self.pointer, $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `asString`() -> String {
|
|
return try! FfiConverterString.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_DescriptorSecretKey_as_string(self.pointer, $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
|
|
}
|
|
|
|
|
|
fileprivate struct FfiConverterTypeDescriptorSecretKey: FfiConverter {
|
|
typealias FfiType = UnsafeMutableRawPointer
|
|
typealias SwiftType = DescriptorSecretKey
|
|
|
|
static func read(from buf: Reader) throws -> DescriptorSecretKey {
|
|
let v: UInt64 = try buf.readInt()
|
|
// 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!)
|
|
}
|
|
|
|
static func write(_ value: DescriptorSecretKey, into buf: Writer) {
|
|
// 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`.
|
|
buf.writeInt(UInt64(bitPattern: Int64(Int(bitPattern: lower(value)))))
|
|
}
|
|
|
|
static func lift(_ pointer: UnsafeMutableRawPointer) throws -> DescriptorSecretKey {
|
|
return DescriptorSecretKey(unsafeFromRawPointer: pointer)
|
|
}
|
|
|
|
static func lower(_ value: DescriptorSecretKey) -> UnsafeMutableRawPointer {
|
|
return value.pointer
|
|
}
|
|
}
|
|
|
|
|
|
public protocol PartiallySignedBitcoinTransactionProtocol {
|
|
func `serialize`() -> String
|
|
func `txid`() -> String
|
|
func `extractTx`() -> [UInt8]
|
|
func `combine`(`other`: PartiallySignedBitcoinTransaction) throws -> PartiallySignedBitcoinTransaction
|
|
|
|
}
|
|
|
|
public class PartiallySignedBitcoinTransaction: PartiallySignedBitcoinTransactionProtocol {
|
|
fileprivate let pointer: UnsafeMutableRawPointer
|
|
|
|
// 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`.
|
|
required init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
|
|
self.pointer = pointer
|
|
}
|
|
public convenience init(`psbtBase64`: String) throws {
|
|
self.init(unsafeFromRawPointer: try
|
|
|
|
rustCallWithError(FfiConverterTypeBdkError.self) {
|
|
|
|
bdk_1724_PartiallySignedBitcoinTransaction_new(
|
|
FfiConverterString.lower(`psbtBase64`), $0)
|
|
})
|
|
}
|
|
|
|
deinit {
|
|
try! rustCall { ffi_bdk_1724_PartiallySignedBitcoinTransaction_object_free(pointer, $0) }
|
|
}
|
|
|
|
|
|
|
|
|
|
public func `serialize`() -> String {
|
|
return try! FfiConverterString.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_PartiallySignedBitcoinTransaction_serialize(self.pointer, $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `txid`() -> String {
|
|
return try! FfiConverterString.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_PartiallySignedBitcoinTransaction_txid(self.pointer, $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `extractTx`() -> [UInt8] {
|
|
return try! FfiConverterSequenceUInt8.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_PartiallySignedBitcoinTransaction_extract_tx(self.pointer, $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `combine`(`other`: PartiallySignedBitcoinTransaction) throws -> PartiallySignedBitcoinTransaction {
|
|
return try FfiConverterTypePartiallySignedBitcoinTransaction.lift(
|
|
try
|
|
rustCallWithError(FfiConverterTypeBdkError.self) {
|
|
bdk_1724_PartiallySignedBitcoinTransaction_combine(self.pointer,
|
|
FfiConverterTypePartiallySignedBitcoinTransaction.lower(`other`), $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
|
|
}
|
|
|
|
|
|
fileprivate struct FfiConverterTypePartiallySignedBitcoinTransaction: FfiConverter {
|
|
typealias FfiType = UnsafeMutableRawPointer
|
|
typealias SwiftType = PartiallySignedBitcoinTransaction
|
|
|
|
static func read(from buf: Reader) throws -> PartiallySignedBitcoinTransaction {
|
|
let v: UInt64 = try buf.readInt()
|
|
// 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!)
|
|
}
|
|
|
|
static func write(_ value: PartiallySignedBitcoinTransaction, into buf: Writer) {
|
|
// 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`.
|
|
buf.writeInt(UInt64(bitPattern: Int64(Int(bitPattern: lower(value)))))
|
|
}
|
|
|
|
static func lift(_ pointer: UnsafeMutableRawPointer) throws -> PartiallySignedBitcoinTransaction {
|
|
return PartiallySignedBitcoinTransaction(unsafeFromRawPointer: pointer)
|
|
}
|
|
|
|
static func lower(_ value: PartiallySignedBitcoinTransaction) -> UnsafeMutableRawPointer {
|
|
return value.pointer
|
|
}
|
|
}
|
|
|
|
|
|
public protocol ScriptProtocol {
|
|
|
|
}
|
|
|
|
public class Script: ScriptProtocol {
|
|
fileprivate let pointer: UnsafeMutableRawPointer
|
|
|
|
// 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`.
|
|
required init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
|
|
self.pointer = pointer
|
|
}
|
|
public convenience init(`rawOutputScript`: [UInt8]) {
|
|
self.init(unsafeFromRawPointer: try!
|
|
|
|
rustCall() {
|
|
|
|
bdk_1724_Script_new(
|
|
FfiConverterSequenceUInt8.lower(`rawOutputScript`), $0)
|
|
})
|
|
}
|
|
|
|
deinit {
|
|
try! rustCall { ffi_bdk_1724_Script_object_free(pointer, $0) }
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
fileprivate struct FfiConverterTypeScript: FfiConverter {
|
|
typealias FfiType = UnsafeMutableRawPointer
|
|
typealias SwiftType = Script
|
|
|
|
static func read(from buf: Reader) throws -> Script {
|
|
let v: UInt64 = try buf.readInt()
|
|
// 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!)
|
|
}
|
|
|
|
static func write(_ value: Script, into buf: Writer) {
|
|
// 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`.
|
|
buf.writeInt(UInt64(bitPattern: Int64(Int(bitPattern: lower(value)))))
|
|
}
|
|
|
|
static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Script {
|
|
return Script(unsafeFromRawPointer: pointer)
|
|
}
|
|
|
|
static func lower(_ value: Script) -> UnsafeMutableRawPointer {
|
|
return value.pointer
|
|
}
|
|
}
|
|
|
|
|
|
public protocol TxBuilderProtocol {
|
|
func `addRecipient`(`script`: Script, `amount`: UInt64) -> TxBuilder
|
|
func `addUnspendable`(`unspendable`: OutPoint) -> TxBuilder
|
|
func `addUtxo`(`outpoint`: OutPoint) -> TxBuilder
|
|
func `addUtxos`(`outpoints`: [OutPoint]) -> TxBuilder
|
|
func `doNotSpendChange`() -> TxBuilder
|
|
func `manuallySelectedOnly`() -> TxBuilder
|
|
func `onlySpendChange`() -> TxBuilder
|
|
func `unspendable`(`unspendable`: [OutPoint]) -> TxBuilder
|
|
func `feeRate`(`satPerVbyte`: Float) -> TxBuilder
|
|
func `feeAbsolute`(`feeAmount`: UInt64) -> TxBuilder
|
|
func `drainWallet`() -> TxBuilder
|
|
func `drainTo`(`address`: String) -> TxBuilder
|
|
func `enableRbf`() -> TxBuilder
|
|
func `enableRbfWithSequence`(`nsequence`: UInt32) -> TxBuilder
|
|
func `addData`(`data`: [UInt8]) -> TxBuilder
|
|
func `setRecipients`(`recipients`: [ScriptAmount]) -> TxBuilder
|
|
func `finish`(`wallet`: Wallet) throws -> TxBuilderResult
|
|
|
|
}
|
|
|
|
public class TxBuilder: TxBuilderProtocol {
|
|
fileprivate let pointer: UnsafeMutableRawPointer
|
|
|
|
// 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`.
|
|
required init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
|
|
self.pointer = pointer
|
|
}
|
|
public convenience init() {
|
|
self.init(unsafeFromRawPointer: try!
|
|
|
|
rustCall() {
|
|
|
|
bdk_1724_TxBuilder_new($0)
|
|
})
|
|
}
|
|
|
|
deinit {
|
|
try! rustCall { ffi_bdk_1724_TxBuilder_object_free(pointer, $0) }
|
|
}
|
|
|
|
|
|
|
|
|
|
public func `addRecipient`(`script`: Script, `amount`: UInt64) -> TxBuilder {
|
|
return try! FfiConverterTypeTxBuilder.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_TxBuilder_add_recipient(self.pointer,
|
|
FfiConverterTypeScript.lower(`script`),
|
|
FfiConverterUInt64.lower(`amount`), $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `addUnspendable`(`unspendable`: OutPoint) -> TxBuilder {
|
|
return try! FfiConverterTypeTxBuilder.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_TxBuilder_add_unspendable(self.pointer,
|
|
FfiConverterTypeOutPoint.lower(`unspendable`), $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `addUtxo`(`outpoint`: OutPoint) -> TxBuilder {
|
|
return try! FfiConverterTypeTxBuilder.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_TxBuilder_add_utxo(self.pointer,
|
|
FfiConverterTypeOutPoint.lower(`outpoint`), $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `addUtxos`(`outpoints`: [OutPoint]) -> TxBuilder {
|
|
return try! FfiConverterTypeTxBuilder.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_TxBuilder_add_utxos(self.pointer,
|
|
FfiConverterSequenceTypeOutPoint.lower(`outpoints`), $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `doNotSpendChange`() -> TxBuilder {
|
|
return try! FfiConverterTypeTxBuilder.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_TxBuilder_do_not_spend_change(self.pointer, $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `manuallySelectedOnly`() -> TxBuilder {
|
|
return try! FfiConverterTypeTxBuilder.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_TxBuilder_manually_selected_only(self.pointer, $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `onlySpendChange`() -> TxBuilder {
|
|
return try! FfiConverterTypeTxBuilder.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_TxBuilder_only_spend_change(self.pointer, $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `unspendable`(`unspendable`: [OutPoint]) -> TxBuilder {
|
|
return try! FfiConverterTypeTxBuilder.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_TxBuilder_unspendable(self.pointer,
|
|
FfiConverterSequenceTypeOutPoint.lower(`unspendable`), $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `feeRate`(`satPerVbyte`: Float) -> TxBuilder {
|
|
return try! FfiConverterTypeTxBuilder.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_TxBuilder_fee_rate(self.pointer,
|
|
FfiConverterFloat.lower(`satPerVbyte`), $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `feeAbsolute`(`feeAmount`: UInt64) -> TxBuilder {
|
|
return try! FfiConverterTypeTxBuilder.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_TxBuilder_fee_absolute(self.pointer,
|
|
FfiConverterUInt64.lower(`feeAmount`), $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `drainWallet`() -> TxBuilder {
|
|
return try! FfiConverterTypeTxBuilder.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_TxBuilder_drain_wallet(self.pointer, $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `drainTo`(`address`: String) -> TxBuilder {
|
|
return try! FfiConverterTypeTxBuilder.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_TxBuilder_drain_to(self.pointer,
|
|
FfiConverterString.lower(`address`), $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `enableRbf`() -> TxBuilder {
|
|
return try! FfiConverterTypeTxBuilder.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_TxBuilder_enable_rbf(self.pointer, $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `enableRbfWithSequence`(`nsequence`: UInt32) -> TxBuilder {
|
|
return try! FfiConverterTypeTxBuilder.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_TxBuilder_enable_rbf_with_sequence(self.pointer,
|
|
FfiConverterUInt32.lower(`nsequence`), $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `addData`(`data`: [UInt8]) -> TxBuilder {
|
|
return try! FfiConverterTypeTxBuilder.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_TxBuilder_add_data(self.pointer,
|
|
FfiConverterSequenceUInt8.lower(`data`), $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `setRecipients`(`recipients`: [ScriptAmount]) -> TxBuilder {
|
|
return try! FfiConverterTypeTxBuilder.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_TxBuilder_set_recipients(self.pointer,
|
|
FfiConverterSequenceTypeScriptAmount.lower(`recipients`), $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `finish`(`wallet`: Wallet) throws -> TxBuilderResult {
|
|
return try FfiConverterTypeTxBuilderResult.lift(
|
|
try
|
|
rustCallWithError(FfiConverterTypeBdkError.self) {
|
|
bdk_1724_TxBuilder_finish(self.pointer,
|
|
FfiConverterTypeWallet.lower(`wallet`), $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
|
|
}
|
|
|
|
|
|
fileprivate struct FfiConverterTypeTxBuilder: FfiConverter {
|
|
typealias FfiType = UnsafeMutableRawPointer
|
|
typealias SwiftType = TxBuilder
|
|
|
|
static func read(from buf: Reader) throws -> TxBuilder {
|
|
let v: UInt64 = try buf.readInt()
|
|
// 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!)
|
|
}
|
|
|
|
static func write(_ value: TxBuilder, into buf: Writer) {
|
|
// 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`.
|
|
buf.writeInt(UInt64(bitPattern: Int64(Int(bitPattern: lower(value)))))
|
|
}
|
|
|
|
static func lift(_ pointer: UnsafeMutableRawPointer) throws -> TxBuilder {
|
|
return TxBuilder(unsafeFromRawPointer: pointer)
|
|
}
|
|
|
|
static func lower(_ value: TxBuilder) -> UnsafeMutableRawPointer {
|
|
return value.pointer
|
|
}
|
|
}
|
|
|
|
|
|
public protocol WalletProtocol {
|
|
func `getAddress`(`addressIndex`: AddressIndex) throws -> AddressInfo
|
|
func `getBalance`() throws -> Balance
|
|
func `sign`(`psbt`: PartiallySignedBitcoinTransaction) throws -> Bool
|
|
func `listTransactions`() throws -> [TransactionDetails]
|
|
func `network`() -> Network
|
|
func `sync`(`blockchain`: Blockchain, `progress`: Progress?) throws
|
|
func `listUnspent`() throws -> [LocalUtxo]
|
|
|
|
}
|
|
|
|
public class Wallet: WalletProtocol {
|
|
fileprivate let pointer: UnsafeMutableRawPointer
|
|
|
|
// 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`.
|
|
required init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
|
|
self.pointer = pointer
|
|
}
|
|
public convenience init(`descriptor`: String, `changeDescriptor`: String?, `network`: Network, `databaseConfig`: DatabaseConfig) throws {
|
|
self.init(unsafeFromRawPointer: try
|
|
|
|
rustCallWithError(FfiConverterTypeBdkError.self) {
|
|
|
|
bdk_1724_Wallet_new(
|
|
FfiConverterString.lower(`descriptor`),
|
|
FfiConverterOptionString.lower(`changeDescriptor`),
|
|
FfiConverterTypeNetwork.lower(`network`),
|
|
FfiConverterTypeDatabaseConfig.lower(`databaseConfig`), $0)
|
|
})
|
|
}
|
|
|
|
deinit {
|
|
try! rustCall { ffi_bdk_1724_Wallet_object_free(pointer, $0) }
|
|
}
|
|
|
|
|
|
|
|
|
|
public func `getAddress`(`addressIndex`: AddressIndex) throws -> AddressInfo {
|
|
return try FfiConverterTypeAddressInfo.lift(
|
|
try
|
|
rustCallWithError(FfiConverterTypeBdkError.self) {
|
|
bdk_1724_Wallet_get_address(self.pointer,
|
|
FfiConverterTypeAddressIndex.lower(`addressIndex`), $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `getBalance`() throws -> Balance {
|
|
return try FfiConverterTypeBalance.lift(
|
|
try
|
|
rustCallWithError(FfiConverterTypeBdkError.self) {
|
|
bdk_1724_Wallet_get_balance(self.pointer, $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `sign`(`psbt`: PartiallySignedBitcoinTransaction) throws -> Bool {
|
|
return try FfiConverterBool.lift(
|
|
try
|
|
rustCallWithError(FfiConverterTypeBdkError.self) {
|
|
bdk_1724_Wallet_sign(self.pointer,
|
|
FfiConverterTypePartiallySignedBitcoinTransaction.lower(`psbt`), $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `listTransactions`() throws -> [TransactionDetails] {
|
|
return try FfiConverterSequenceTypeTransactionDetails.lift(
|
|
try
|
|
rustCallWithError(FfiConverterTypeBdkError.self) {
|
|
bdk_1724_Wallet_list_transactions(self.pointer, $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `network`() -> Network {
|
|
return try! FfiConverterTypeNetwork.lift(
|
|
try!
|
|
rustCall() {
|
|
|
|
bdk_1724_Wallet_network(self.pointer, $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
public func `sync`(`blockchain`: Blockchain, `progress`: Progress?) throws {
|
|
try
|
|
rustCallWithError(FfiConverterTypeBdkError.self) {
|
|
bdk_1724_Wallet_sync(self.pointer,
|
|
FfiConverterTypeBlockchain.lower(`blockchain`),
|
|
FfiConverterOptionCallbackInterfaceProgress.lower(`progress`), $0
|
|
)
|
|
}
|
|
}
|
|
public func `listUnspent`() throws -> [LocalUtxo] {
|
|
return try FfiConverterSequenceTypeLocalUtxo.lift(
|
|
try
|
|
rustCallWithError(FfiConverterTypeBdkError.self) {
|
|
bdk_1724_Wallet_list_unspent(self.pointer, $0
|
|
)
|
|
}
|
|
)
|
|
}
|
|
|
|
}
|
|
|
|
|
|
fileprivate struct FfiConverterTypeWallet: FfiConverter {
|
|
typealias FfiType = UnsafeMutableRawPointer
|
|
typealias SwiftType = Wallet
|
|
|
|
static func read(from buf: Reader) throws -> Wallet {
|
|
let v: UInt64 = try buf.readInt()
|
|
// 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!)
|
|
}
|
|
|
|
static func write(_ value: Wallet, into buf: Writer) {
|
|
// 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`.
|
|
buf.writeInt(UInt64(bitPattern: Int64(Int(bitPattern: lower(value)))))
|
|
}
|
|
|
|
static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Wallet {
|
|
return Wallet(unsafeFromRawPointer: pointer)
|
|
}
|
|
|
|
static func lower(_ value: Wallet) -> UnsafeMutableRawPointer {
|
|
return value.pointer
|
|
}
|
|
}
|
|
|
|
|
|
public struct AddressInfo {
|
|
public var `index`: UInt32
|
|
public var `address`: String
|
|
|
|
// Default memberwise initializers are never public by default, so we
|
|
// declare one manually.
|
|
public init(`index`: UInt32, `address`: String) {
|
|
self.`index` = `index`
|
|
self.`address` = `address`
|
|
}
|
|
}
|
|
|
|
|
|
extension AddressInfo: Equatable, Hashable {
|
|
public static func ==(lhs: AddressInfo, rhs: AddressInfo) -> Bool {
|
|
if lhs.`index` != rhs.`index` {
|
|
return false
|
|
}
|
|
if lhs.`address` != rhs.`address` {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
public func hash(into hasher: inout Hasher) {
|
|
hasher.combine(`index`)
|
|
hasher.combine(`address`)
|
|
}
|
|
}
|
|
|
|
|
|
fileprivate struct FfiConverterTypeAddressInfo: FfiConverterRustBuffer {
|
|
fileprivate static func read(from buf: Reader) throws -> AddressInfo {
|
|
return try AddressInfo(
|
|
`index`: FfiConverterUInt32.read(from: buf),
|
|
`address`: FfiConverterString.read(from: buf)
|
|
)
|
|
}
|
|
|
|
fileprivate static func write(_ value: AddressInfo, into buf: Writer) {
|
|
FfiConverterUInt32.write(value.`index`, into: buf)
|
|
FfiConverterString.write(value.`address`, into: buf)
|
|
}
|
|
}
|
|
|
|
|
|
public struct Balance {
|
|
public var `immature`: UInt64
|
|
public var `trustedPending`: UInt64
|
|
public var `untrustedPending`: UInt64
|
|
public var `confirmed`: UInt64
|
|
public var `spendable`: UInt64
|
|
public var `total`: UInt64
|
|
|
|
// Default memberwise initializers are never public by default, so we
|
|
// declare one manually.
|
|
public init(`immature`: UInt64, `trustedPending`: UInt64, `untrustedPending`: UInt64, `confirmed`: UInt64, `spendable`: UInt64, `total`: UInt64) {
|
|
self.`immature` = `immature`
|
|
self.`trustedPending` = `trustedPending`
|
|
self.`untrustedPending` = `untrustedPending`
|
|
self.`confirmed` = `confirmed`
|
|
self.`spendable` = `spendable`
|
|
self.`total` = `total`
|
|
}
|
|
}
|
|
|
|
|
|
extension Balance: Equatable, Hashable {
|
|
public static func ==(lhs: Balance, rhs: Balance) -> Bool {
|
|
if lhs.`immature` != rhs.`immature` {
|
|
return false
|
|
}
|
|
if lhs.`trustedPending` != rhs.`trustedPending` {
|
|
return false
|
|
}
|
|
if lhs.`untrustedPending` != rhs.`untrustedPending` {
|
|
return false
|
|
}
|
|
if lhs.`confirmed` != rhs.`confirmed` {
|
|
return false
|
|
}
|
|
if lhs.`spendable` != rhs.`spendable` {
|
|
return false
|
|
}
|
|
if lhs.`total` != rhs.`total` {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
public func hash(into hasher: inout Hasher) {
|
|
hasher.combine(`immature`)
|
|
hasher.combine(`trustedPending`)
|
|
hasher.combine(`untrustedPending`)
|
|
hasher.combine(`confirmed`)
|
|
hasher.combine(`spendable`)
|
|
hasher.combine(`total`)
|
|
}
|
|
}
|
|
|
|
|
|
fileprivate struct FfiConverterTypeBalance: FfiConverterRustBuffer {
|
|
fileprivate static func read(from buf: Reader) throws -> Balance {
|
|
return try Balance(
|
|
`immature`: FfiConverterUInt64.read(from: buf),
|
|
`trustedPending`: FfiConverterUInt64.read(from: buf),
|
|
`untrustedPending`: FfiConverterUInt64.read(from: buf),
|
|
`confirmed`: FfiConverterUInt64.read(from: buf),
|
|
`spendable`: FfiConverterUInt64.read(from: buf),
|
|
`total`: FfiConverterUInt64.read(from: buf)
|
|
)
|
|
}
|
|
|
|
fileprivate static func write(_ value: Balance, into buf: Writer) {
|
|
FfiConverterUInt64.write(value.`immature`, into: buf)
|
|
FfiConverterUInt64.write(value.`trustedPending`, into: buf)
|
|
FfiConverterUInt64.write(value.`untrustedPending`, into: buf)
|
|
FfiConverterUInt64.write(value.`confirmed`, into: buf)
|
|
FfiConverterUInt64.write(value.`spendable`, into: buf)
|
|
FfiConverterUInt64.write(value.`total`, into: buf)
|
|
}
|
|
}
|
|
|
|
|
|
public struct BlockTime {
|
|
public var `height`: UInt32
|
|
public var `timestamp`: UInt64
|
|
|
|
// Default memberwise initializers are never public by default, so we
|
|
// declare one manually.
|
|
public init(`height`: UInt32, `timestamp`: UInt64) {
|
|
self.`height` = `height`
|
|
self.`timestamp` = `timestamp`
|
|
}
|
|
}
|
|
|
|
|
|
extension BlockTime: Equatable, Hashable {
|
|
public static func ==(lhs: BlockTime, rhs: BlockTime) -> Bool {
|
|
if lhs.`height` != rhs.`height` {
|
|
return false
|
|
}
|
|
if lhs.`timestamp` != rhs.`timestamp` {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
public func hash(into hasher: inout Hasher) {
|
|
hasher.combine(`height`)
|
|
hasher.combine(`timestamp`)
|
|
}
|
|
}
|
|
|
|
|
|
fileprivate struct FfiConverterTypeBlockTime: FfiConverterRustBuffer {
|
|
fileprivate static func read(from buf: Reader) throws -> BlockTime {
|
|
return try BlockTime(
|
|
`height`: FfiConverterUInt32.read(from: buf),
|
|
`timestamp`: FfiConverterUInt64.read(from: buf)
|
|
)
|
|
}
|
|
|
|
fileprivate static func write(_ value: BlockTime, into buf: Writer) {
|
|
FfiConverterUInt32.write(value.`height`, into: buf)
|
|
FfiConverterUInt64.write(value.`timestamp`, into: buf)
|
|
}
|
|
}
|
|
|
|
|
|
public struct ElectrumConfig {
|
|
public var `url`: String
|
|
public var `socks5`: String?
|
|
public var `retry`: UInt8
|
|
public var `timeout`: UInt8?
|
|
public var `stopGap`: UInt64
|
|
|
|
// Default memberwise initializers are never public by default, so we
|
|
// declare one manually.
|
|
public init(`url`: String, `socks5`: String?, `retry`: UInt8, `timeout`: UInt8?, `stopGap`: UInt64) {
|
|
self.`url` = `url`
|
|
self.`socks5` = `socks5`
|
|
self.`retry` = `retry`
|
|
self.`timeout` = `timeout`
|
|
self.`stopGap` = `stopGap`
|
|
}
|
|
}
|
|
|
|
|
|
extension ElectrumConfig: Equatable, Hashable {
|
|
public static func ==(lhs: ElectrumConfig, rhs: ElectrumConfig) -> Bool {
|
|
if lhs.`url` != rhs.`url` {
|
|
return false
|
|
}
|
|
if lhs.`socks5` != rhs.`socks5` {
|
|
return false
|
|
}
|
|
if lhs.`retry` != rhs.`retry` {
|
|
return false
|
|
}
|
|
if lhs.`timeout` != rhs.`timeout` {
|
|
return false
|
|
}
|
|
if lhs.`stopGap` != rhs.`stopGap` {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
public func hash(into hasher: inout Hasher) {
|
|
hasher.combine(`url`)
|
|
hasher.combine(`socks5`)
|
|
hasher.combine(`retry`)
|
|
hasher.combine(`timeout`)
|
|
hasher.combine(`stopGap`)
|
|
}
|
|
}
|
|
|
|
|
|
fileprivate struct FfiConverterTypeElectrumConfig: FfiConverterRustBuffer {
|
|
fileprivate static func read(from buf: Reader) throws -> ElectrumConfig {
|
|
return try ElectrumConfig(
|
|
`url`: FfiConverterString.read(from: buf),
|
|
`socks5`: FfiConverterOptionString.read(from: buf),
|
|
`retry`: FfiConverterUInt8.read(from: buf),
|
|
`timeout`: FfiConverterOptionUInt8.read(from: buf),
|
|
`stopGap`: FfiConverterUInt64.read(from: buf)
|
|
)
|
|
}
|
|
|
|
fileprivate static func write(_ value: ElectrumConfig, into buf: Writer) {
|
|
FfiConverterString.write(value.`url`, into: buf)
|
|
FfiConverterOptionString.write(value.`socks5`, into: buf)
|
|
FfiConverterUInt8.write(value.`retry`, into: buf)
|
|
FfiConverterOptionUInt8.write(value.`timeout`, into: buf)
|
|
FfiConverterUInt64.write(value.`stopGap`, into: buf)
|
|
}
|
|
}
|
|
|
|
|
|
public struct EsploraConfig {
|
|
public var `baseUrl`: String
|
|
public var `proxy`: String?
|
|
public var `concurrency`: UInt8?
|
|
public var `stopGap`: UInt64
|
|
public var `timeout`: UInt64?
|
|
|
|
// Default memberwise initializers are never public by default, so we
|
|
// declare one manually.
|
|
public init(`baseUrl`: String, `proxy`: String?, `concurrency`: UInt8?, `stopGap`: UInt64, `timeout`: UInt64?) {
|
|
self.`baseUrl` = `baseUrl`
|
|
self.`proxy` = `proxy`
|
|
self.`concurrency` = `concurrency`
|
|
self.`stopGap` = `stopGap`
|
|
self.`timeout` = `timeout`
|
|
}
|
|
}
|
|
|
|
|
|
extension EsploraConfig: Equatable, Hashable {
|
|
public static func ==(lhs: EsploraConfig, rhs: EsploraConfig) -> Bool {
|
|
if lhs.`baseUrl` != rhs.`baseUrl` {
|
|
return false
|
|
}
|
|
if lhs.`proxy` != rhs.`proxy` {
|
|
return false
|
|
}
|
|
if lhs.`concurrency` != rhs.`concurrency` {
|
|
return false
|
|
}
|
|
if lhs.`stopGap` != rhs.`stopGap` {
|
|
return false
|
|
}
|
|
if lhs.`timeout` != rhs.`timeout` {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
public func hash(into hasher: inout Hasher) {
|
|
hasher.combine(`baseUrl`)
|
|
hasher.combine(`proxy`)
|
|
hasher.combine(`concurrency`)
|
|
hasher.combine(`stopGap`)
|
|
hasher.combine(`timeout`)
|
|
}
|
|
}
|
|
|
|
|
|
fileprivate struct FfiConverterTypeEsploraConfig: FfiConverterRustBuffer {
|
|
fileprivate static func read(from buf: Reader) throws -> EsploraConfig {
|
|
return try EsploraConfig(
|
|
`baseUrl`: FfiConverterString.read(from: buf),
|
|
`proxy`: FfiConverterOptionString.read(from: buf),
|
|
`concurrency`: FfiConverterOptionUInt8.read(from: buf),
|
|
`stopGap`: FfiConverterUInt64.read(from: buf),
|
|
`timeout`: FfiConverterOptionUInt64.read(from: buf)
|
|
)
|
|
}
|
|
|
|
fileprivate static func write(_ value: EsploraConfig, into buf: Writer) {
|
|
FfiConverterString.write(value.`baseUrl`, into: buf)
|
|
FfiConverterOptionString.write(value.`proxy`, into: buf)
|
|
FfiConverterOptionUInt8.write(value.`concurrency`, into: buf)
|
|
FfiConverterUInt64.write(value.`stopGap`, into: buf)
|
|
FfiConverterOptionUInt64.write(value.`timeout`, into: buf)
|
|
}
|
|
}
|
|
|
|
|
|
public struct LocalUtxo {
|
|
public var `outpoint`: OutPoint
|
|
public var `txout`: TxOut
|
|
public var `keychain`: KeychainKind
|
|
public var `isSpent`: Bool
|
|
|
|
// Default memberwise initializers are never public by default, so we
|
|
// declare one manually.
|
|
public init(`outpoint`: OutPoint, `txout`: TxOut, `keychain`: KeychainKind, `isSpent`: Bool) {
|
|
self.`outpoint` = `outpoint`
|
|
self.`txout` = `txout`
|
|
self.`keychain` = `keychain`
|
|
self.`isSpent` = `isSpent`
|
|
}
|
|
}
|
|
|
|
|
|
extension LocalUtxo: Equatable, Hashable {
|
|
public static func ==(lhs: LocalUtxo, rhs: LocalUtxo) -> Bool {
|
|
if lhs.`outpoint` != rhs.`outpoint` {
|
|
return false
|
|
}
|
|
if lhs.`txout` != rhs.`txout` {
|
|
return false
|
|
}
|
|
if lhs.`keychain` != rhs.`keychain` {
|
|
return false
|
|
}
|
|
if lhs.`isSpent` != rhs.`isSpent` {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
public func hash(into hasher: inout Hasher) {
|
|
hasher.combine(`outpoint`)
|
|
hasher.combine(`txout`)
|
|
hasher.combine(`keychain`)
|
|
hasher.combine(`isSpent`)
|
|
}
|
|
}
|
|
|
|
|
|
fileprivate struct FfiConverterTypeLocalUtxo: FfiConverterRustBuffer {
|
|
fileprivate static func read(from buf: Reader) throws -> LocalUtxo {
|
|
return try LocalUtxo(
|
|
`outpoint`: FfiConverterTypeOutPoint.read(from: buf),
|
|
`txout`: FfiConverterTypeTxOut.read(from: buf),
|
|
`keychain`: FfiConverterTypeKeychainKind.read(from: buf),
|
|
`isSpent`: FfiConverterBool.read(from: buf)
|
|
)
|
|
}
|
|
|
|
fileprivate static func write(_ value: LocalUtxo, into buf: Writer) {
|
|
FfiConverterTypeOutPoint.write(value.`outpoint`, into: buf)
|
|
FfiConverterTypeTxOut.write(value.`txout`, into: buf)
|
|
FfiConverterTypeKeychainKind.write(value.`keychain`, into: buf)
|
|
FfiConverterBool.write(value.`isSpent`, into: buf)
|
|
}
|
|
}
|
|
|
|
|
|
public struct OutPoint {
|
|
public var `txid`: String
|
|
public var `vout`: UInt32
|
|
|
|
// Default memberwise initializers are never public by default, so we
|
|
// declare one manually.
|
|
public init(`txid`: String, `vout`: UInt32) {
|
|
self.`txid` = `txid`
|
|
self.`vout` = `vout`
|
|
}
|
|
}
|
|
|
|
|
|
extension OutPoint: Equatable, Hashable {
|
|
public static func ==(lhs: OutPoint, rhs: OutPoint) -> Bool {
|
|
if lhs.`txid` != rhs.`txid` {
|
|
return false
|
|
}
|
|
if lhs.`vout` != rhs.`vout` {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
public func hash(into hasher: inout Hasher) {
|
|
hasher.combine(`txid`)
|
|
hasher.combine(`vout`)
|
|
}
|
|
}
|
|
|
|
|
|
fileprivate struct FfiConverterTypeOutPoint: FfiConverterRustBuffer {
|
|
fileprivate static func read(from buf: Reader) throws -> OutPoint {
|
|
return try OutPoint(
|
|
`txid`: FfiConverterString.read(from: buf),
|
|
`vout`: FfiConverterUInt32.read(from: buf)
|
|
)
|
|
}
|
|
|
|
fileprivate static func write(_ value: OutPoint, into buf: Writer) {
|
|
FfiConverterString.write(value.`txid`, into: buf)
|
|
FfiConverterUInt32.write(value.`vout`, into: buf)
|
|
}
|
|
}
|
|
|
|
|
|
public struct ScriptAmount {
|
|
public var `script`: Script
|
|
public var `amount`: UInt64
|
|
|
|
// Default memberwise initializers are never public by default, so we
|
|
// declare one manually.
|
|
public init(`script`: Script, `amount`: UInt64) {
|
|
self.`script` = `script`
|
|
self.`amount` = `amount`
|
|
}
|
|
}
|
|
|
|
|
|
|
|
fileprivate struct FfiConverterTypeScriptAmount: FfiConverterRustBuffer {
|
|
fileprivate static func read(from buf: Reader) throws -> ScriptAmount {
|
|
return try ScriptAmount(
|
|
`script`: FfiConverterTypeScript.read(from: buf),
|
|
`amount`: FfiConverterUInt64.read(from: buf)
|
|
)
|
|
}
|
|
|
|
fileprivate static func write(_ value: ScriptAmount, into buf: Writer) {
|
|
FfiConverterTypeScript.write(value.`script`, into: buf)
|
|
FfiConverterUInt64.write(value.`amount`, into: buf)
|
|
}
|
|
}
|
|
|
|
|
|
public struct SledDbConfiguration {
|
|
public var `path`: String
|
|
public var `treeName`: String
|
|
|
|
// Default memberwise initializers are never public by default, so we
|
|
// declare one manually.
|
|
public init(`path`: String, `treeName`: String) {
|
|
self.`path` = `path`
|
|
self.`treeName` = `treeName`
|
|
}
|
|
}
|
|
|
|
|
|
extension SledDbConfiguration: Equatable, Hashable {
|
|
public static func ==(lhs: SledDbConfiguration, rhs: SledDbConfiguration) -> Bool {
|
|
if lhs.`path` != rhs.`path` {
|
|
return false
|
|
}
|
|
if lhs.`treeName` != rhs.`treeName` {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
public func hash(into hasher: inout Hasher) {
|
|
hasher.combine(`path`)
|
|
hasher.combine(`treeName`)
|
|
}
|
|
}
|
|
|
|
|
|
fileprivate struct FfiConverterTypeSledDbConfiguration: FfiConverterRustBuffer {
|
|
fileprivate static func read(from buf: Reader) throws -> SledDbConfiguration {
|
|
return try SledDbConfiguration(
|
|
`path`: FfiConverterString.read(from: buf),
|
|
`treeName`: FfiConverterString.read(from: buf)
|
|
)
|
|
}
|
|
|
|
fileprivate static func write(_ value: SledDbConfiguration, into buf: Writer) {
|
|
FfiConverterString.write(value.`path`, into: buf)
|
|
FfiConverterString.write(value.`treeName`, into: buf)
|
|
}
|
|
}
|
|
|
|
|
|
public struct SqliteDbConfiguration {
|
|
public var `path`: String
|
|
|
|
// Default memberwise initializers are never public by default, so we
|
|
// declare one manually.
|
|
public init(`path`: String) {
|
|
self.`path` = `path`
|
|
}
|
|
}
|
|
|
|
|
|
extension SqliteDbConfiguration: Equatable, Hashable {
|
|
public static func ==(lhs: SqliteDbConfiguration, rhs: SqliteDbConfiguration) -> Bool {
|
|
if lhs.`path` != rhs.`path` {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
public func hash(into hasher: inout Hasher) {
|
|
hasher.combine(`path`)
|
|
}
|
|
}
|
|
|
|
|
|
fileprivate struct FfiConverterTypeSqliteDbConfiguration: FfiConverterRustBuffer {
|
|
fileprivate static func read(from buf: Reader) throws -> SqliteDbConfiguration {
|
|
return try SqliteDbConfiguration(
|
|
`path`: FfiConverterString.read(from: buf)
|
|
)
|
|
}
|
|
|
|
fileprivate static func write(_ value: SqliteDbConfiguration, into buf: Writer) {
|
|
FfiConverterString.write(value.`path`, into: buf)
|
|
}
|
|
}
|
|
|
|
|
|
public struct TransactionDetails {
|
|
public var `fee`: UInt64?
|
|
public var `received`: UInt64
|
|
public var `sent`: UInt64
|
|
public var `txid`: String
|
|
public var `confirmationTime`: BlockTime?
|
|
|
|
// Default memberwise initializers are never public by default, so we
|
|
// declare one manually.
|
|
public init(`fee`: UInt64?, `received`: UInt64, `sent`: UInt64, `txid`: String, `confirmationTime`: BlockTime?) {
|
|
self.`fee` = `fee`
|
|
self.`received` = `received`
|
|
self.`sent` = `sent`
|
|
self.`txid` = `txid`
|
|
self.`confirmationTime` = `confirmationTime`
|
|
}
|
|
}
|
|
|
|
|
|
extension TransactionDetails: Equatable, Hashable {
|
|
public static func ==(lhs: TransactionDetails, rhs: TransactionDetails) -> Bool {
|
|
if lhs.`fee` != rhs.`fee` {
|
|
return false
|
|
}
|
|
if lhs.`received` != rhs.`received` {
|
|
return false
|
|
}
|
|
if lhs.`sent` != rhs.`sent` {
|
|
return false
|
|
}
|
|
if lhs.`txid` != rhs.`txid` {
|
|
return false
|
|
}
|
|
if lhs.`confirmationTime` != rhs.`confirmationTime` {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
public func hash(into hasher: inout Hasher) {
|
|
hasher.combine(`fee`)
|
|
hasher.combine(`received`)
|
|
hasher.combine(`sent`)
|
|
hasher.combine(`txid`)
|
|
hasher.combine(`confirmationTime`)
|
|
}
|
|
}
|
|
|
|
|
|
fileprivate struct FfiConverterTypeTransactionDetails: FfiConverterRustBuffer {
|
|
fileprivate static func read(from buf: Reader) throws -> TransactionDetails {
|
|
return try TransactionDetails(
|
|
`fee`: FfiConverterOptionUInt64.read(from: buf),
|
|
`received`: FfiConverterUInt64.read(from: buf),
|
|
`sent`: FfiConverterUInt64.read(from: buf),
|
|
`txid`: FfiConverterString.read(from: buf),
|
|
`confirmationTime`: FfiConverterOptionTypeBlockTime.read(from: buf)
|
|
)
|
|
}
|
|
|
|
fileprivate static func write(_ value: TransactionDetails, into buf: Writer) {
|
|
FfiConverterOptionUInt64.write(value.`fee`, into: buf)
|
|
FfiConverterUInt64.write(value.`received`, into: buf)
|
|
FfiConverterUInt64.write(value.`sent`, into: buf)
|
|
FfiConverterString.write(value.`txid`, into: buf)
|
|
FfiConverterOptionTypeBlockTime.write(value.`confirmationTime`, into: buf)
|
|
}
|
|
}
|
|
|
|
|
|
public struct TxBuilderResult {
|
|
public var `psbt`: PartiallySignedBitcoinTransaction
|
|
public var `transactionDetails`: TransactionDetails
|
|
|
|
// Default memberwise initializers are never public by default, so we
|
|
// declare one manually.
|
|
public init(`psbt`: PartiallySignedBitcoinTransaction, `transactionDetails`: TransactionDetails) {
|
|
self.`psbt` = `psbt`
|
|
self.`transactionDetails` = `transactionDetails`
|
|
}
|
|
}
|
|
|
|
|
|
|
|
fileprivate struct FfiConverterTypeTxBuilderResult: FfiConverterRustBuffer {
|
|
fileprivate static func read(from buf: Reader) throws -> TxBuilderResult {
|
|
return try TxBuilderResult(
|
|
`psbt`: FfiConverterTypePartiallySignedBitcoinTransaction.read(from: buf),
|
|
`transactionDetails`: FfiConverterTypeTransactionDetails.read(from: buf)
|
|
)
|
|
}
|
|
|
|
fileprivate static func write(_ value: TxBuilderResult, into buf: Writer) {
|
|
FfiConverterTypePartiallySignedBitcoinTransaction.write(value.`psbt`, into: buf)
|
|
FfiConverterTypeTransactionDetails.write(value.`transactionDetails`, into: buf)
|
|
}
|
|
}
|
|
|
|
|
|
public struct TxOut {
|
|
public var `value`: UInt64
|
|
public var `address`: String
|
|
|
|
// Default memberwise initializers are never public by default, so we
|
|
// declare one manually.
|
|
public init(`value`: UInt64, `address`: String) {
|
|
self.`value` = `value`
|
|
self.`address` = `address`
|
|
}
|
|
}
|
|
|
|
|
|
extension TxOut: Equatable, Hashable {
|
|
public static func ==(lhs: TxOut, rhs: TxOut) -> Bool {
|
|
if lhs.`value` != rhs.`value` {
|
|
return false
|
|
}
|
|
if lhs.`address` != rhs.`address` {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
public func hash(into hasher: inout Hasher) {
|
|
hasher.combine(`value`)
|
|
hasher.combine(`address`)
|
|
}
|
|
}
|
|
|
|
|
|
fileprivate struct FfiConverterTypeTxOut: FfiConverterRustBuffer {
|
|
fileprivate static func read(from buf: Reader) throws -> TxOut {
|
|
return try TxOut(
|
|
`value`: FfiConverterUInt64.read(from: buf),
|
|
`address`: FfiConverterString.read(from: buf)
|
|
)
|
|
}
|
|
|
|
fileprivate static func write(_ value: TxOut, into buf: Writer) {
|
|
FfiConverterUInt64.write(value.`value`, into: buf)
|
|
FfiConverterString.write(value.`address`, into: buf)
|
|
}
|
|
}
|
|
|
|
// Note that we don't yet support `indirect` for enums.
|
|
// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion.
|
|
public enum AddressIndex {
|
|
|
|
case `new`
|
|
case `lastUnused`
|
|
}
|
|
|
|
fileprivate struct FfiConverterTypeAddressIndex: FfiConverterRustBuffer {
|
|
typealias SwiftType = AddressIndex
|
|
|
|
static func read(from buf: Reader) throws -> AddressIndex {
|
|
let variant: Int32 = try buf.readInt()
|
|
switch variant {
|
|
|
|
case 1: return .`new`
|
|
|
|
case 2: return .`lastUnused`
|
|
|
|
default: throw UniffiInternalError.unexpectedEnumCase
|
|
}
|
|
}
|
|
|
|
static func write(_ value: AddressIndex, into buf: Writer) {
|
|
switch value {
|
|
|
|
|
|
case .`new`:
|
|
buf.writeInt(Int32(1))
|
|
|
|
|
|
case .`lastUnused`:
|
|
buf.writeInt(Int32(2))
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
extension AddressIndex: 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 BlockchainConfig {
|
|
|
|
case `electrum`(`config`: ElectrumConfig)
|
|
case `esplora`(`config`: EsploraConfig)
|
|
}
|
|
|
|
fileprivate struct FfiConverterTypeBlockchainConfig: FfiConverterRustBuffer {
|
|
typealias SwiftType = BlockchainConfig
|
|
|
|
static func read(from buf: Reader) throws -> BlockchainConfig {
|
|
let variant: Int32 = try buf.readInt()
|
|
switch variant {
|
|
|
|
case 1: return .`electrum`(
|
|
`config`: try FfiConverterTypeElectrumConfig.read(from: buf)
|
|
)
|
|
|
|
case 2: return .`esplora`(
|
|
`config`: try FfiConverterTypeEsploraConfig.read(from: buf)
|
|
)
|
|
|
|
default: throw UniffiInternalError.unexpectedEnumCase
|
|
}
|
|
}
|
|
|
|
static func write(_ value: BlockchainConfig, into buf: Writer) {
|
|
switch value {
|
|
|
|
|
|
case let .`electrum`(`config`):
|
|
buf.writeInt(Int32(1))
|
|
FfiConverterTypeElectrumConfig.write(`config`, into: buf)
|
|
|
|
|
|
case let .`esplora`(`config`):
|
|
buf.writeInt(Int32(2))
|
|
FfiConverterTypeEsploraConfig.write(`config`, into: buf)
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
extension BlockchainConfig: 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 DatabaseConfig {
|
|
|
|
case `memory`
|
|
case `sled`(`config`: SledDbConfiguration)
|
|
case `sqlite`(`config`: SqliteDbConfiguration)
|
|
}
|
|
|
|
fileprivate struct FfiConverterTypeDatabaseConfig: FfiConverterRustBuffer {
|
|
typealias SwiftType = DatabaseConfig
|
|
|
|
static func read(from buf: Reader) throws -> DatabaseConfig {
|
|
let variant: Int32 = try buf.readInt()
|
|
switch variant {
|
|
|
|
case 1: return .`memory`
|
|
|
|
case 2: return .`sled`(
|
|
`config`: try FfiConverterTypeSledDbConfiguration.read(from: buf)
|
|
)
|
|
|
|
case 3: return .`sqlite`(
|
|
`config`: try FfiConverterTypeSqliteDbConfiguration.read(from: buf)
|
|
)
|
|
|
|
default: throw UniffiInternalError.unexpectedEnumCase
|
|
}
|
|
}
|
|
|
|
static func write(_ value: DatabaseConfig, into buf: Writer) {
|
|
switch value {
|
|
|
|
|
|
case .`memory`:
|
|
buf.writeInt(Int32(1))
|
|
|
|
|
|
case let .`sled`(`config`):
|
|
buf.writeInt(Int32(2))
|
|
FfiConverterTypeSledDbConfiguration.write(`config`, into: buf)
|
|
|
|
|
|
case let .`sqlite`(`config`):
|
|
buf.writeInt(Int32(3))
|
|
FfiConverterTypeSqliteDbConfiguration.write(`config`, into: buf)
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
extension DatabaseConfig: 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 KeychainKind {
|
|
|
|
case `external`
|
|
case `internal`
|
|
}
|
|
|
|
fileprivate struct FfiConverterTypeKeychainKind: FfiConverterRustBuffer {
|
|
typealias SwiftType = KeychainKind
|
|
|
|
static func read(from buf: Reader) throws -> KeychainKind {
|
|
let variant: Int32 = try buf.readInt()
|
|
switch variant {
|
|
|
|
case 1: return .`external`
|
|
|
|
case 2: return .`internal`
|
|
|
|
default: throw UniffiInternalError.unexpectedEnumCase
|
|
}
|
|
}
|
|
|
|
static func write(_ value: KeychainKind, into buf: Writer) {
|
|
switch value {
|
|
|
|
|
|
case .`external`:
|
|
buf.writeInt(Int32(1))
|
|
|
|
|
|
case .`internal`:
|
|
buf.writeInt(Int32(2))
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
extension KeychainKind: 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 Network {
|
|
|
|
case `bitcoin`
|
|
case `testnet`
|
|
case `signet`
|
|
case `regtest`
|
|
}
|
|
|
|
fileprivate struct FfiConverterTypeNetwork: FfiConverterRustBuffer {
|
|
typealias SwiftType = Network
|
|
|
|
static func read(from buf: Reader) throws -> Network {
|
|
let variant: Int32 = try buf.readInt()
|
|
switch variant {
|
|
|
|
case 1: return .`bitcoin`
|
|
|
|
case 2: return .`testnet`
|
|
|
|
case 3: return .`signet`
|
|
|
|
case 4: return .`regtest`
|
|
|
|
default: throw UniffiInternalError.unexpectedEnumCase
|
|
}
|
|
}
|
|
|
|
static func write(_ value: Network, into buf: Writer) {
|
|
switch value {
|
|
|
|
|
|
case .`bitcoin`:
|
|
buf.writeInt(Int32(1))
|
|
|
|
|
|
case .`testnet`:
|
|
buf.writeInt(Int32(2))
|
|
|
|
|
|
case .`signet`:
|
|
buf.writeInt(Int32(3))
|
|
|
|
|
|
case .`regtest`:
|
|
buf.writeInt(Int32(4))
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
extension Network: 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 WordCount {
|
|
|
|
case `words12`
|
|
case `words15`
|
|
case `words18`
|
|
case `words21`
|
|
case `words24`
|
|
}
|
|
|
|
fileprivate struct FfiConverterTypeWordCount: FfiConverterRustBuffer {
|
|
typealias SwiftType = WordCount
|
|
|
|
static func read(from buf: Reader) throws -> WordCount {
|
|
let variant: Int32 = try buf.readInt()
|
|
switch variant {
|
|
|
|
case 1: return .`words12`
|
|
|
|
case 2: return .`words15`
|
|
|
|
case 3: return .`words18`
|
|
|
|
case 4: return .`words21`
|
|
|
|
case 5: return .`words24`
|
|
|
|
default: throw UniffiInternalError.unexpectedEnumCase
|
|
}
|
|
}
|
|
|
|
static func write(_ value: WordCount, into buf: Writer) {
|
|
switch value {
|
|
|
|
|
|
case .`words12`:
|
|
buf.writeInt(Int32(1))
|
|
|
|
|
|
case .`words15`:
|
|
buf.writeInt(Int32(2))
|
|
|
|
|
|
case .`words18`:
|
|
buf.writeInt(Int32(3))
|
|
|
|
|
|
case .`words21`:
|
|
buf.writeInt(Int32(4))
|
|
|
|
|
|
case .`words24`:
|
|
buf.writeInt(Int32(5))
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
extension WordCount: Equatable, Hashable {}
|
|
|
|
|
|
|
|
public enum BdkError {
|
|
|
|
|
|
|
|
// Simple error enums only carry a message
|
|
case InvalidU32Bytes(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case Generic(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case MissingCachedScripts(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case ScriptDoesntHaveAddressForm(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case NoRecipients(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case NoUtxosSelected(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case OutputBelowDustLimit(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case InsufficientFunds(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case BnBTotalTriesExceeded(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case BnBNoExactMatch(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case UnknownUtxo(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case TransactionNotFound(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case TransactionConfirmed(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case IrreplaceableTransaction(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case FeeRateTooLow(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case FeeTooLow(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case FeeRateUnavailable(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case MissingKeyOrigin(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case Key(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case ChecksumMismatch(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case SpendingPolicyRequired(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case InvalidPolicyPathError(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case Signer(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case InvalidNetwork(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case InvalidProgressValue(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case ProgressUpdateError(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case InvalidOutpoint(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case Descriptor(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case AddressValidator(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case Encode(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case Miniscript(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case Bip32(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case Secp256k1(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case Json(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case Hex(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case Psbt(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case PsbtParse(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case Electrum(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case Esplora(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case Sled(message: String)
|
|
|
|
// Simple error enums only carry a message
|
|
case Rusqlite(message: String)
|
|
|
|
}
|
|
|
|
fileprivate struct FfiConverterTypeBdkError: FfiConverterRustBuffer {
|
|
typealias SwiftType = BdkError
|
|
|
|
static func read(from buf: Reader) throws -> BdkError {
|
|
let variant: Int32 = try buf.readInt()
|
|
switch variant {
|
|
|
|
|
|
|
|
|
|
case 1: return .InvalidU32Bytes(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 2: return .Generic(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 3: return .MissingCachedScripts(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 4: return .ScriptDoesntHaveAddressForm(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 5: return .NoRecipients(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 6: return .NoUtxosSelected(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 7: return .OutputBelowDustLimit(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 8: return .InsufficientFunds(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 9: return .BnBTotalTriesExceeded(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 10: return .BnBNoExactMatch(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 11: return .UnknownUtxo(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 12: return .TransactionNotFound(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 13: return .TransactionConfirmed(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 14: return .IrreplaceableTransaction(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 15: return .FeeRateTooLow(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 16: return .FeeTooLow(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 17: return .FeeRateUnavailable(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 18: return .MissingKeyOrigin(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 19: return .Key(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 20: return .ChecksumMismatch(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 21: return .SpendingPolicyRequired(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 22: return .InvalidPolicyPathError(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 23: return .Signer(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 24: return .InvalidNetwork(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 25: return .InvalidProgressValue(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 26: return .ProgressUpdateError(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 27: return .InvalidOutpoint(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 28: return .Descriptor(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 29: return .AddressValidator(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 30: return .Encode(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 31: return .Miniscript(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 32: return .Bip32(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 33: return .Secp256k1(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 34: return .Json(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 35: return .Hex(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 36: return .Psbt(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 37: return .PsbtParse(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 38: return .Electrum(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 39: return .Esplora(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 40: return .Sled(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
case 41: return .Rusqlite(
|
|
message: try FfiConverterString.read(from: buf)
|
|
)
|
|
|
|
|
|
default: throw UniffiInternalError.unexpectedEnumCase
|
|
}
|
|
}
|
|
|
|
static func write(_ value: BdkError, into buf: Writer) {
|
|
switch value {
|
|
|
|
|
|
|
|
|
|
case let .InvalidU32Bytes(message):
|
|
buf.writeInt(Int32(1))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .Generic(message):
|
|
buf.writeInt(Int32(2))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .MissingCachedScripts(message):
|
|
buf.writeInt(Int32(3))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .ScriptDoesntHaveAddressForm(message):
|
|
buf.writeInt(Int32(4))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .NoRecipients(message):
|
|
buf.writeInt(Int32(5))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .NoUtxosSelected(message):
|
|
buf.writeInt(Int32(6))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .OutputBelowDustLimit(message):
|
|
buf.writeInt(Int32(7))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .InsufficientFunds(message):
|
|
buf.writeInt(Int32(8))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .BnBTotalTriesExceeded(message):
|
|
buf.writeInt(Int32(9))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .BnBNoExactMatch(message):
|
|
buf.writeInt(Int32(10))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .UnknownUtxo(message):
|
|
buf.writeInt(Int32(11))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .TransactionNotFound(message):
|
|
buf.writeInt(Int32(12))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .TransactionConfirmed(message):
|
|
buf.writeInt(Int32(13))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .IrreplaceableTransaction(message):
|
|
buf.writeInt(Int32(14))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .FeeRateTooLow(message):
|
|
buf.writeInt(Int32(15))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .FeeTooLow(message):
|
|
buf.writeInt(Int32(16))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .FeeRateUnavailable(message):
|
|
buf.writeInt(Int32(17))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .MissingKeyOrigin(message):
|
|
buf.writeInt(Int32(18))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .Key(message):
|
|
buf.writeInt(Int32(19))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .ChecksumMismatch(message):
|
|
buf.writeInt(Int32(20))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .SpendingPolicyRequired(message):
|
|
buf.writeInt(Int32(21))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .InvalidPolicyPathError(message):
|
|
buf.writeInt(Int32(22))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .Signer(message):
|
|
buf.writeInt(Int32(23))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .InvalidNetwork(message):
|
|
buf.writeInt(Int32(24))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .InvalidProgressValue(message):
|
|
buf.writeInt(Int32(25))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .ProgressUpdateError(message):
|
|
buf.writeInt(Int32(26))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .InvalidOutpoint(message):
|
|
buf.writeInt(Int32(27))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .Descriptor(message):
|
|
buf.writeInt(Int32(28))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .AddressValidator(message):
|
|
buf.writeInt(Int32(29))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .Encode(message):
|
|
buf.writeInt(Int32(30))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .Miniscript(message):
|
|
buf.writeInt(Int32(31))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .Bip32(message):
|
|
buf.writeInt(Int32(32))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .Secp256k1(message):
|
|
buf.writeInt(Int32(33))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .Json(message):
|
|
buf.writeInt(Int32(34))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .Hex(message):
|
|
buf.writeInt(Int32(35))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .Psbt(message):
|
|
buf.writeInt(Int32(36))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .PsbtParse(message):
|
|
buf.writeInt(Int32(37))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .Electrum(message):
|
|
buf.writeInt(Int32(38))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .Esplora(message):
|
|
buf.writeInt(Int32(39))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .Sled(message):
|
|
buf.writeInt(Int32(40))
|
|
FfiConverterString.write(message, into: buf)
|
|
case let .Rusqlite(message):
|
|
buf.writeInt(Int32(41))
|
|
FfiConverterString.write(message, into: buf)
|
|
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
extension BdkError: Equatable, Hashable {}
|
|
|
|
extension BdkError: Error { }
|
|
|
|
fileprivate extension NSLock {
|
|
func withLock<T>(f: () throws -> T) rethrows -> T {
|
|
self.lock()
|
|
defer { self.unlock() }
|
|
return try f()
|
|
}
|
|
}
|
|
|
|
fileprivate typealias Handle = UInt64
|
|
fileprivate class ConcurrentHandleMap<T> {
|
|
private var leftMap: [Handle: T] = [:]
|
|
private var counter: [Handle: UInt64] = [:]
|
|
private var rightMap: [ObjectIdentifier: Handle] = [:]
|
|
|
|
private let lock = NSLock()
|
|
private var currentHandle: Handle = 0
|
|
private let stride: Handle = 1
|
|
|
|
func insert(obj: T) -> Handle {
|
|
lock.withLock {
|
|
let id = ObjectIdentifier(obj as AnyObject)
|
|
let handle = rightMap[id] ?? {
|
|
currentHandle += stride
|
|
let handle = currentHandle
|
|
leftMap[handle] = obj
|
|
rightMap[id] = handle
|
|
return handle
|
|
}()
|
|
counter[handle] = (counter[handle] ?? 0) + 1
|
|
return handle
|
|
}
|
|
}
|
|
|
|
func get(handle: Handle) -> T? {
|
|
lock.withLock {
|
|
leftMap[handle]
|
|
}
|
|
}
|
|
|
|
func delete(handle: Handle) {
|
|
remove(handle: handle)
|
|
}
|
|
|
|
@discardableResult
|
|
func remove(handle: Handle) -> T? {
|
|
lock.withLock {
|
|
defer { counter[handle] = (counter[handle] ?? 1) - 1 }
|
|
guard counter[handle] == 1 else { return leftMap[handle] }
|
|
let obj = leftMap.removeValue(forKey: handle)
|
|
if let obj = obj {
|
|
rightMap.removeValue(forKey: ObjectIdentifier(obj as AnyObject))
|
|
}
|
|
return obj
|
|
}
|
|
}
|
|
}
|
|
|
|
// Magic number for the Rust proxy to call using the same mechanism as every other method,
|
|
// to free the callback once it's dropped by Rust.
|
|
private let IDX_CALLBACK_FREE: Int32 = 0
|
|
|
|
// Declaration and FfiConverters for Progress Callback Interface
|
|
|
|
public protocol Progress : AnyObject {
|
|
func `update`(`progress`: Float, `message`: String?)
|
|
|
|
}
|
|
|
|
// The ForeignCallback that is passed to Rust.
|
|
fileprivate let foreignCallbackCallbackInterfaceProgress : ForeignCallback =
|
|
{ (handle: Handle, method: Int32, args: RustBuffer, out_buf: UnsafeMutablePointer<RustBuffer>) -> Int32 in
|
|
func `invokeUpdate`(_ swiftCallbackInterface: Progress, _ args: RustBuffer) throws -> RustBuffer {
|
|
defer { args.deallocate() }
|
|
|
|
let reader = Reader(data: Data(rustBuffer: args))
|
|
swiftCallbackInterface.`update`(
|
|
`progress`: try FfiConverterFloat.read(from: reader),
|
|
`message`: try FfiConverterOptionString.read(from: reader)
|
|
)
|
|
return RustBuffer()
|
|
// TODO catch errors and report them back to Rust.
|
|
// https://github.com/mozilla/uniffi-rs/issues/351
|
|
|
|
}
|
|
|
|
|
|
let cb: Progress
|
|
do {
|
|
cb = try FfiConverterCallbackInterfaceProgress.lift(handle)
|
|
} catch {
|
|
out_buf.pointee = FfiConverterString.lower("Progress: Invalid handle")
|
|
return -1
|
|
}
|
|
|
|
switch method {
|
|
case IDX_CALLBACK_FREE:
|
|
FfiConverterCallbackInterfaceProgress.drop(handle: handle)
|
|
// No return value.
|
|
// See docs of ForeignCallback in `uniffi/src/ffi/foreigncallbacks.rs`
|
|
return 0
|
|
case 1:
|
|
do {
|
|
out_buf.pointee = try `invokeUpdate`(cb, args)
|
|
// Value written to out buffer.
|
|
// See docs of ForeignCallback in `uniffi/src/ffi/foreigncallbacks.rs`
|
|
return 1
|
|
} catch let error {
|
|
out_buf.pointee = FfiConverterString.lower(String(describing: error))
|
|
return -1
|
|
}
|
|
|
|
// This should never happen, because an out of bounds method index won't
|
|
// ever be used. Once we can catch errors, we should return an InternalError.
|
|
// https://github.com/mozilla/uniffi-rs/issues/351
|
|
default:
|
|
// An unexpected error happened.
|
|
// See docs of ForeignCallback in `uniffi/src/ffi/foreigncallbacks.rs`
|
|
return -1
|
|
}
|
|
}
|
|
|
|
// FFIConverter protocol for callback interfaces
|
|
fileprivate struct FfiConverterCallbackInterfaceProgress {
|
|
// Initialize our callback method with the scaffolding code
|
|
private static var callbackInitialized = false
|
|
private static func initCallback() {
|
|
try! rustCall { (err: UnsafeMutablePointer<RustCallStatus>) in
|
|
ffi_bdk_1724_Progress_init_callback(foreignCallbackCallbackInterfaceProgress, err)
|
|
}
|
|
}
|
|
private static func ensureCallbackinitialized() {
|
|
if !callbackInitialized {
|
|
initCallback()
|
|
callbackInitialized = true
|
|
}
|
|
}
|
|
|
|
static func drop(handle: Handle) {
|
|
handleMap.remove(handle: handle)
|
|
}
|
|
|
|
private static var handleMap = ConcurrentHandleMap<Progress>()
|
|
}
|
|
|
|
extension FfiConverterCallbackInterfaceProgress : FfiConverter {
|
|
typealias SwiftType = Progress
|
|
// We can use Handle as the FFIType because it's a typealias to UInt64
|
|
typealias FfiType = Handle
|
|
|
|
static func lift(_ handle: Handle) throws -> SwiftType {
|
|
ensureCallbackinitialized();
|
|
guard let callback = handleMap.get(handle: handle) else {
|
|
throw UniffiInternalError.unexpectedStaleHandle
|
|
}
|
|
return callback
|
|
}
|
|
|
|
static func read(from buf: Reader) throws -> SwiftType {
|
|
ensureCallbackinitialized();
|
|
let handle: Handle = try buf.readInt()
|
|
return try lift(handle)
|
|
}
|
|
|
|
static func lower(_ v: SwiftType) -> Handle {
|
|
ensureCallbackinitialized();
|
|
return handleMap.insert(obj: v)
|
|
}
|
|
|
|
static func write(_ v: SwiftType, into buf: Writer) {
|
|
ensureCallbackinitialized();
|
|
buf.writeInt(lower(v))
|
|
}
|
|
}
|
|
|
|
fileprivate struct FfiConverterOptionUInt8: FfiConverterRustBuffer {
|
|
typealias SwiftType = UInt8?
|
|
|
|
static func write(_ value: SwiftType, into buf: Writer) {
|
|
guard let value = value else {
|
|
buf.writeInt(Int8(0))
|
|
return
|
|
}
|
|
buf.writeInt(Int8(1))
|
|
FfiConverterUInt8.write(value, into: buf)
|
|
}
|
|
|
|
static func read(from buf: Reader) throws -> SwiftType {
|
|
switch try buf.readInt() as Int8 {
|
|
case 0: return nil
|
|
case 1: return try FfiConverterUInt8.read(from: buf)
|
|
default: throw UniffiInternalError.unexpectedOptionalTag
|
|
}
|
|
}
|
|
}
|
|
|
|
fileprivate struct FfiConverterOptionUInt64: FfiConverterRustBuffer {
|
|
typealias SwiftType = UInt64?
|
|
|
|
static func write(_ value: SwiftType, into buf: Writer) {
|
|
guard let value = value else {
|
|
buf.writeInt(Int8(0))
|
|
return
|
|
}
|
|
buf.writeInt(Int8(1))
|
|
FfiConverterUInt64.write(value, into: buf)
|
|
}
|
|
|
|
static func read(from buf: Reader) throws -> SwiftType {
|
|
switch try buf.readInt() as Int8 {
|
|
case 0: return nil
|
|
case 1: return try FfiConverterUInt64.read(from: buf)
|
|
default: throw UniffiInternalError.unexpectedOptionalTag
|
|
}
|
|
}
|
|
}
|
|
|
|
fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer {
|
|
typealias SwiftType = String?
|
|
|
|
static func write(_ value: SwiftType, into buf: Writer) {
|
|
guard let value = value else {
|
|
buf.writeInt(Int8(0))
|
|
return
|
|
}
|
|
buf.writeInt(Int8(1))
|
|
FfiConverterString.write(value, into: buf)
|
|
}
|
|
|
|
static func read(from buf: Reader) throws -> SwiftType {
|
|
switch try buf.readInt() as Int8 {
|
|
case 0: return nil
|
|
case 1: return try FfiConverterString.read(from: buf)
|
|
default: throw UniffiInternalError.unexpectedOptionalTag
|
|
}
|
|
}
|
|
}
|
|
|
|
fileprivate struct FfiConverterOptionTypeBlockTime: FfiConverterRustBuffer {
|
|
typealias SwiftType = BlockTime?
|
|
|
|
static func write(_ value: SwiftType, into buf: Writer) {
|
|
guard let value = value else {
|
|
buf.writeInt(Int8(0))
|
|
return
|
|
}
|
|
buf.writeInt(Int8(1))
|
|
FfiConverterTypeBlockTime.write(value, into: buf)
|
|
}
|
|
|
|
static func read(from buf: Reader) throws -> SwiftType {
|
|
switch try buf.readInt() as Int8 {
|
|
case 0: return nil
|
|
case 1: return try FfiConverterTypeBlockTime.read(from: buf)
|
|
default: throw UniffiInternalError.unexpectedOptionalTag
|
|
}
|
|
}
|
|
}
|
|
|
|
fileprivate struct FfiConverterOptionCallbackInterfaceProgress: FfiConverterRustBuffer {
|
|
typealias SwiftType = Progress?
|
|
|
|
static func write(_ value: SwiftType, into buf: Writer) {
|
|
guard let value = value else {
|
|
buf.writeInt(Int8(0))
|
|
return
|
|
}
|
|
buf.writeInt(Int8(1))
|
|
FfiConverterCallbackInterfaceProgress.write(value, into: buf)
|
|
}
|
|
|
|
static func read(from buf: Reader) throws -> SwiftType {
|
|
switch try buf.readInt() as Int8 {
|
|
case 0: return nil
|
|
case 1: return try FfiConverterCallbackInterfaceProgress.read(from: buf)
|
|
default: throw UniffiInternalError.unexpectedOptionalTag
|
|
}
|
|
}
|
|
}
|
|
|
|
fileprivate struct FfiConverterSequenceUInt8: FfiConverterRustBuffer {
|
|
typealias SwiftType = [UInt8]
|
|
|
|
static func write(_ value: [UInt8], into buf: Writer) {
|
|
let len = Int32(value.count)
|
|
buf.writeInt(len)
|
|
for item in value {
|
|
FfiConverterUInt8.write(item, into: buf)
|
|
}
|
|
}
|
|
|
|
static func read(from buf: Reader) throws -> [UInt8] {
|
|
let len: Int32 = try buf.readInt()
|
|
var seq = [UInt8]()
|
|
seq.reserveCapacity(Int(len))
|
|
for _ in 0 ..< len {
|
|
seq.append(try FfiConverterUInt8.read(from: buf))
|
|
}
|
|
return seq
|
|
}
|
|
}
|
|
|
|
fileprivate struct FfiConverterSequenceTypeLocalUtxo: FfiConverterRustBuffer {
|
|
typealias SwiftType = [LocalUtxo]
|
|
|
|
static func write(_ value: [LocalUtxo], into buf: Writer) {
|
|
let len = Int32(value.count)
|
|
buf.writeInt(len)
|
|
for item in value {
|
|
FfiConverterTypeLocalUtxo.write(item, into: buf)
|
|
}
|
|
}
|
|
|
|
static func read(from buf: Reader) throws -> [LocalUtxo] {
|
|
let len: Int32 = try buf.readInt()
|
|
var seq = [LocalUtxo]()
|
|
seq.reserveCapacity(Int(len))
|
|
for _ in 0 ..< len {
|
|
seq.append(try FfiConverterTypeLocalUtxo.read(from: buf))
|
|
}
|
|
return seq
|
|
}
|
|
}
|
|
|
|
fileprivate struct FfiConverterSequenceTypeOutPoint: FfiConverterRustBuffer {
|
|
typealias SwiftType = [OutPoint]
|
|
|
|
static func write(_ value: [OutPoint], into buf: Writer) {
|
|
let len = Int32(value.count)
|
|
buf.writeInt(len)
|
|
for item in value {
|
|
FfiConverterTypeOutPoint.write(item, into: buf)
|
|
}
|
|
}
|
|
|
|
static func read(from buf: Reader) throws -> [OutPoint] {
|
|
let len: Int32 = try buf.readInt()
|
|
var seq = [OutPoint]()
|
|
seq.reserveCapacity(Int(len))
|
|
for _ in 0 ..< len {
|
|
seq.append(try FfiConverterTypeOutPoint.read(from: buf))
|
|
}
|
|
return seq
|
|
}
|
|
}
|
|
|
|
fileprivate struct FfiConverterSequenceTypeScriptAmount: FfiConverterRustBuffer {
|
|
typealias SwiftType = [ScriptAmount]
|
|
|
|
static func write(_ value: [ScriptAmount], into buf: Writer) {
|
|
let len = Int32(value.count)
|
|
buf.writeInt(len)
|
|
for item in value {
|
|
FfiConverterTypeScriptAmount.write(item, into: buf)
|
|
}
|
|
}
|
|
|
|
static func read(from buf: Reader) throws -> [ScriptAmount] {
|
|
let len: Int32 = try buf.readInt()
|
|
var seq = [ScriptAmount]()
|
|
seq.reserveCapacity(Int(len))
|
|
for _ in 0 ..< len {
|
|
seq.append(try FfiConverterTypeScriptAmount.read(from: buf))
|
|
}
|
|
return seq
|
|
}
|
|
}
|
|
|
|
fileprivate struct FfiConverterSequenceTypeTransactionDetails: FfiConverterRustBuffer {
|
|
typealias SwiftType = [TransactionDetails]
|
|
|
|
static func write(_ value: [TransactionDetails], into buf: Writer) {
|
|
let len = Int32(value.count)
|
|
buf.writeInt(len)
|
|
for item in value {
|
|
FfiConverterTypeTransactionDetails.write(item, into: buf)
|
|
}
|
|
}
|
|
|
|
static func read(from buf: Reader) throws -> [TransactionDetails] {
|
|
let len: Int32 = try buf.readInt()
|
|
var seq = [TransactionDetails]()
|
|
seq.reserveCapacity(Int(len))
|
|
for _ in 0 ..< len {
|
|
seq.append(try FfiConverterTypeTransactionDetails.read(from: buf))
|
|
}
|
|
return seq
|
|
}
|
|
}
|
|
|
|
public func `generateMnemonic`(`wordCount`: WordCount) throws -> String {
|
|
return try FfiConverterString.lift(
|
|
try
|
|
|
|
rustCallWithError(FfiConverterTypeBdkError.self) {
|
|
|
|
bdk_1724_generate_mnemonic(
|
|
FfiConverterTypeWordCount.lower(`wordCount`), $0)
|
|
}
|
|
)
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Top level initializers and tear down methods.
|
|
*
|
|
* This is generated by uniffi.
|
|
*/
|
|
public enum BdkLifecycle {
|
|
/**
|
|
* Initialize the FFI and Rust library. This should be only called once per application.
|
|
*/
|
|
func initialize() {
|
|
}
|
|
} |