@keystonehq/react-native-keystone-wallet-core 0.1.0-alpha.0 → 0.1.0-alpha.3

package/ios/keystone_wallet_core.swift

@@ -442,6 +442,30 @@ fileprivate struct FfiConverterUInt64: FfiConverterPrimitive {
     }
 }
 
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterBool : FfiConverter {
+    typealias FfiType = Int8
+    typealias SwiftType = Bool
+
+    public static func lift(_ value: Int8) throws -> Bool {
+        return value != 0
+    }
+
+    public static func lower(_ value: Bool) -> Int8 {
+        return value ? 1 : 0
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Bool {
+        return try lift(readInt(&buf))
+    }
+
+    public static func write(_ value: Bool, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
@@ -604,6 +628,286 @@ public func FfiConverterTypePczt_lower(_ value: Pczt) -> UnsafeMutableRawPointer
 }
 
 
+public struct CardanoTxInput {
+    public var txHash: String
+    public var txIndex: UInt32
+    public var amount: UInt64
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(txHash: String, txIndex: UInt32, amount: UInt64) {
+        self.txHash = txHash
+        self.txIndex = txIndex
+        self.amount = amount
+    }
+}
+
+
+
+extension CardanoTxInput: Equatable, Hashable {
+    public static func ==(lhs: CardanoTxInput, rhs: CardanoTxInput) -> Bool {
+        if lhs.txHash != rhs.txHash {
+            return false
+        }
+        if lhs.txIndex != rhs.txIndex {
+            return false
+        }
+        if lhs.amount != rhs.amount {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(txHash)
+        hasher.combine(txIndex)
+        hasher.combine(amount)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeCardanoTxInput: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CardanoTxInput {
+        return
+            try CardanoTxInput(
+                txHash: FfiConverterString.read(from: &buf), 
+                txIndex: FfiConverterUInt32.read(from: &buf), 
+                amount: FfiConverterUInt64.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: CardanoTxInput, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.txHash, into: &buf)
+        FfiConverterUInt32.write(value.txIndex, into: &buf)
+        FfiConverterUInt64.write(value.amount, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeCardanoTxInput_lift(_ buf: RustBuffer) throws -> CardanoTxInput {
+    return try FfiConverterTypeCardanoTxInput.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeCardanoTxInput_lower(_ value: CardanoTxInput) -> RustBuffer {
+    return FfiConverterTypeCardanoTxInput.lower(value)
+}
+
+
+public struct CardanoTxOutput {
+    public var address: String
+    public var amount: UInt64
+    public var isChange: Bool
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(address: String, amount: UInt64, isChange: Bool) {
+        self.address = address
+        self.amount = amount
+        self.isChange = isChange
+    }
+}
+
+
+
+extension CardanoTxOutput: Equatable, Hashable {
+    public static func ==(lhs: CardanoTxOutput, rhs: CardanoTxOutput) -> Bool {
+        if lhs.address != rhs.address {
+            return false
+        }
+        if lhs.amount != rhs.amount {
+            return false
+        }
+        if lhs.isChange != rhs.isChange {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(address)
+        hasher.combine(amount)
+        hasher.combine(isChange)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeCardanoTxOutput: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CardanoTxOutput {
+        return
+            try CardanoTxOutput(
+                address: FfiConverterString.read(from: &buf), 
+                amount: FfiConverterUInt64.read(from: &buf), 
+                isChange: FfiConverterBool.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: CardanoTxOutput, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.address, into: &buf)
+        FfiConverterUInt64.write(value.amount, into: &buf)
+        FfiConverterBool.write(value.isChange, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeCardanoTxOutput_lift(_ buf: RustBuffer) throws -> CardanoTxOutput {
+    return try FfiConverterTypeCardanoTxOutput.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeCardanoTxOutput_lower(_ value: CardanoTxOutput) -> RustBuffer {
+    return FfiConverterTypeCardanoTxOutput.lower(value)
+}
+
+
+public struct DerivedKeys {
+    public var paymentPubkeyHex: String
+    public var stakePubkeyHex: String
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(paymentPubkeyHex: String, stakePubkeyHex: String) {
+        self.paymentPubkeyHex = paymentPubkeyHex
+        self.stakePubkeyHex = stakePubkeyHex
+    }
+}
+
+
+
+extension DerivedKeys: Equatable, Hashable {
+    public static func ==(lhs: DerivedKeys, rhs: DerivedKeys) -> Bool {
+        if lhs.paymentPubkeyHex != rhs.paymentPubkeyHex {
+            return false
+        }
+        if lhs.stakePubkeyHex != rhs.stakePubkeyHex {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(paymentPubkeyHex)
+        hasher.combine(stakePubkeyHex)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeDerivedKeys: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> DerivedKeys {
+        return
+            try DerivedKeys(
+                paymentPubkeyHex: FfiConverterString.read(from: &buf), 
+                stakePubkeyHex: FfiConverterString.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: DerivedKeys, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.paymentPubkeyHex, into: &buf)
+        FfiConverterString.write(value.stakePubkeyHex, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeDerivedKeys_lift(_ buf: RustBuffer) throws -> DerivedKeys {
+    return try FfiConverterTypeDerivedKeys.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeDerivedKeys_lower(_ value: DerivedKeys) -> RustBuffer {
+    return FfiConverterTypeDerivedKeys.lower(value)
+}
+
+
+public struct SignedTxResult {
+    public var txId: String
+    public var txHex: String
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(txId: String, txHex: String) {
+        self.txId = txId
+        self.txHex = txHex
+    }
+}
+
+
+
+extension SignedTxResult: Equatable, Hashable {
+    public static func ==(lhs: SignedTxResult, rhs: SignedTxResult) -> Bool {
+        if lhs.txId != rhs.txId {
+            return false
+        }
+        if lhs.txHex != rhs.txHex {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(txId)
+        hasher.combine(txHex)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeSignedTxResult: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SignedTxResult {
+        return
+            try SignedTxResult(
+                txId: FfiConverterString.read(from: &buf), 
+                txHex: FfiConverterString.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: SignedTxResult, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.txId, into: &buf)
+        FfiConverterString.write(value.txHex, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeSignedTxResult_lift(_ buf: RustBuffer) throws -> SignedTxResult {
+    return try FfiConverterTypeSignedTxResult.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeSignedTxResult_lower(_ value: SignedTxResult) -> RustBuffer {
+    return FfiConverterTypeSignedTxResult.lower(value)
+}
+
+
 public struct TransparentInput {
     public var txid: String
     public var vout: UInt32
@@ -775,6 +1079,70 @@ public func FfiConverterTypeTransparentOutput_lower(_ value: TransparentOutput)
     return FfiConverterTypeTransparentOutput.lower(value)
 }
 
+// Note that we don't yet support `indirect` for enums.
+// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion.
+
+public enum CardanoNetwork {
+    
+    case mainnet
+    case testnet
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeCardanoNetwork: FfiConverterRustBuffer {
+    typealias SwiftType = CardanoNetwork
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CardanoNetwork {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+        
+        case 1: return .mainnet
+        
+        case 2: return .testnet
+        
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: CardanoNetwork, into buf: inout [UInt8]) {
+        switch value {
+        
+        
+        case .mainnet:
+            writeInt(&buf, Int32(1))
+        
+        
+        case .testnet:
+            writeInt(&buf, Int32(2))
+        
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeCardanoNetwork_lift(_ buf: RustBuffer) throws -> CardanoNetwork {
+    return try FfiConverterTypeCardanoNetwork.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeCardanoNetwork_lower(_ value: CardanoNetwork) -> RustBuffer {
+    return FfiConverterTypeCardanoNetwork.lower(value)
+}
+
+
+
+extension CardanoNetwork: Equatable, Hashable {}
+
+
+
 
 public enum PcztError {
 
@@ -870,6 +1238,85 @@ extension PcztError: Foundation.LocalizedError {
     }
 }
 
+
+public enum WalletError {
+
+    
+    
+    case HexError(message: String)
+    
+    case InvalidPath(message: String)
+    
+    case CslError(message: String)
+    
+    case ParseError(message: String)
+    
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeWalletError: FfiConverterRustBuffer {
+    typealias SwiftType = WalletError
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> WalletError {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+
+        
+
+        
+        case 1: return .HexError(
+            message: try FfiConverterString.read(from: &buf)
+        )
+        
+        case 2: return .InvalidPath(
+            message: try FfiConverterString.read(from: &buf)
+        )
+        
+        case 3: return .CslError(
+            message: try FfiConverterString.read(from: &buf)
+        )
+        
+        case 4: return .ParseError(
+            message: try FfiConverterString.read(from: &buf)
+        )
+        
+
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: WalletError, into buf: inout [UInt8]) {
+        switch value {
+
+        
+
+        
+        case .HexError(_ /* message is ignored*/):
+            writeInt(&buf, Int32(1))
+        case .InvalidPath(_ /* message is ignored*/):
+            writeInt(&buf, Int32(2))
+        case .CslError(_ /* message is ignored*/):
+            writeInt(&buf, Int32(3))
+        case .ParseError(_ /* message is ignored*/):
+            writeInt(&buf, Int32(4))
+
+        
+        }
+    }
+}
+
+
+extension WalletError: Equatable, Hashable {}
+
+extension WalletError: Foundation.LocalizedError {
+    public var errorDescription: String? {
+        String(reflecting: self)
+    }
+}
+
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
@@ -895,6 +1342,56 @@ fileprivate struct FfiConverterSequenceUInt8: FfiConverterRustBuffer {
     }
 }
 
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterSequenceTypeCardanoTxInput: FfiConverterRustBuffer {
+    typealias SwiftType = [CardanoTxInput]
+
+    public static func write(_ value: [CardanoTxInput], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterTypeCardanoTxInput.write(item, into: &buf)
+        }
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [CardanoTxInput] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [CardanoTxInput]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            seq.append(try FfiConverterTypeCardanoTxInput.read(from: &buf))
+        }
+        return seq
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterSequenceTypeCardanoTxOutput: FfiConverterRustBuffer {
+    typealias SwiftType = [CardanoTxOutput]
+
+    public static func write(_ value: [CardanoTxOutput], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterTypeCardanoTxOutput.write(item, into: &buf)
+        }
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [CardanoTxOutput] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [CardanoTxOutput]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            seq.append(try FfiConverterTypeCardanoTxOutput.read(from: &buf))
+        }
+        return seq
+    }
+}
+
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
@@ -944,6 +1441,26 @@ fileprivate struct FfiConverterSequenceTypeTransparentOutput: FfiConverterRustBu
         return seq
     }
 }
+public func assembleTransactionAda(rawTxHex: String, witnessSetHex: String)throws  -> SignedTxResult {
+    return try  FfiConverterTypeSignedTxResult.lift(try rustCallWithError(FfiConverterTypeWalletError.lift) {
+    uniffi_keystone_wallet_core_fn_func_assemble_transaction_ada(
+        FfiConverterString.lower(rawTxHex),
+        FfiConverterString.lower(witnessSetHex),$0
+    )
+})
+}
+public func composeTransactionAda(inputs: [CardanoTxInput], outputs: [CardanoTxOutput], changeAddress: String, fee: UInt64, ttl: UInt64, network: CardanoNetwork)throws  -> String {
+    return try  FfiConverterString.lift(try rustCallWithError(FfiConverterTypeWalletError.lift) {
+    uniffi_keystone_wallet_core_fn_func_compose_transaction_ada(
+        FfiConverterSequenceTypeCardanoTxInput.lower(inputs),
+        FfiConverterSequenceTypeCardanoTxOutput.lower(outputs),
+        FfiConverterString.lower(changeAddress),
+        FfiConverterUInt64.lower(fee),
+        FfiConverterUInt64.lower(ttl),
+        FfiConverterTypeCardanoNetwork.lower(network),$0
+    )
+})
+}
 public func createPczt(consensusBranchId: UInt32, expiryHeight: UInt32, coinType: UInt32)throws  -> Pczt {
     return try  FfiConverterTypePczt.lift(try rustCallWithError(FfiConverterTypePcztError.lift) {
     uniffi_keystone_wallet_core_fn_func_create_pczt(
@@ -962,22 +1479,52 @@ public func createTransparentPczt(inputs: [TransparentInput], outputs: [Transpar
     )
 })
 }
-public func extractAndFinalizePczt(pcztHex: String, expiryHeight: UInt32, privateKeyHex: String)throws  -> String {
-    return try  FfiConverterString.lift(try rustCallWithError(FfiConverterTypePcztError.lift) {
-    uniffi_keystone_wallet_core_fn_func_extract_and_finalize_pczt(
-        FfiConverterString.lower(pcztHex),
-        FfiConverterUInt32.lower(expiryHeight),
-        FfiConverterString.lower(privateKeyHex),$0
+public func deriveAddressByPathAda(accountXpubHex: String, path: String, network: CardanoNetwork)throws  -> String {
+    return try  FfiConverterString.lift(try rustCallWithError(FfiConverterTypeWalletError.lift) {
+    uniffi_keystone_wallet_core_fn_func_derive_address_by_path_ada(
+        FfiConverterString.lower(accountXpubHex),
+        FfiConverterString.lower(path),
+        FfiConverterTypeCardanoNetwork.lower(network),$0
     )
 })
 }
-public func extractPcztTransaction(pcztHex: String)throws  -> String {
+public func deriveEnterpriseAddressByPathAda(accountXpubHex: String, path: String, network: CardanoNetwork)throws  -> String {
+    return try  FfiConverterString.lift(try rustCallWithError(FfiConverterTypeWalletError.lift) {
+    uniffi_keystone_wallet_core_fn_func_derive_enterprise_address_by_path_ada(
+        FfiConverterString.lower(accountXpubHex),
+        FfiConverterString.lower(path),
+        FfiConverterTypeCardanoNetwork.lower(network),$0
+    )
+})
+}
+public func derivePubkeyByPathAda(accountXpubHex: String, path: String)throws  -> DerivedKeys {
+    return try  FfiConverterTypeDerivedKeys.lift(try rustCallWithError(FfiConverterTypeWalletError.lift) {
+    uniffi_keystone_wallet_core_fn_func_derive_pubkey_by_path_ada(
+        FfiConverterString.lower(accountXpubHex),
+        FfiConverterString.lower(path),$0
+    )
+})
+}
+public func deriveStakeAddressAda(accountXpubHex: String, network: CardanoNetwork)throws  -> String {
+    return try  FfiConverterString.lift(try rustCallWithError(FfiConverterTypeWalletError.lift) {
+    uniffi_keystone_wallet_core_fn_func_derive_stake_address_ada(
+        FfiConverterString.lower(accountXpubHex),
+        FfiConverterTypeCardanoNetwork.lower(network),$0
+    )
+})
+}
+public func finalizeThenExtractPcztTransaction(pcztHex: String)throws  -> String {
     return try  FfiConverterString.lift(try rustCallWithError(FfiConverterTypePcztError.lift) {
-    uniffi_keystone_wallet_core_fn_func_extract_pczt_transaction(
+    uniffi_keystone_wallet_core_fn_func_finalize_then_extract_pczt_transaction(
         FfiConverterString.lower(pcztHex),$0
     )
 })
 }
+public func hello() {try! rustCall() {
+    uniffi_keystone_wallet_core_fn_func_hello($0
+    )
+}
+}
 
 private enum InitializationResult {
     case ok
@@ -994,16 +1541,34 @@ private var initializationResult: InitializationResult = {
     if bindings_contract_version != scaffolding_contract_version {
         return InitializationResult.contractVersionMismatch
     }
+    if (uniffi_keystone_wallet_core_checksum_func_assemble_transaction_ada() != 22105) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_keystone_wallet_core_checksum_func_compose_transaction_ada() != 48909) {
+        return InitializationResult.apiChecksumMismatch
+    }
     if (uniffi_keystone_wallet_core_checksum_func_create_pczt() != 11746) {
         return InitializationResult.apiChecksumMismatch
     }
     if (uniffi_keystone_wallet_core_checksum_func_create_transparent_pczt() != 17127) {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_keystone_wallet_core_checksum_func_extract_and_finalize_pczt() != 38408) {
+    if (uniffi_keystone_wallet_core_checksum_func_derive_address_by_path_ada() != 24523) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_keystone_wallet_core_checksum_func_derive_enterprise_address_by_path_ada() != 54377) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_keystone_wallet_core_checksum_func_derive_pubkey_by_path_ada() != 53793) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_keystone_wallet_core_checksum_func_derive_stake_address_ada() != 22900) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_keystone_wallet_core_checksum_func_finalize_then_extract_pczt_transaction() != 23392) {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_keystone_wallet_core_checksum_func_extract_pczt_transaction() != 4075) {
+    if (uniffi_keystone_wallet_core_checksum_func_hello() != 6912) {
         return InitializationResult.apiChecksumMismatch
     }
     if (uniffi_keystone_wallet_core_checksum_method_pczt_serialize() != 18950) {

package/lib/commonjs/index.js

@@ -3,8 +3,15 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.CardanoNetwork = void 0;
+exports.assembleTransactionAda = assembleTransactionAda;
+exports.composeTransactionAda = composeTransactionAda;
 exports.createTransparentPczt = createTransparentPczt;
-exports.extractPcztTransaction = extractPcztTransaction;
+exports.deriveAddressByPathAda = deriveAddressByPathAda;
+exports.deriveEnterpriseAddressByPathAda = deriveEnterpriseAddressByPathAda;
+exports.derivePubkeyByPathAda = derivePubkeyByPathAda;
+exports.deriveStakeAddressAda = deriveStakeAddressAda;
+exports.finalizeThenExtractPcztTransaction = finalizeThenExtractPcztTransaction;
 var _reactNative = require("react-native");
 const LINKING_ERROR = `The package 'react-native-keystone-wallet-core' doesn't seem to be linked. Make sure: \n\n` + (_reactNative.Platform.select({
   ios: "- You have run 'pod install'\n",
@@ -18,7 +25,30 @@ const KeystoneWalletCoreModule = _reactNative.NativeModules.KeystoneWalletCoreMo
 function createTransparentPczt(inputs, outputs, blockHeight) {
   return KeystoneWalletCoreModule.createTransparentPczt(inputs, outputs, blockHeight);
 }
-function extractPcztTransaction(pcztHex) {
-  return KeystoneWalletCoreModule.extractPcztTransaction(pcztHex);
+function finalizeThenExtractPcztTransaction(pcztHex) {
+  return KeystoneWalletCoreModule.finalizeThenExtractPcztTransaction(pcztHex);
+}
+let CardanoNetwork = exports.CardanoNetwork = /*#__PURE__*/function (CardanoNetwork) {
+  CardanoNetwork["Mainnet"] = "Mainnet";
+  CardanoNetwork["Testnet"] = "Testnet";
+  return CardanoNetwork;
+}({});
+function derivePubkeyByPathAda(accountXpubHex, path) {
+  return KeystoneWalletCoreModule.derivePubkeyByPathAda(accountXpubHex, path);
+}
+function deriveAddressByPathAda(accountXpubHex, path, network) {
+  return KeystoneWalletCoreModule.deriveAddressByPathAda(accountXpubHex, path, network);
+}
+function deriveEnterpriseAddressByPathAda(accountXpubHex, path, network) {
+  return KeystoneWalletCoreModule.deriveEnterpriseAddressByPathAda(accountXpubHex, path, network);
+}
+function deriveStakeAddressAda(accountXpubHex, network) {
+  return KeystoneWalletCoreModule.deriveStakeAddressAda(accountXpubHex, network);
+}
+function composeTransactionAda(inputs, outputs, changeAddress, fee, ttl, network) {
+  return KeystoneWalletCoreModule.composeTransactionAda(inputs, outputs, changeAddress, fee, ttl, network);
+}
+function assembleTransactionAda(rawTxHex, witnessSetHex) {
+  return KeystoneWalletCoreModule.assembleTransactionAda(rawTxHex, witnessSetHex);
 }
 //# sourceMappingURL=index.js.map