feat: Implement JSON-RPC endpoint for AccountCreateTransaction

Author: rwalworth

Package.resolved

@@ -283,7 +283,7 @@ extension AccountCreateTransaction: ToProtobuf {
     internal func toProtobuf() -> Protobuf {
         .with { proto in
             key?.toProtobufInto(&proto.key)
-            proto.initialBalance = UInt64(initialBalance.toTinybars())
+            proto.initialBalance = UInt64(truncatingIfNeeded: initialBalance.toTinybars())
             proto.receiverSigRequired = receiverSignatureRequired
             autoRenewPeriod?.toProtobufInto(&proto.autoRenewPeriod)
             // autoRenewAccountId?.toProtobufInto(&proto.autoRenewAccount)
@@ -295,7 +295,7 @@ extension AccountCreateTransaction: ToProtobuf {
             }
 
             if let stakedNodeId = stakedNodeId {
-                proto.stakedNodeID = Int64(stakedNodeId)
+                proto.stakedNodeID = Int64(truncatingIfNeeded: stakedNodeId)
             }
 
             if let stakedAccountId = stakedAccountId {

Sources/Hedera/Account/AccountCreateTransaction.swift

@@ -33,6 +33,6 @@ extension Duration: ProtobufCodable {
     }
 
     internal func toProtobuf() -> Protobuf {
-        .with { proto in proto.seconds = Int64(seconds) }
+        .with { proto in proto.seconds = Int64(truncatingIfNeeded: seconds) }
     }
 }

Sources/Hedera/Duration.swift

@@ -0,0 +1,82 @@
+/*
+ * ‌
+ * Hedera Swift SDK
+ * ​
+ * Copyright (C) 2022 - 2024 Hedera Hashgraph, LLC
+ * ​
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ‍
+ */
+internal func getJson<T>(_ json: JSONObject, _ paramName: String, _ functionName: String) throws
+    -> T
+{
+    if T.self == String.self {
+        guard let val = json.stringValue else {
+            throw JSONError.invalidParams("\(functionName): \(paramName) MUST be a string.")
+        }
+        return val as! T
+    }
+    if T.self == Int.self || T.self == Int32.self || T.self == UInt32.self || T.self == Int64.self
+        || T.self == UInt64.self
+    {
+        guard let val = json.intValue else {
+            throw JSONError.invalidParams("\(functionName): \(paramName) MUST be an integer.")
+        }
+        return val as! T
+    }
+    if T.self == Double.self || T.self == Float.self {
+        guard let val = json.doubleValue else {
+            throw JSONError.invalidParams("\(functionName): \(paramName) MUST be a double.")
+        }
+        return val as! T
+    }
+    if T.self == Bool.self {
+        guard let val = json.boolValue else {
+            throw JSONError.invalidParams("\(functionName): \(paramName) MUST be a boolean.")
+        }
+        return val as! T
+    }
+    if T.self == [JSONObject].self {
+        guard let val = json.listValue else {
+            throw JSONError.invalidParams("\(functionName): \(paramName) MUST be a list.")
+        }
+        return val as! T
+    }
+    if T.self == [String: JSONObject].self {
+        guard let val = json.dictValue else {
+            throw JSONError.invalidParams("\(functionName): \(paramName) MUST be a dictionary.")
+        }
+        return val as! T
+    }
+
+    throw JSONError.invalidParams("\(functionName): \(paramName) is NOT a valid type.")
+}
+
+internal func getParam(_ json: JSONObject?, _ paramName: String, _ functionName: String) throws -> JSONObject {
+    return try json ?? { throw JSONError.invalidParams("\(functionName): \(paramName) MUST be provided.") }()
+}
+
+internal func getOptionalJsonParameter<T>(
+    _ name: String, _ parameters: [String: JSONObject], _ functionName: String
+) throws -> T? {
+    guard let param = parameters[name] else {
+        return nil
+    }
+    return try getJson(param, name, functionName) as T
+}
+
+internal func getRequiredJsonParameter<T>(
+    _ name: String, _ parameters: [String: JSONObject], _ functionName: String
+) throws -> T {
+    return try getJson(getParam(parameters[name], name, functionName), name, functionName)
+}

Sources/HederaTCK/JSONHelper.swift

@@ -24,26 +24,26 @@ import Vapor
 private let jsonRpcVersion = "2.0"
 
 internal struct JSONRequest: Decodable {
-    let jsonrpc: String
-    var id: Int
-    var method: String
-    var params: JSONObject?
+    internal let jsonrpc: String
+    internal var id: Int
+    internal var method: String
+    internal var params: JSONObject?
 
-    enum CodingKeys: String, CodingKey {
+    private enum CodingKeys: String, CodingKey {
         case jsonrpc
         case id
         case method
         case params
     }
 
-    init(id: Int, method: String, params: JSONObject) {
+    internal init(id: Int, method: String, params: JSONObject) {
         self.jsonrpc = jsonRpcVersion
         self.id = id
         self.method = method
         self.params = params
     }
 
-    init(from decoder: Decoder) throws {
+    internal init(from decoder: Decoder) throws {
         let container = try decoder.container(keyedBy: CodingKeys.self)
 
         guard let jsonrpc = try container.decodeIfPresent(String.self, forKey: .jsonrpc) else {
@@ -72,22 +72,36 @@ internal struct JSONRequest: Decodable {
             self.params = nil
         }
     }
+
+    internal func toDict() -> [String: JSONObject] {
+        var dict = [
+            "jsonrpc": JSONObject.string(jsonRpcVersion),
+            "id": JSONObject.int(Int64(self.id)),
+            "method": JSONObject.string(self.method),
+        ]
+
+        if let params = self.params {
+            dict["params"] = params
+        }
+
+        return dict
+    }
 }
 
 internal struct JSONResponse: Encodable {
-    let jsonrpc: String
-    var id: Int?
-    var result: JSONObject?
-    var error: JSONError?
+    internal let jsonrpc: String
+    internal var id: Int?
+    internal var result: JSONObject?
+    internal var error: JSONError?
 
-    init(id: Int, result: JSONObject) {
+    internal init(id: Int, result: JSONObject) {
         self.jsonrpc = jsonRpcVersion
         self.id = id
         self.result = result
         self.error = nil
     }
 
-    init(id: Int?, error: JSONError) {
+    internal init(id: Int?, error: JSONError) {
         self.jsonrpc = jsonRpcVersion
         self.id = id
         self.result = nil
@@ -103,13 +117,13 @@ internal enum JSONError: Encodable, Error {
     case internalError(String, JSONObject? = nil)
     case parseError(String, JSONObject? = nil)
 
-    enum CodingKeys: String, CodingKey {
+    private enum CodingKeys: String, CodingKey {
         case code
         case message
         case data
     }
 
-    var code: Int {
+    internal var code: Int {
         switch self {
         case .hederaError: return -32001
         case .invalidRequest: return -32600
@@ -120,7 +134,7 @@ internal enum JSONError: Encodable, Error {
         }
     }
 
-    var message: String {
+    internal var message: String {
         switch self {
         case .hederaError(let message, _),
             .invalidRequest(let message, _),
@@ -132,7 +146,7 @@ internal enum JSONError: Encodable, Error {
         }
     }
 
-    var data: JSONObject? {
+    internal var data: JSONObject? {
         switch self {
         case .hederaError(_, let data),
             .invalidRequest(_, let data),
@@ -144,7 +158,7 @@ internal enum JSONError: Encodable, Error {
         }
     }
 
-    func encode(to encoder: Encoder) throws {
+    internal func encode(to encoder: Encoder) throws {
         var container = encoder.container(keyedBy: CodingKeys.self)
         try container.encode(code, forKey: .code)
         try container.encode(message, forKey: .message)
@@ -153,58 +167,57 @@ internal enum JSONError: Encodable, Error {
 }
 
 internal enum JSONObject: Codable {
-    case none
     case string(String)
-    case integer(Int)
+    case int(Int64)
     case double(Double)
     case bool(Bool)
     case list([JSONObject])
     case dictionary([String: JSONObject])
 
-    var stringValue: String? {
+    internal var stringValue: String? {
         if case .string(let value) = self {
             return value
         }
         return nil
     }
-    var intValue: Int? {
-        if case .integer(let value) = self {
+    internal var intValue: Int64? {
+        if case .int(let value) = self {
             return value
         }
         return nil
     }
-    var doubleValue: Double? {
+    internal var doubleValue: Double? {
         if case .double(let value) = self {
             return value
         }
         return nil
     }
-    var boolValue: Bool? {
+    internal var boolValue: Bool? {
         if case .bool(let value) = self {
             return value
         }
         return nil
     }
-    var listValue: [JSONObject]? {
+    internal var listValue: [JSONObject]? {
         if case .list(let value) = self {
             return value
         }
         return nil
     }
-    var dictValue: [String: JSONObject]? {
+    internal var dictValue: [String: JSONObject]? {
         if case .dictionary(let value) = self {
             return value
         }
         return nil
     }
 
-    init(from decoder: Decoder) throws {
+    internal init(from decoder: Decoder) throws {
         let container = try decoder.singleValueContainer()
 
         if let value = try? container.decode(String.self) {
             self = .string(value)
-        } else if let value = try? container.decode(Int.self) {
-            self = .integer(value)
+        } else if let value = try? container.decode(Int64.self) {
+            self = .int(value)
         } else if let value = try? container.decode(Double.self) {
             self = .double(value)
         } else if let value = try? container.decode(Bool.self) {
@@ -214,19 +227,17 @@ internal enum JSONObject: Codable {
         } else if let value = try? container.decode([String: JSONObject].self) {
             self = .dictionary(value)
         } else {
-            self = .none
+            throw JSONError.invalidParams("param type not recognized")
         }
     }
 
-    func encode(to encoder: Encoder) throws {
+    internal func encode(to encoder: Encoder) throws {
         var container = encoder.singleValueContainer()
 
         switch self {
-        case .none:
-            break
         case .string(let value):
             try container.encode(value)
-        case .integer(let value):
+        case .int(let value):
             try container.encode(value)
         case .double(let value):
             try container.encode(value)