rn-linkrunner 2.5.2 → 2.6.0

package/LinkrunnerSDK.podspec

@@ -19,5 +19,5 @@ Pod::Spec.new do |s|
   s.requires_arc = true
 
   s.dependency "React"
-  s.dependency 'LinkrunnerKit', '3.6.0'
+  s.dependency 'LinkrunnerKit', '3.7.0'
 end

package/ios/Podfile

@@ -12,7 +12,7 @@ abstract_target 'LinkrunnerSDK' do
   # Pods for LinkrunnerSDK
   
   # Add the linkrunner-ios-sdk dependency
-    pod 'LinkrunnerKit', '3.6.0'
+    pod 'LinkrunnerKit', '3.7.0'
 
   
   # Add any other dependencies your SDK needs here

package/ios/Pods/LinkrunnerKit/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Linkrunner Private Limited
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/ios/Pods/LinkrunnerKit/README.md

@@ -0,0 +1,15 @@
+# Linkrunner iOS SDK
+
+A Swift package for integrating Linkrunner functionality into your iOS applications.
+
+## Documentation
+
+For setup instructions, usage examples, and API reference, please visit:
+
+[Linkrunner iOS SDK Documentation](https://docs.linkrunner.io/sdk/ios/installation)
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](./LICENSE) file for details.
+
+Copyright (c) 2025 Linkrunner Private Limited

package/ios/Pods/LinkrunnerKit/Sources/Linkrunner/HmacSignatureGenerator.swift

@@ -0,0 +1,95 @@
+import Foundation
+import CommonCrypto
+
+public class HmacSignatureGenerator {
+    // MARK: - Constants
+    private static let HMAC_ALGORITHM = kCCHmacAlgSHA256
+    
+    // MARK: - Properties
+    private let secretKey: String
+    private let keyId: String
+    
+    // MARK: - Initialization
+    public init(secretKey: String, keyId: String) {
+        self.secretKey = secretKey
+        self.keyId = keyId
+    }
+    
+    // MARK: - Models
+    public struct SignedRequest {
+        public let signature: String
+        public let timestamp: Int64
+        public let keyId: String
+    }
+    
+    // MARK: - Public Methods
+    public func signRequest(
+        payload: String?,
+        timestamp: Int64 = Int64(Date().timeIntervalSince1970 * 1000),
+        onCanonicalString: ((String) -> Void)? = nil
+    ) -> SignedRequest {
+        // Calculate content hash if payload exists, otherwise use empty string
+        let contentHash: String
+        if let payload = payload, !payload.isEmpty {
+            contentHash = sha256Hash(payload)
+        } else {
+            contentHash = ""
+        }
+        
+        // Build the canonical string with timestamp and content hash
+        let stringToSign = buildCanonicalString(timestamp: timestamp, contentHash: contentHash)
+        onCanonicalString?(stringToSign)
+        // Generate the signature
+        let signature = generateHmac(data: stringToSign)
+        
+        return SignedRequest(signature: signature, timestamp: timestamp, keyId: keyId)
+    }
+    
+    // MARK: - Private Methods
+    private func buildCanonicalString(timestamp: Int64, contentHash: String) -> String {
+        return "\(timestamp)\n\(contentHash)"
+    }
+    
+    private func generateHmac(data: String) -> String {
+        guard let dataBytes = data.data(using: .utf8) else {
+            return ""
+        }
+        
+        // Create a mutable pointer to hold the HMAC result
+        let digestLength = Int(CC_SHA256_DIGEST_LENGTH)
+        var hmacResult = [UInt8](repeating: 0, count: digestLength)
+        
+        // Calculate HMAC using a more compatible approach
+        let keyData = Data(secretKey.utf8)
+        
+        keyData.withUnsafeBytes { keyBytes in
+            dataBytes.withUnsafeBytes { dataBytes in
+                let keyPtr = keyBytes.baseAddress?.assumingMemoryBound(to: UInt8.self)
+                let dataPtr = dataBytes.baseAddress?.assumingMemoryBound(to: UInt8.self)
+                
+                CCHmac(
+                    CCHmacAlgorithm(kCCHmacAlgSHA256),
+                    keyPtr, keyBytes.count,
+                    dataPtr, dataBytes.count,
+                    &hmacResult
+                )
+            }
+        }
+        
+        // Convert to base64
+        let hmacData = Data(hmacResult)
+        return hmacData.base64EncodedString()
+    }
+    
+    private func sha256Hash(_ data: String) -> String {
+        guard let dataBytes = data.data(using: .utf8) else { return "" }
+        
+        var hashBytes = [UInt8](repeating: 0, count: Int(CC_SHA256_DIGEST_LENGTH))
+        dataBytes.withUnsafeBytes { buffer in
+            _ = CC_SHA256(buffer.baseAddress, CC_LONG(buffer.count), &hashBytes)
+        }
+        
+        let hashData = Data(hashBytes)
+        return hashData.base64EncodedString()
+    }
+}