diff --git a/.gitattributes b/.gitattributes index 352f149..40283b4 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1 +1,2 @@ *.a filter=lfs diff=lfs merge=lfs -text +*.dylib filter=lfs diff=lfs merge=lfs -text diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index c89b936..b5544b5 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -81,6 +81,6 @@ jobs: tool: cargo-swift - name: Generate Swift package - run: cargo swift package -p ios -n WalletSdkRs + run: cargo swift package -p ios -n WalletSdkRs --lib-type dynamic - name: Fail if generated swift code needs update run: git diff --exit-code WalletSdkRs/Sources/WalletSdkRs/wallet_sdk_rs.swift diff --git a/.gitignore b/.gitignore index 6319670..37eefdb 100644 --- a/.gitignore +++ b/.gitignore @@ -2,3 +2,4 @@ /generated .build WalletSdkRs/Package.swift +.swiftpm diff --git a/Derived/InfoPlists/WalletSdkRs-Info.plist b/Derived/InfoPlists/WalletSdkRs-Info.plist new file mode 100644 index 0000000..323e5ec --- /dev/null +++ b/Derived/InfoPlists/WalletSdkRs-Info.plist @@ -0,0 +1,22 @@ + + + + + CFBundleDevelopmentRegion + $(DEVELOPMENT_LANGUAGE) + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + $(PRODUCT_NAME) + CFBundlePackageType + FMWK + CFBundleShortVersionString + 1.0 + CFBundleVersion + 1 + + diff --git a/WalletSdkRs.xcodeproj/project.pbxproj b/WalletSdkRs.xcodeproj/project.pbxproj new file mode 100644 index 0000000..60ccd4f --- /dev/null +++ b/WalletSdkRs.xcodeproj/project.pbxproj @@ -0,0 +1,444 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 55; + objects = { + +/* Begin PBXBuildFile section */ + 38E734383E3E1498F95C2328 /* wallet_sdk_rs.swift in Sources */ = {isa = PBXBuildFile; fileRef = E9D1B746337C66679B4ED482 /* wallet_sdk_rs.swift */; }; + 450AEB618744585F0BEF229A /* RustFramework.xcframework in Static XCFramework Dependencies */ = {isa = PBXBuildFile; fileRef = 7A41FCE148C0FB35D9689F3E /* RustFramework.xcframework */; }; +/* End PBXBuildFile section */ + +/* Begin PBXCopyFilesBuildPhase section */ + 7A0970155A88B5FEBAF3A1BB /* Static XCFramework Dependencies */ = { + isa = PBXCopyFilesBuildPhase; + buildActionMask = 8; + dstPath = _StaticXCFrameworkDependencies/WalletSdkRs; + dstSubfolderSpec = 16; + files = ( + 450AEB618744585F0BEF229A /* RustFramework.xcframework in Static XCFramework Dependencies */, + ); + name = "Static XCFramework Dependencies"; + runOnlyForDeploymentPostprocessing = 1; + }; + E83897E7A27C778DC75772FA /* Embed Frameworks */ = { + isa = PBXCopyFilesBuildPhase; + buildActionMask = 2147483647; + dstPath = ""; + dstSubfolderSpec = 10; + files = ( + ); + name = "Embed Frameworks"; + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXCopyFilesBuildPhase section */ + +/* Begin PBXFileReference section */ + 1B218750EE0694D324B96B77 /* WalletSdkRs-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist; path = "WalletSdkRs-Info.plist"; sourceTree = ""; }; + 7A41FCE148C0FB35D9689F3E /* RustFramework.xcframework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcframework; path = RustFramework.xcframework; sourceTree = ""; }; + E9CEC10BCC3806980F7C6698 /* WalletSdkRs.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = WalletSdkRs.framework; sourceTree = BUILT_PRODUCTS_DIR; }; + E9D1B746337C66679B4ED482 /* wallet_sdk_rs.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = wallet_sdk_rs.swift; sourceTree = ""; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 0DDDC4C16D83A05BB399883A /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 333CC97695BEDA6DD4B166DF /* Products */ = { + isa = PBXGroup; + children = ( + E9CEC10BCC3806980F7C6698 /* WalletSdkRs.framework */, + ); + name = Products; + sourceTree = ""; + }; + 633A411F2DE716CB4CDAE625 /* WalletSdkRs */ = { + isa = PBXGroup; + children = ( + 6527FAAE2E5E2D333F24F549 /* Sources */, + 7A41FCE148C0FB35D9689F3E /* RustFramework.xcframework */, + ); + path = WalletSdkRs; + sourceTree = ""; + }; + 6527FAAE2E5E2D333F24F549 /* Sources */ = { + isa = PBXGroup; + children = ( + 7318F796102C2090A079A90D /* WalletSdkRs */, + ); + path = Sources; + sourceTree = ""; + }; + 7318F796102C2090A079A90D /* WalletSdkRs */ = { + isa = PBXGroup; + children = ( + E9D1B746337C66679B4ED482 /* wallet_sdk_rs.swift */, + ); + path = WalletSdkRs; + sourceTree = ""; + }; + 96CF76908FAF8BB4E3395580 /* Compiled */ = { + isa = PBXGroup; + children = ( + ); + name = Compiled; + sourceTree = ""; + }; + A493A8BC2EAC9E3707C60F82 = { + isa = PBXGroup; + children = ( + D90FE7F4B014784168390C9F /* Project */, + 96CF76908FAF8BB4E3395580 /* Compiled */, + 333CC97695BEDA6DD4B166DF /* Products */, + ); + sourceTree = ""; + }; + D90FE7F4B014784168390C9F /* Project */ = { + isa = PBXGroup; + children = ( + F3FCD0BA5E90400DD52C0B4A /* Derived */, + 633A411F2DE716CB4CDAE625 /* WalletSdkRs */, + ); + name = Project; + sourceTree = ""; + }; + F2AD9CFB1E0A7285B7CE67FA /* InfoPlists */ = { + isa = PBXGroup; + children = ( + 1B218750EE0694D324B96B77 /* WalletSdkRs-Info.plist */, + ); + path = InfoPlists; + sourceTree = ""; + }; + F3FCD0BA5E90400DD52C0B4A /* Derived */ = { + isa = PBXGroup; + children = ( + F2AD9CFB1E0A7285B7CE67FA /* InfoPlists */, + ); + path = Derived; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + 0520066DAB350462FFF21054 /* WalletSdkRs */ = { + isa = PBXNativeTarget; + buildConfigurationList = F0EF904FD305D6AA0B5DB9C6 /* Build configuration list for PBXNativeTarget "WalletSdkRs" */; + buildPhases = ( + 66BBA529758BD1A9353140BE /* Sources */, + 7F473E3C3DFA598367A136F5 /* Resources */, + E83897E7A27C778DC75772FA /* Embed Frameworks */, + 0DDDC4C16D83A05BB399883A /* Frameworks */, + 7A0970155A88B5FEBAF3A1BB /* Static XCFramework Dependencies */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = WalletSdkRs; + productName = WalletSdkRs; + productReference = E9CEC10BCC3806980F7C6698 /* WalletSdkRs.framework */; + productType = "com.apple.product-type.framework"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 11A4714882C5854D93108443 /* Project object */ = { + isa = PBXProject; + attributes = { + BuildIndependentTargetsInParallel = YES; + LastUpgradeCheck = 9999; + TargetAttributes = { + }; + }; + buildConfigurationList = 3581E3B3E44193DC7E6CB2E3 /* Build configuration list for PBXProject "WalletSdkRs" */; + compatibilityVersion = "Xcode 14.0"; + developmentRegion = en; + hasScannedForEncodings = 0; + knownRegions = ( + Base, + en, + ); + mainGroup = A493A8BC2EAC9E3707C60F82; + productRefGroup = 333CC97695BEDA6DD4B166DF /* Products */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + 0520066DAB350462FFF21054 /* WalletSdkRs */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXResourcesBuildPhase section */ + 7F473E3C3DFA598367A136F5 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + 66BBA529758BD1A9353140BE /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 38E734383E3E1498F95C2328 /* wallet_sdk_rs.swift in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + 7054448E84CA61342F57D836 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = YES; + CLANG_ENABLE_OBJC_WEAK = NO; + CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = NO; + CODE_SIGN_IDENTITY = ""; + CURRENT_PROJECT_VERSION = 1; + DEFINES_MODULE = YES; + DYLIB_COMPATIBILITY_VERSION = 1; + DYLIB_CURRENT_VERSION = 1; + DYLIB_INSTALL_NAME_BASE = "@rpath"; + ENABLE_STRICT_OBJC_MSGSEND = NO; + FRAMEWORK_SEARCH_PATHS = ( + "$(inherited)", + "$(PLATFORM_DIR)/Developer/Library/Frameworks", + ); + GCC_NO_COMMON_BLOCKS = NO; + GCC_PREPROCESSOR_DEFINITIONS = ( + "$(inherited)", + "SWIFT_PACKAGE=1", + ); + GCC_WARN_INHIBIT_ALL_WARNINGS = YES; + INFOPLIST_FILE = "Derived/InfoPlists/WalletSdkRs-Info.plist"; + INSTALL_PATH = "$(LOCAL_LIBRARY_DIR)/Frameworks"; + IPHONEOS_DEPLOYMENT_TARGET = 13.0; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/Frameworks", + "@loader_path/Frameworks", + ); + MACH_O_TYPE = staticlib; + PRODUCT_BUNDLE_IDENTIFIER = WalletSdkRs; + PRODUCT_NAME = WalletSdkRs; + SDKROOT = iphoneos; + SKIP_INSTALL = YES; + SUPPORTS_MACCATALYST = NO; + SUPPORTS_MAC_DESIGNED_FOR_IPHONE_IPAD = YES; + SUPPORTS_XR_DESIGNED_FOR_IPHONE_IPAD = YES; + SWIFT_ACTIVE_COMPILATION_CONDITIONS = ( + "$(inherited) SWIFT_PACKAGE", + DEBUG, + ); + SWIFT_COMPILATION_MODE = singlefile; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + SWIFT_SUPPRESS_WARNINGS = YES; + SWIFT_VERSION = 5.0; + TARGETED_DEVICE_FAMILY = "1,2"; + USE_HEADERMAP = NO; + VERSIONING_SYSTEM = "apple-generic"; + VERSION_INFO_PREFIX = ""; + }; + name = Debug; + }; + A113BBC44C23A820299EA6AB /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = YES; + CLANG_ENABLE_OBJC_WEAK = NO; + CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = NO; + CODE_SIGN_IDENTITY = ""; + CURRENT_PROJECT_VERSION = 1; + DEFINES_MODULE = YES; + DYLIB_COMPATIBILITY_VERSION = 1; + DYLIB_CURRENT_VERSION = 1; + DYLIB_INSTALL_NAME_BASE = "@rpath"; + ENABLE_STRICT_OBJC_MSGSEND = NO; + FRAMEWORK_SEARCH_PATHS = ( + "$(inherited)", + "$(PLATFORM_DIR)/Developer/Library/Frameworks", + ); + GCC_NO_COMMON_BLOCKS = NO; + GCC_PREPROCESSOR_DEFINITIONS = ( + "$(inherited)", + "SWIFT_PACKAGE=1", + ); + GCC_WARN_INHIBIT_ALL_WARNINGS = YES; + INFOPLIST_FILE = "Derived/InfoPlists/WalletSdkRs-Info.plist"; + INSTALL_PATH = "$(LOCAL_LIBRARY_DIR)/Frameworks"; + IPHONEOS_DEPLOYMENT_TARGET = 13.0; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/Frameworks", + "@loader_path/Frameworks", + ); + MACH_O_TYPE = staticlib; + PRODUCT_BUNDLE_IDENTIFIER = WalletSdkRs; + PRODUCT_NAME = WalletSdkRs; + SDKROOT = iphoneos; + SKIP_INSTALL = YES; + SUPPORTS_MACCATALYST = NO; + SUPPORTS_MAC_DESIGNED_FOR_IPHONE_IPAD = YES; + SUPPORTS_XR_DESIGNED_FOR_IPHONE_IPAD = YES; + SWIFT_ACTIVE_COMPILATION_CONDITIONS = "$(inherited) SWIFT_PACKAGE"; + SWIFT_COMPILATION_MODE = wholemodule; + SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule"; + SWIFT_SUPPRESS_WARNINGS = YES; + SWIFT_VERSION = 5.0; + TARGETED_DEVICE_FAMILY = "1,2"; + USE_HEADERMAP = NO; + VERSIONING_SYSTEM = "apple-generic"; + VERSION_INFO_PREFIX = ""; + }; + name = Release; + }; + D6BB70B01D0683DA42D14874 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_ENABLE_OBJC_WEAK = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + COPY_PHASE_STRIP = NO; + DEAD_CODE_STRIPPING = YES; + DEBUG_INFORMATION_FORMAT = dwarf; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_TESTABILITY = YES; + GCC_C_LANGUAGE_STANDARD = gnu11; + GCC_DYNAMIC_NO_PIC = NO; + GCC_NO_COMMON_BLOCKS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + MTL_ENABLE_DEBUG_INFO = YES; + ONLY_ACTIVE_ARCH = YES; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Debug; + }; + FC102D2D5907F98D52EC8272 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_ENABLE_OBJC_WEAK = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + COPY_PHASE_STRIP = NO; + DEAD_CODE_STRIPPING = YES; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + GCC_C_LANGUAGE_STANDARD = gnu11; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + MTL_ENABLE_DEBUG_INFO = NO; + PRODUCT_NAME = "$(TARGET_NAME)"; + VALIDATE_PRODUCT = YES; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 3581E3B3E44193DC7E6CB2E3 /* Build configuration list for PBXProject "WalletSdkRs" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + D6BB70B01D0683DA42D14874 /* Debug */, + FC102D2D5907F98D52EC8272 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + F0EF904FD305D6AA0B5DB9C6 /* Build configuration list for PBXNativeTarget "WalletSdkRs" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 7054448E84CA61342F57D836 /* Debug */, + A113BBC44C23A820299EA6AB /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 11A4714882C5854D93108443 /* Project object */; +} diff --git a/WalletSdkRs.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/WalletSdkRs.xcodeproj/project.xcworkspace/contents.xcworkspacedata new file mode 100644 index 0000000..919434a --- /dev/null +++ b/WalletSdkRs.xcodeproj/project.xcworkspace/contents.xcworkspacedata @@ -0,0 +1,7 @@ + + + + + diff --git a/WalletSdkRs.xcodeproj/xcuserdata/sbihel.xcuserdatad/xcschemes/xcschememanagement.plist b/WalletSdkRs.xcodeproj/xcuserdata/sbihel.xcuserdatad/xcschemes/xcschememanagement.plist new file mode 100644 index 0000000..0241c9f --- /dev/null +++ b/WalletSdkRs.xcodeproj/xcuserdata/sbihel.xcuserdatad/xcschemes/xcschememanagement.plist @@ -0,0 +1,8 @@ + + + + + SchemeUserState + + + diff --git a/WalletSdkRs/RustFramework.xcframework/Info.plist b/WalletSdkRs/RustFramework.xcframework/Info.plist index 5f7b6a2..a2b41f8 100644 --- a/WalletSdkRs/RustFramework.xcframework/Info.plist +++ b/WalletSdkRs/RustFramework.xcframework/Info.plist @@ -6,38 +6,38 @@ BinaryPath - libwallet_sdk_rs.a + libwallet_sdk_rs.dylib HeadersPath Headers LibraryIdentifier - ios-arm64_x86_64-simulator + ios-arm64 LibraryPath - libwallet_sdk_rs.a + libwallet_sdk_rs.dylib SupportedArchitectures arm64 - x86_64 SupportedPlatform ios - SupportedPlatformVariant - simulator BinaryPath - libwallet_sdk_rs.a + libwallet_sdk_rs.dylib HeadersPath Headers LibraryIdentifier - ios-arm64 + ios-arm64_x86_64-simulator LibraryPath - libwallet_sdk_rs.a + libwallet_sdk_rs.dylib SupportedArchitectures arm64 + x86_64 SupportedPlatform ios + SupportedPlatformVariant + simulator CFBundlePackageType diff --git a/WalletSdkRs/RustFramework.xcframework/ios-arm64/Headers/wallet_sdk_rsFFI.h b/WalletSdkRs/RustFramework.xcframework/ios-arm64/Headers/wallet_sdk_rsFFI.h index d5d192b..7ce3e47 100644 --- a/WalletSdkRs/RustFramework.xcframework/ios-arm64/Headers/wallet_sdk_rsFFI.h +++ b/WalletSdkRs/RustFramework.xcframework/ios-arm64/Headers/wallet_sdk_rsFFI.h @@ -63,14 +63,24 @@ typedef struct RustCallStatus { typedef void (*UniFfiRustFutureContinuation)(void * _Nonnull, int8_t); // Scaffolding functions +void uniffi_wallet_sdk_rs_fn_free_mdoc(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +void*_Nonnull uniffi_wallet_sdk_rs_fn_constructor_mdoc_from_cbor(RustBuffer value, RustCallStatus *_Nonnull out_status +); +RustBuffer uniffi_wallet_sdk_rs_fn_method_mdoc_id(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +void uniffi_wallet_sdk_rs_fn_free_sessionmanager(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); RustBuffer uniffi_wallet_sdk_rs_fn_func_handle_request(RustBuffer state, RustBuffer request, RustCallStatus *_Nonnull out_status ); RustBuffer uniffi_wallet_sdk_rs_fn_func_hello_ffi(RustCallStatus *_Nonnull out_status ); -RustBuffer uniffi_wallet_sdk_rs_fn_func_initialise_session(RustBuffer document, RustBuffer uuid, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_wallet_sdk_rs_fn_func_initialise_session(void*_Nonnull document, RustBuffer uuid, RustCallStatus *_Nonnull out_status +); +RustBuffer uniffi_wallet_sdk_rs_fn_func_submit_response(void*_Nonnull session_manager, RustBuffer items_requests, RustBuffer permitted_items, RustCallStatus *_Nonnull out_status ); -RustBuffer uniffi_wallet_sdk_rs_fn_func_submit_signature(RustBuffer state, RustBuffer signature, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_wallet_sdk_rs_fn_func_submit_signature(void*_Nonnull session_manager, RustBuffer signature, RustCallStatus *_Nonnull out_status ); RustBuffer uniffi_wallet_sdk_rs_fn_func_terminate_session(RustCallStatus *_Nonnull out_status @@ -197,12 +207,21 @@ uint16_t uniffi_wallet_sdk_rs_checksum_func_hello_ffi(void ); uint16_t uniffi_wallet_sdk_rs_checksum_func_initialise_session(void +); +uint16_t uniffi_wallet_sdk_rs_checksum_func_submit_response(void + ); uint16_t uniffi_wallet_sdk_rs_checksum_func_submit_signature(void ); uint16_t uniffi_wallet_sdk_rs_checksum_func_terminate_session(void +); +uint16_t uniffi_wallet_sdk_rs_checksum_method_mdoc_id(void + +); +uint16_t uniffi_wallet_sdk_rs_checksum_constructor_mdoc_from_cbor(void + ); uint32_t ffi_wallet_sdk_rs_uniffi_contract_version(void diff --git a/WalletSdkRs/RustFramework.xcframework/ios-arm64/libwallet_sdk_rs.a b/WalletSdkRs/RustFramework.xcframework/ios-arm64/libwallet_sdk_rs.a deleted file mode 100644 index 65accdc..0000000 --- a/WalletSdkRs/RustFramework.xcframework/ios-arm64/libwallet_sdk_rs.a +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:a947c1390c07fbeb1a70b3071b4839f568c0d24fdc0ae6c085982a5f17a0e531 -size 92732640 diff --git a/WalletSdkRs/RustFramework.xcframework/ios-arm64/libwallet_sdk_rs.dylib b/WalletSdkRs/RustFramework.xcframework/ios-arm64/libwallet_sdk_rs.dylib new file mode 100755 index 0000000..8a9067d --- /dev/null +++ b/WalletSdkRs/RustFramework.xcframework/ios-arm64/libwallet_sdk_rs.dylib @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4f0b6588bf0755b18cc839ca37724a4a9511492b4110d6c95d8aee33e2f01ff9 +size 2898960 diff --git a/WalletSdkRs/RustFramework.xcframework/ios-arm64_x86_64-simulator/Headers/wallet_sdk_rsFFI.h b/WalletSdkRs/RustFramework.xcframework/ios-arm64_x86_64-simulator/Headers/wallet_sdk_rsFFI.h index d5d192b..7ce3e47 100644 --- a/WalletSdkRs/RustFramework.xcframework/ios-arm64_x86_64-simulator/Headers/wallet_sdk_rsFFI.h +++ b/WalletSdkRs/RustFramework.xcframework/ios-arm64_x86_64-simulator/Headers/wallet_sdk_rsFFI.h @@ -63,14 +63,24 @@ typedef struct RustCallStatus { typedef void (*UniFfiRustFutureContinuation)(void * _Nonnull, int8_t); // Scaffolding functions +void uniffi_wallet_sdk_rs_fn_free_mdoc(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +void*_Nonnull uniffi_wallet_sdk_rs_fn_constructor_mdoc_from_cbor(RustBuffer value, RustCallStatus *_Nonnull out_status +); +RustBuffer uniffi_wallet_sdk_rs_fn_method_mdoc_id(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); +void uniffi_wallet_sdk_rs_fn_free_sessionmanager(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status +); RustBuffer uniffi_wallet_sdk_rs_fn_func_handle_request(RustBuffer state, RustBuffer request, RustCallStatus *_Nonnull out_status ); RustBuffer uniffi_wallet_sdk_rs_fn_func_hello_ffi(RustCallStatus *_Nonnull out_status ); -RustBuffer uniffi_wallet_sdk_rs_fn_func_initialise_session(RustBuffer document, RustBuffer uuid, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_wallet_sdk_rs_fn_func_initialise_session(void*_Nonnull document, RustBuffer uuid, RustCallStatus *_Nonnull out_status +); +RustBuffer uniffi_wallet_sdk_rs_fn_func_submit_response(void*_Nonnull session_manager, RustBuffer items_requests, RustBuffer permitted_items, RustCallStatus *_Nonnull out_status ); -RustBuffer uniffi_wallet_sdk_rs_fn_func_submit_signature(RustBuffer state, RustBuffer signature, RustCallStatus *_Nonnull out_status +RustBuffer uniffi_wallet_sdk_rs_fn_func_submit_signature(void*_Nonnull session_manager, RustBuffer signature, RustCallStatus *_Nonnull out_status ); RustBuffer uniffi_wallet_sdk_rs_fn_func_terminate_session(RustCallStatus *_Nonnull out_status @@ -197,12 +207,21 @@ uint16_t uniffi_wallet_sdk_rs_checksum_func_hello_ffi(void ); uint16_t uniffi_wallet_sdk_rs_checksum_func_initialise_session(void +); +uint16_t uniffi_wallet_sdk_rs_checksum_func_submit_response(void + ); uint16_t uniffi_wallet_sdk_rs_checksum_func_submit_signature(void ); uint16_t uniffi_wallet_sdk_rs_checksum_func_terminate_session(void +); +uint16_t uniffi_wallet_sdk_rs_checksum_method_mdoc_id(void + +); +uint16_t uniffi_wallet_sdk_rs_checksum_constructor_mdoc_from_cbor(void + ); uint32_t ffi_wallet_sdk_rs_uniffi_contract_version(void diff --git a/WalletSdkRs/RustFramework.xcframework/ios-arm64_x86_64-simulator/libwallet_sdk_rs.a b/WalletSdkRs/RustFramework.xcframework/ios-arm64_x86_64-simulator/libwallet_sdk_rs.a deleted file mode 100644 index a9b97f6..0000000 --- a/WalletSdkRs/RustFramework.xcframework/ios-arm64_x86_64-simulator/libwallet_sdk_rs.a +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:58febeccaa0889368d270318d871e2339ecd4dc38f89af63db2f2ac73bc202cb -size 130930616 diff --git a/WalletSdkRs/RustFramework.xcframework/ios-arm64_x86_64-simulator/libwallet_sdk_rs.dylib b/WalletSdkRs/RustFramework.xcframework/ios-arm64_x86_64-simulator/libwallet_sdk_rs.dylib new file mode 100755 index 0000000..8910a4e --- /dev/null +++ b/WalletSdkRs/RustFramework.xcframework/ios-arm64_x86_64-simulator/libwallet_sdk_rs.dylib @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a3eeaefd2fc4daffb365cf31434147eb8456748d266d34d1b609d9d9d3d7c6c2 +size 6017416 diff --git a/WalletSdkRs/Sources/WalletSdkRs/wallet_sdk_rs.swift b/WalletSdkRs/Sources/WalletSdkRs/wallet_sdk_rs.swift index 398f890..2f9b85e 100644 --- a/WalletSdkRs/Sources/WalletSdkRs/wallet_sdk_rs.swift +++ b/WalletSdkRs/Sources/WalletSdkRs/wallet_sdk_rs.swift @@ -297,6 +297,27 @@ private func uniffiCheckCallStatus( // Public interface members begin here. +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)) + } +} + fileprivate struct FfiConverterString: FfiConverter { typealias SwiftType = String typealias FfiType = RustBuffer @@ -335,57 +356,251 @@ fileprivate struct FfiConverterString: FfiConverter { } } +fileprivate struct FfiConverterData: FfiConverterRustBuffer { + typealias SwiftType = Data -public struct RequestData { - public var state: String - public var payload: String - public var requestedValues: String + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Data { + let len: Int32 = try readInt(&buf) + return Data(try readBytes(&buf, count: Int(len))) + } + + public static func write(_ value: Data, into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + writeBytes(&buf, value) + } +} + + +public protocol MDocProtocol { + func id() -> Uuid + +} + +public class MDoc: MDocProtocol { + 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 { uniffi_wallet_sdk_rs_fn_free_mdoc(pointer, $0) } + } + + + + public static func fromCbor(value: Data) throws -> MDoc { + return MDoc(unsafeFromRawPointer: try rustCallWithError(FfiConverterTypeMDocInitError.lift) { + uniffi_wallet_sdk_rs_fn_constructor_mdoc_from_cbor( + FfiConverterData.lower(value),$0) +}) + } + + + + + + + public func id() -> Uuid { + return try! FfiConverterTypeUuid.lift( + try! + rustCall() { + + uniffi_wallet_sdk_rs_fn_method_mdoc_id(self.pointer, $0 + ) +} + ) + } +} + +public struct FfiConverterTypeMDoc: FfiConverter { + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = MDoc + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MDoc { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: MDoc, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> MDoc { + return MDoc(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: MDoc) -> UnsafeMutableRawPointer { + return value.pointer + } +} + + +public func FfiConverterTypeMDoc_lift(_ pointer: UnsafeMutableRawPointer) throws -> MDoc { + return try FfiConverterTypeMDoc.lift(pointer) +} + +public func FfiConverterTypeMDoc_lower(_ value: MDoc) -> UnsafeMutableRawPointer { + return FfiConverterTypeMDoc.lower(value) +} + + +public protocol SessionManagerProtocol { + +} + +public class SessionManager: SessionManagerProtocol { + 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 { uniffi_wallet_sdk_rs_fn_free_sessionmanager(pointer, $0) } + } + + + + + +} + +public struct FfiConverterTypeSessionManager: FfiConverter { + typealias FfiType = UnsafeMutableRawPointer + typealias SwiftType = SessionManager + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SessionManager { + let v: UInt64 = try readInt(&buf) + // The Rust code won't compile if a pointer won't fit in a UInt64. + // We have to go via `UInt` because that's the thing that's the size of a pointer. + let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v)) + if (ptr == nil) { + throw UniffiInternalError.unexpectedNullPointer + } + return try lift(ptr!) + } + + public static func write(_ value: SessionManager, into buf: inout [UInt8]) { + // This fiddling is because `Int` is the thing that's the same size as a pointer. + // The Rust code won't compile if a pointer won't fit in a `UInt64`. + writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value))))) + } + + public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> SessionManager { + return SessionManager(unsafeFromRawPointer: pointer) + } + + public static func lower(_ value: SessionManager) -> UnsafeMutableRawPointer { + return value.pointer + } +} + + +public func FfiConverterTypeSessionManager_lift(_ pointer: UnsafeMutableRawPointer) throws -> SessionManager { + return try FfiConverterTypeSessionManager.lift(pointer) +} + +public func FfiConverterTypeSessionManager_lower(_ value: SessionManager) -> UnsafeMutableRawPointer { + return FfiConverterTypeSessionManager.lower(value) +} + + +public struct ItemsRequest { + public var docType: String + public var namespaces: [String: [String: Bool]] // Default memberwise initializers are never public by default, so we // declare one manually. - public init(state: String, payload: String, requestedValues: String) { - self.state = state - self.payload = payload - self.requestedValues = requestedValues + public init(docType: String, namespaces: [String: [String: Bool]]) { + self.docType = docType + self.namespaces = namespaces } } -extension RequestData: Equatable, Hashable { - public static func ==(lhs: RequestData, rhs: RequestData) -> Bool { - if lhs.state != rhs.state { +extension ItemsRequest: Equatable, Hashable { + public static func ==(lhs: ItemsRequest, rhs: ItemsRequest) -> Bool { + if lhs.docType != rhs.docType { return false } - if lhs.payload != rhs.payload { - return false - } - if lhs.requestedValues != rhs.requestedValues { + if lhs.namespaces != rhs.namespaces { return false } return true } public func hash(into hasher: inout Hasher) { - hasher.combine(state) - hasher.combine(payload) - hasher.combine(requestedValues) + hasher.combine(docType) + hasher.combine(namespaces) + } +} + + +public struct FfiConverterTypeItemsRequest: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ItemsRequest { + return try ItemsRequest( + docType: FfiConverterString.read(from: &buf), + namespaces: FfiConverterDictionaryStringDictionaryStringBool.read(from: &buf) + ) + } + + public static func write(_ value: ItemsRequest, into buf: inout [UInt8]) { + FfiConverterString.write(value.docType, into: &buf) + FfiConverterDictionaryStringDictionaryStringBool.write(value.namespaces, into: &buf) + } +} + + +public func FfiConverterTypeItemsRequest_lift(_ buf: RustBuffer) throws -> ItemsRequest { + return try FfiConverterTypeItemsRequest.lift(buf) +} + +public func FfiConverterTypeItemsRequest_lower(_ value: ItemsRequest) -> RustBuffer { + return FfiConverterTypeItemsRequest.lower(value) +} + + +public struct RequestData { + public var sessionManager: SessionManager + public var itemsRequests: [ItemsRequest] + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(sessionManager: SessionManager, itemsRequests: [ItemsRequest]) { + self.sessionManager = sessionManager + self.itemsRequests = itemsRequests } } + public struct FfiConverterTypeRequestData: FfiConverterRustBuffer { public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> RequestData { return try RequestData( - state: FfiConverterString.read(from: &buf), - payload: FfiConverterString.read(from: &buf), - requestedValues: FfiConverterString.read(from: &buf) + sessionManager: FfiConverterTypeSessionManager.read(from: &buf), + itemsRequests: FfiConverterSequenceTypeItemsRequest.read(from: &buf) ) } public static func write(_ value: RequestData, into buf: inout [UInt8]) { - FfiConverterString.write(value.state, into: &buf) - FfiConverterString.write(value.payload, into: &buf) - FfiConverterString.write(value.requestedValues, into: &buf) + FfiConverterTypeSessionManager.write(value.sessionManager, into: &buf) + FfiConverterSequenceTypeItemsRequest.write(value.itemsRequests, into: &buf) } } @@ -399,6 +614,53 @@ public func FfiConverterTypeRequestData_lower(_ value: RequestData) -> RustBuffe } +public struct ResponseData { + public var payload: Data + + // Default memberwise initializers are never public by default, so we + // declare one manually. + public init(payload: Data) { + self.payload = payload + } +} + + +extension ResponseData: Equatable, Hashable { + public static func ==(lhs: ResponseData, rhs: ResponseData) -> Bool { + if lhs.payload != rhs.payload { + return false + } + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(payload) + } +} + + +public struct FfiConverterTypeResponseData: FfiConverterRustBuffer { + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ResponseData { + return try ResponseData( + payload: FfiConverterData.read(from: &buf) + ) + } + + public static func write(_ value: ResponseData, into buf: inout [UInt8]) { + FfiConverterData.write(value.payload, into: &buf) + } +} + + +public func FfiConverterTypeResponseData_lift(_ buf: RustBuffer) throws -> ResponseData { + return try FfiConverterTypeResponseData.lift(buf) +} + +public func FfiConverterTypeResponseData_lower(_ value: ResponseData) -> RustBuffer { + return FfiConverterTypeResponseData.lower(value) +} + + public struct SessionData { public var state: String public var qrCodeUri: String @@ -464,11 +726,11 @@ public func FfiConverterTypeSessionData_lower(_ value: SessionData) -> RustBuffe public struct SignatureData { public var state: String - public var response: String + public var response: Data // Default memberwise initializers are never public by default, so we // declare one manually. - public init(state: String, response: String) { + public init(state: String, response: Data) { self.state = state self.response = response } @@ -497,13 +759,13 @@ public struct FfiConverterTypeSignatureData: FfiConverterRustBuffer { public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SignatureData { return try SignatureData( state: FfiConverterString.read(from: &buf), - response: FfiConverterString.read(from: &buf) + response: FfiConverterData.read(from: &buf) ) } public static func write(_ value: SignatureData, into buf: inout [UInt8]) { FfiConverterString.write(value.state, into: &buf) - FfiConverterString.write(value.response, into: &buf) + FfiConverterData.write(value.response, into: &buf) } } @@ -516,11 +778,60 @@ public func FfiConverterTypeSignatureData_lower(_ value: SignatureData) -> RustB return FfiConverterTypeSignatureData.lower(value) } +public enum MDocInitError { + + + + case Generic(value: String) + + fileprivate static func uniffiErrorHandler(_ error: RustBuffer) throws -> Error { + return try FfiConverterTypeMDocInitError.lift(error) + } +} + + +public struct FfiConverterTypeMDocInitError: FfiConverterRustBuffer { + typealias SwiftType = MDocInitError + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MDocInitError { + let variant: Int32 = try readInt(&buf) + switch variant { + + + + + case 1: return .Generic( + value: try FfiConverterString.read(from: &buf) + ) + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: MDocInitError, into buf: inout [UInt8]) { + switch value { + + + + + + case let .Generic(value): + writeInt(&buf, Int32(1)) + FfiConverterString.write(value, into: &buf) + + } + } +} + + +extension MDocInitError: Equatable, Hashable {} + +extension MDocInitError: Error { } + public enum RequestError { - case MissingSignature case Generic(value: String) fileprivate static func uniffiErrorHandler(_ error: RustBuffer) throws -> Error { @@ -539,6 +850,57 @@ public struct FfiConverterTypeRequestError: FfiConverterRustBuffer { + case 1: return .Generic( + value: try FfiConverterString.read(from: &buf) + ) + + default: throw UniffiInternalError.unexpectedEnumCase + } + } + + public static func write(_ value: RequestError, into buf: inout [UInt8]) { + switch value { + + + + + + case let .Generic(value): + writeInt(&buf, Int32(1)) + FfiConverterString.write(value, into: &buf) + + } + } +} + + +extension RequestError: Equatable, Hashable {} + +extension RequestError: Error { } + +public enum ResponseError { + + + + case MissingSignature + case Generic(value: String) + + fileprivate static func uniffiErrorHandler(_ error: RustBuffer) throws -> Error { + return try FfiConverterTypeResponseError.lift(error) + } +} + + +public struct FfiConverterTypeResponseError: FfiConverterRustBuffer { + typealias SwiftType = ResponseError + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ResponseError { + let variant: Int32 = try readInt(&buf) + switch variant { + + + + case 1: return .MissingSignature case 2: return .Generic( value: try FfiConverterString.read(from: &buf) @@ -548,7 +910,7 @@ public struct FfiConverterTypeRequestError: FfiConverterRustBuffer { } } - public static func write(_ value: RequestError, into buf: inout [UInt8]) { + public static func write(_ value: ResponseError, into buf: inout [UInt8]) { switch value { @@ -568,9 +930,9 @@ public struct FfiConverterTypeRequestError: FfiConverterRustBuffer { } -extension RequestError: Equatable, Hashable {} +extension ResponseError: Equatable, Hashable {} -extension RequestError: Error { } +extension ResponseError: Error { } public enum SessionError { @@ -728,6 +1090,142 @@ extension TerminationError: Equatable, Hashable {} extension TerminationError: Error { } +fileprivate struct FfiConverterSequenceString: FfiConverterRustBuffer { + typealias SwiftType = [String] + + public static func write(_ value: [String], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterString.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [String] { + let len: Int32 = try readInt(&buf) + var seq = [String]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterString.read(from: &buf)) + } + return seq + } +} + +fileprivate struct FfiConverterSequenceTypeItemsRequest: FfiConverterRustBuffer { + typealias SwiftType = [ItemsRequest] + + public static func write(_ value: [ItemsRequest], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for item in value { + FfiConverterTypeItemsRequest.write(item, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [ItemsRequest] { + let len: Int32 = try readInt(&buf) + var seq = [ItemsRequest]() + seq.reserveCapacity(Int(len)) + for _ in 0 ..< len { + seq.append(try FfiConverterTypeItemsRequest.read(from: &buf)) + } + return seq + } +} + +fileprivate struct FfiConverterDictionaryStringBool: FfiConverterRustBuffer { + public static func write(_ value: [String: Bool], into buf: inout [UInt8]) { + let len = Int32(value.count) + writeInt(&buf, len) + for (key, value) in value { + FfiConverterString.write(key, into: &buf) + FfiConverterBool.write(value, into: &buf) + } + } + + public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [String: Bool] { + let len: Int32 = try readInt(&buf) + var dict = [String: Bool]() + dict.reserveCapacity(Int(len)) + for _ in 0.. [String: [String]] { + let len: Int32 = try readInt(&buf) + var dict = [String: [String]]() + dict.reserveCapacity(Int(len)) + for _ in 0.. [String: [String: Bool]] { + let len: Int32 = try readInt(&buf) + var dict = [String: [String: Bool]]() + dict.reserveCapacity(Int(len)) + for _ in 0.. [String: [String: [String]]] { + let len: Int32 = try readInt(&buf) + var dict = [String: [String: [String]]]() + dict.reserveCapacity(Int(len)) + for _ in 0.. RustBuffer { return FfiConverterTypeUuid.lower(value) } -public func handleRequest(state: String, request: String) throws -> RequestData { +public func handleRequest(state: String, request: Data) throws -> RequestData { return try FfiConverterTypeRequestData.lift( try rustCallWithError(FfiConverterTypeRequestError.lift) { uniffi_wallet_sdk_rs_fn_func_handle_request( FfiConverterString.lower(state), - FfiConverterString.lower(request),$0) + FfiConverterData.lower(request),$0) } ) } @@ -779,22 +1277,33 @@ public func helloFfi() -> String { ) } -public func initialiseSession(document: String, uuid: Uuid) throws -> SessionData { +public func initialiseSession(document: MDoc, uuid: Uuid) throws -> SessionData { return try FfiConverterTypeSessionData.lift( try rustCallWithError(FfiConverterTypeSessionError.lift) { uniffi_wallet_sdk_rs_fn_func_initialise_session( - FfiConverterString.lower(document), + FfiConverterTypeMDoc.lower(document), FfiConverterTypeUuid.lower(uuid),$0) } ) } -public func submitSignature(state: String, signature: String) throws -> SignatureData { +public func submitResponse(sessionManager: SessionManager, itemsRequests: [ItemsRequest], permittedItems: [String: [String: [String]]]) throws -> ResponseData { + return try FfiConverterTypeResponseData.lift( + try rustCallWithError(FfiConverterTypeResponseError.lift) { + uniffi_wallet_sdk_rs_fn_func_submit_response( + FfiConverterTypeSessionManager.lower(sessionManager), + FfiConverterSequenceTypeItemsRequest.lower(itemsRequests), + FfiConverterDictionaryStringDictionaryStringSequenceString.lower(permittedItems),$0) +} + ) +} + +public func submitSignature(sessionManager: SessionManager, signature: Data) throws -> SignatureData { return try FfiConverterTypeSignatureData.lift( try rustCallWithError(FfiConverterTypeSignatureError.lift) { uniffi_wallet_sdk_rs_fn_func_submit_signature( - FfiConverterString.lower(state), - FfiConverterString.lower(signature),$0) + FfiConverterTypeSessionManager.lower(sessionManager), + FfiConverterData.lower(signature),$0) } ) } @@ -822,21 +1331,30 @@ private var initializationResult: InitializationResult { if bindings_contract_version != scaffolding_contract_version { return InitializationResult.contractVersionMismatch } - if (uniffi_wallet_sdk_rs_checksum_func_handle_request() != 57070) { + if (uniffi_wallet_sdk_rs_checksum_func_handle_request() != 8171) { return InitializationResult.apiChecksumMismatch } if (uniffi_wallet_sdk_rs_checksum_func_hello_ffi() != 49556) { return InitializationResult.apiChecksumMismatch } - if (uniffi_wallet_sdk_rs_checksum_func_initialise_session() != 30313) { + if (uniffi_wallet_sdk_rs_checksum_func_initialise_session() != 41897) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_wallet_sdk_rs_checksum_func_submit_response() != 45596) { return InitializationResult.apiChecksumMismatch } - if (uniffi_wallet_sdk_rs_checksum_func_submit_signature() != 56190) { + if (uniffi_wallet_sdk_rs_checksum_func_submit_signature() != 58193) { return InitializationResult.apiChecksumMismatch } if (uniffi_wallet_sdk_rs_checksum_func_terminate_session() != 30335) { return InitializationResult.apiChecksumMismatch } + if (uniffi_wallet_sdk_rs_checksum_method_mdoc_id() != 56888) { + return InitializationResult.apiChecksumMismatch + } + if (uniffi_wallet_sdk_rs_checksum_constructor_mdoc_from_cbor() != 23024) { + return InitializationResult.apiChecksumMismatch + } return InitializationResult.ok } diff --git a/src/lib.rs b/src/lib.rs index 735f6e6..a47d424 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,11 +1,19 @@ +uniffi::setup_scaffolding!(); + +use std::{ + collections::{BTreeMap, HashMap}, + sync::{Arc, Mutex}, +}; + use isomdl::{ definitions::{ device_engagement::{CentralClientMode, DeviceRetrievalMethods}, + device_request, helpers::NonEmptyMap, - BleOptions, DeviceRetrievalMethod, + BleOptions, DeviceRetrievalMethod, SessionEstablishment, }, presentation::{ - device::{Document, SessionManagerInit}, + device::{self, Document, SessionManagerEngaged, SessionManagerInit}, Stringify, }, }; @@ -41,16 +49,13 @@ impl UniffiCustomTypeConverter for Uuid { } #[uniffi::export] -fn initialise_session(document: String, uuid: Uuid) -> Result { +fn initialise_session(document: Arc, uuid: Uuid) -> Result { let drms = DeviceRetrievalMethods::new(DeviceRetrievalMethod::BLE(BleOptions { peripheral_server_mode: None, central_client_mode: Some(CentralClientMode { uuid }), })); - let document = Document::parse(document).map_err(|e| SessionError::Generic { - value: format!("Could not parse document: {e:?}"), - })?; let session = SessionManagerInit::initialise( - NonEmptyMap::new("org.iso.18013.5.1.mDL".into(), document), + NonEmptyMap::new("org.iso.18013.5.1.mDL".into(), document.0.clone()), Some(drms), None, ) @@ -83,29 +88,37 @@ fn initialise_session(document: String, uuid: Uuid) -> Result>, +} + +// uniffi::custom_newtype!(SessionManager, device::SessionManager); +#[derive(uniffi::Object)] +pub struct SessionManager(Mutex); + +// #[uniffi::export] +// impl SessionManager { +// #[uniffi::constructor] +// fn from_cbor(value: Vec) -> Arc { +// Arc::new(SessionManager(serde_cbor::from_slice(&value).unwrap())) +// } +// } + #[derive(uniffi::Record)] struct RequestData { - state: String, - payload: String, - requested_values: String, + session_manager: Arc, + items_requests: Vec, } #[uniffi::export] -fn handle_request(state: String, request: String) -> Result { - use isomdl::definitions::session::SessionEstablishment; - use isomdl::presentation::device::{SessionManager, SessionManagerEngaged}; - - let request = request.strip_prefix("0x").unwrap_or(&request); - let request: Vec = hex::decode(request).map_err(|e| RequestError::Generic { - value: format!("Could not decode request: {e:?}"), - })?; - let (mut session, requested) = match SessionManagerEngaged::parse(state.to_string()) { +fn handle_request(state: String, request: Vec) -> Result { + let (session_manager, items_requests) = match SessionManagerEngaged::parse(state.to_string()) { Ok(sme) => { let session_establishment: SessionEstablishment = serde_cbor::from_slice(&request) .map_err(|e| RequestError::Generic { @@ -117,10 +130,11 @@ fn handle_request(state: String, request: String) -> Result { - let mut sm = - SessionManager::parse(state.to_string()).map_err(|e| RequestError::Generic { + let mut sm = device::SessionManager::parse(state.to_string()).map_err(|e| { + RequestError::Generic { value: format!("Could not parse session manager state: {e:?}"), - })?; + } + })?; let req = sm .handle_request(&request) .map_err(|e| RequestError::Generic { @@ -129,46 +143,84 @@ fn handle_request(state: String, request: String) -> Result, +} + +#[uniffi::export] +fn submit_response( + session_manager: Arc, + items_requests: Vec, + permitted_items: HashMap>>, +) -> Result { + let permitted = permitted_items .into_iter() - .map(|req| { - let namespaces = req - .namespaces - .into_inner() - .into_iter() - .map(|(ns, es)| { - let ids = es.into_inner().into_keys().collect(); - (ns, ids) - }) - .collect(); - (req.doc_type, namespaces) + .map(|(doc_type, namespaces)| { + let ns = namespaces.into_iter().collect(); + (doc_type, ns) }) .collect(); - session.prepare_response(&requested, permitted); - let payload = session + let mut session_manager = session_manager.0.lock().unwrap(); + session_manager.prepare_response( + &items_requests + .into_iter() + .map(|req| device_request::ItemsRequest { + doc_type: req.doc_type, + namespaces: req + .namespaces + .into_iter() + .map(|(ns, ir)| { + ( + ns, + ir.into_iter() + .collect::>() + .try_into() + .unwrap(), + ) + }) + .collect::>() + .try_into() + .unwrap(), + request_info: None, + }) + .collect(), + permitted, + ); + let payload = session_manager .get_next_signature_payload() .map(|(_, payload)| payload) - .ok_or(RequestError::MissingSignature)?; - let mut payload = hex::encode(payload); - payload.insert_str(0, "0x"); - let state = session.stringify().map_err(|e| RequestError::Generic { - value: format!("Could not stringify session: {e:?}"), - })?; - - let requested_values = requested - .into_iter() - .map(|req| (req.doc_type, req.namespaces)) - .collect::>(); - Ok(RequestData { - state, - payload, - requested_values: serde_json::to_string(&requested_values).map_err(|e| { - RequestError::Generic { - value: format!("Could not serialize requested values: {e:?}"), - } - })?, - }) + .ok_or(ResponseError::MissingSignature)? + .to_vec(); + Ok(ResponseData { payload }) } #[derive(thiserror::Error, uniffi::Error, Debug)] @@ -182,36 +234,28 @@ pub enum SignatureError { #[derive(uniffi::Record)] struct SignatureData { state: String, - response: String, + response: Vec, } #[uniffi::export] -fn submit_signature(state: String, signature: String) -> Result { - use isomdl::presentation::device::SessionManager; - - let sig = signature.strip_prefix("0x").unwrap_or(&signature); - let sig: Vec = hex::decode(sig).map_err(|e| SignatureError::Generic { - value: format!("Could not decode signature: {e:?}"), - })?; - let mut session = - SessionManager::parse(state.to_string()).map_err(|e| SignatureError::Generic { - value: format!("Could not parse session manager state: {e:?}"), - })?; - session - .submit_next_signature(sig) +fn submit_signature( + session_manager: Arc, + signature: Vec, +) -> Result { + let mut session_manager = session_manager.0.lock().unwrap(); + session_manager + .submit_next_signature(signature) .map_err(|e| SignatureError::Generic { value: format!("Could not submit next signature: {e:?}"), })?; - - let response = session + let response = session_manager .retrieve_response() .ok_or(SignatureError::TooManyDocuments)?; - let mut response = hex::encode(response); - response.insert_str(0, "0x"); - - let state = session.stringify().map_err(|e| SignatureError::Generic { - value: format!("Could not stringify session: {e:?}"), - })?; + let state = session_manager + .stringify() + .map_err(|e| SignatureError::Generic { + value: format!("Could not stringify session: {e:?}"), + })?; Ok(SignatureData { state, response }) } @@ -237,4 +281,27 @@ fn terminate_session() -> Result { Ok(response) } -uniffi::setup_scaffolding!(); +#[derive(uniffi::Object)] +pub struct MDoc(Document); + +#[derive(thiserror::Error, uniffi::Error, Debug)] +pub enum MDocInitError { + #[error("Could not initialize mDoc: {value}")] + Generic { value: String }, +} + +#[uniffi::export] +impl MDoc { + #[uniffi::constructor] + fn from_cbor(value: Vec) -> Result, MDocInitError> { + Ok(Arc::new(MDoc(serde_cbor::from_slice(&value).map_err( + |e| MDocInitError::Generic { + value: e.to_string(), + }, + )?))) + } + + fn id(&self) -> Uuid { + self.0.id + } +}