dnrops
/
viz-swift-lib
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update for VIZ

This commit is contained in:
Vladimir Babin 2021-02-22 13:30:56 +05:00
parent 6cbbd6a9da
commit 70dd5cc354
39 changed files with 606 additions and 804 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -2,7 +2,9 @@
/.build /.build
/Packages /Packages
/*.xcodeproj /*.xcodeproj
xcuserdata/
Package.resolved Package.resolved
/build /build
/docs /docs
/.gh-pages /.gh-pages
.swiftpm

17
Package.swift
View File

@ -1,11 +1,12 @@
// swift-tools-version:4.0 // swift-tools-version:5.3
// The swift-tools-version declares the minimum version of Swift required to build this package.
import PackageDescription import PackageDescription
let package = Package( let package = Package(
name: "Steem", name: "VIZ",
products: [ products: [
.library(name: "Steem", targets: ["Steem"]), .library(name: "VIZ", targets: ["VIZ"]),
], ],
dependencies: [ dependencies: [
.package(url: "https://github.com/Flight-School/AnyCodable.git", .revision("396ccc3dba5bdee04c1e742e7fab40582861401e")), .package(url: "https://github.com/Flight-School/AnyCodable.git", .revision("396ccc3dba5bdee04c1e742e7fab40582861401e")),
@ -21,16 +22,16 @@ let package = Package(
dependencies: [] dependencies: []
), ),
.target( .target(
name: "Steem", name: "VIZ",
dependencies: ["Crypto", "AnyCodable", "OrderedDictionary", "secp256k1"] dependencies: ["Crypto", "AnyCodable", "OrderedDictionary", "secp256k1"]
), ),
.testTarget( .testTarget(
name: "SteemTests", name: "UnitTests",
dependencies: ["Steem"] dependencies: ["VIZ"]
), ),
.testTarget( .testTarget(
name: "SteemIntegrationTests", name: "IntegrationTests",
dependencies: ["Steem"] dependencies: ["VIZ"]
), ),
] ]
) )

25
README.md
View File

@ -1,43 +1,32 @@
# viz-swift-lib
swift-hive VIZ library for Swift.
===========
Unofficial Hive library for Swift.
Resources:
* [API documentation](https://steemit.github.io/swift-steem/)
* [Issue tracker](https://github.com/hiveuprss/swift-hive/issues)
* [Steem developer portal](https://developers.hive.io)
Installation Installation
------------ ------------
Using the [Swift package manager](https://swift.org/package-manager/): Using the [Swift package manager](https://swift.org/package-manager/):
In your Package.swift add: In your `Package.swift` just add:
``` ```
dependencies: [ dependencies: [
.package(url: "https://github.com/hiveuprss/swift-hive.git", .branch("master")) .package(url: "https://github.com/viz-blockchain/viz-swift-lib.git", .branch("master"))
] ]
``` ```
and run `swift package update`. Now you can `import Steem` in your Swift project. and run `swift package update`. Now you can `import VIZ` in your Swift project.
Running tests Running tests
------------- -------------
To run all tests simply run `swift test`, this will run both the unit- and integration-tests. To run them separately use the `--filter` flag, e.g. `swift test --filter SteemIntegrationTests` To run all tests simply run `swift test`, this will run both the unit- and integration-tests. To run them separately use the `--filter` flag, e.g. `swift test --filter IntegrationTests`
Developing Developing
---------- ----------
Development of the library is best done with Xcode, to generate a `.xcodeproj` you need to run `swift package generate-xcodeproj`. Development of the library is best done with Xcode, to generate a `.xcodeproj` you need to run `swift package generate-xcodeproj`.
To enable test coverage display go "Scheme > Manage Schemes..." menu item and edit the "Steem-Package" scheme, select the Test configuration and under the Options tab enable "Gather coverage for some targets" and add the `Steem` target. To enable test coverage display go "Scheme > Manage Schemes..." menu item and edit the "viz-swift-lib" scheme, select the Test configuration and under the Options tab enable "Gather coverage for some targets" and add the `viz-swift-lib` target.
After adding adding more unit tests the `swift test --generate-linuxmain` command has to be run and the XCTestManifest changes committed for the tests to be run on Linux. After adding adding more unit tests the `swift test --generate-linuxmain` command has to be run and the XCTestManifest changes committed for the tests to be run on Linux.

2
Sources/Crypto/options.h
View File

@ -66,7 +66,7 @@
#define USE_ETHEREUM 0 #define USE_ETHEREUM 0
#endif #endif
// support Graphene operations (STEEM, BitShares) // support Graphene operations (VIZ, BitShares)
#ifndef USE_GRAPHENE #ifndef USE_GRAPHENE
#define USE_GRAPHENE 1 #define USE_GRAPHENE 1
#endif #endif

153
Sources/VIZ/API.swift
View File

@ -1,26 +1,23 @@
/// Steem RPC requests and responses. /// VIZ RPC requests and responses.
/// - Author: Johan Nordberg <johan@steemit.com> /// - Author: Johan Nordberg <johan@steemit.com>
/// - Author: Iain Maitland <imaitland@steemit.com> /// - Author: Iain Maitland <imaitland@steemit.com>
import AnyCodable import AnyCodable
import Foundation import Foundation
/// Steem RPC API request- and response-types. /// VIZ RPC API request- and response-types.
public struct API { public struct API {
/// Wrapper for pre-appbase steemd calls. /// Wrapper for pre-appbase vizd calls.
public struct CallParams<T: Encodable>: Encodable { public struct CallParams<T: Encodable>: Encodable {
let api: String
let method: String let method: String
let params: [T] let params: [T]
init(_ api: String, _ method: String, _ params: [T]) { init(_ method: String, _ params: [T]) {
self.api = api
self.method = method self.method = method
self.params = params self.params = params
} }
public func encode(to encoder: Encoder) throws { public func encode(to encoder: Encoder) throws {
var container = encoder.unkeyedContainer() var container = encoder.unkeyedContainer()
try container.encode(api)
try container.encode(method) try container.encode(method)
try container.encode(params) try container.encode(params)
} }
@ -29,73 +26,37 @@ public struct API {
public struct DynamicGlobalProperties: Decodable { public struct DynamicGlobalProperties: Decodable {
public let headBlockNumber: UInt32 public let headBlockNumber: UInt32
public let headBlockId: BlockId public let headBlockId: BlockId
public let time: Date
public let genesisTime: Date
public let currentWitness: String public let currentWitness: String
public let numPowWitnesses: UInt32 public let committeeFund: Asset
public let virtualSupply: Asset public let committeeRequests: UInt32
public let currentSupply: Asset public let currentSupply: Asset
public let confidentialSupply: Asset public let totalVestingFund: Asset
public let currentSbdSupply: Asset
public let confidentialSbdSupply: Asset
public let totalVestingFundSteem: Asset
public let totalVestingShares: Asset public let totalVestingShares: Asset
public let totalRewardFundSteem: Asset public let totalRewardFund: Asset
public let totalRewardShares2: String public let totalRewardShares: String
public let pendingRewardedVestingShares: Asset public let inflationCalcBlockNum: UInt32
public let pendingRewardedVestingSteem: Asset public let inflationWitnessPercent: Int16
public let sbdInterestRate: UInt32 public let inflationRatio: Int16
public let sbdPrintRate: UInt32 public let averageBlockSize: UInt32
public let maximumBlockSize: UInt32
public let currentAslot: UInt32 public let currentAslot: UInt32
public let recentSlotsFilled: String public let recentSlotsFilled: String
public let participationCount: UInt32 public let participationCount: UInt32
public let lastIrreversibleBlockNum: UInt32 public let lastIrreversibleBlockNum: UInt32
public let votePowerReserveRate: UInt32 public let maxVirtualBandwidth: String
public let time: Date public let currentReserveRatio: UInt64
public let voteRegenerationPerDay: UInt32
} }
public struct GetDynamicGlobalProperties: Request { public struct GetDynamicGlobalProperties: Request {
public typealias Response = DynamicGlobalProperties public typealias Response = DynamicGlobalProperties
public let method = "condenser_api.get_dynamic_global_properties" public let method = "get_dynamic_global_properties"
public let params: RequestParams<[String]>? = RequestParams([]) public let params: RequestParams<[String]>? = RequestParams([])
public init() {} public init() {}
} }
public struct SteemPrices: Decodable {
public let steemSbd: Float32
public let steemUsd: Float32
public let steemVest: Float32
}
public struct GetPrices: Request {
public typealias Response = SteemPrices
public let method = "conveyor.get_prices"
public init() {}
}
public struct FeedHistory: Decodable {
public let currentMedianHistory: Price
public let priceHistory: [Price]
}
public struct GetFeedHistory: Request {
public typealias Response = FeedHistory
public let method = "get_feed_history"
public init() {}
}
public struct OrderBook: Decodable {
public let bids: [Order]
public let asks: [Order]
}
public struct GetOrderBook: Request {
public typealias Response = OrderBook
public let method = "get_order_book"
public let params: RequestParams<Int>?
public init(count: Int) {
self.params = RequestParams([count])
}
}
public struct TransactionConfirmation: Decodable { public struct TransactionConfirmation: Decodable {
public let id: Data public let id: Data
public let blockNum: Int32 public let blockNum: Int32
@ -108,7 +69,7 @@ public struct API {
public let method = "call" public let method = "call"
public let params: CallParams<SignedTransaction>? public let params: CallParams<SignedTransaction>?
public init(transaction: SignedTransaction) { public init(transaction: SignedTransaction) {
self.params = CallParams("condenser_api", "broadcast_transaction_synchronous", [transaction]) self.params = CallParams("broadcast_transaction_synchronous", [transaction])
} }
} }
@ -137,42 +98,26 @@ public struct API {
public struct ExtendedAccount: Decodable { public struct ExtendedAccount: Decodable {
public let id: Int public let id: Int
public let name: String public let name: String
public let owner: Authority public let masterAuthority: Authority
public let active: Authority public let activeAuthority: Authority
public let posting: Authority public let regularAuthority: Authority
public let memoKey: PublicKey public let memoKey: PublicKey
public let jsonMetadata: String public let jsonMetadata: String
public let proxy: String public let proxy: String
public let lastOwnerUpdate: Date public let referrer: String
public let lastMasterUpdate: Date
public let lastAccountUpdate: Date public let lastAccountUpdate: Date
public let created: Date public let created: Date
public let mined: Bool
public let recoveryAccount: String public let recoveryAccount: String
public let resetAccount: String
public let lastAccountRecovery: Date public let lastAccountRecovery: Date
public let commentCount: UInt32 public let awardedRshares: UInt64
public let lifetimeVoteCount: UInt32 public let customSequence: UInt64
public let postCount: UInt32 public let customSequenceBlockNum: UInt64
public let canVote: Bool public let energy: Int32
public let votingPower: UInt16
public let lastVoteTime: Date public let lastVoteTime: Date
public let balance: Asset public let balance: Asset
public let savingsBalance: Asset public let receiverAwards: UInt64
public let sbdBalance: Asset public let benefactorAwards: UInt64
public let sbdSeconds: String // uint128_t
public let sbdSecondsLastUpdate: Date
public let sbdLastInterestPayment: Date
public let savingsSbdBalance: Asset
public let savingsSbdSeconds: String // uint128_t
public let savingsSbdSecondsLastUpdate: Date
public let savingsSbdLastInterestPayment: Date
public let savingsWithdrawRequests: UInt8
public let rewardSbdBalance: Asset
public let rewardSteemBalance: Asset
public let rewardVestingBalance: Asset
public let rewardVestingSteem: Asset
public let curationRewards: Share
public let postingRewards: Share
public let vestingShares: Asset public let vestingShares: Asset
public let delegatedVestingShares: Asset public let delegatedVestingShares: Asset
public let receivedVestingShares: Asset public let receivedVestingShares: Asset
@ -183,14 +128,26 @@ public struct API {
public let withdrawRoutes: UInt16 public let withdrawRoutes: UInt16
public let proxiedVsfVotes: [Share] public let proxiedVsfVotes: [Share]
public let witnessesVotedFor: UInt16 public let witnessesVotedFor: UInt16
public let witnessesVoteWeight: Share
public let lastPost: Date public let lastPost: Date
public let lastRootPost: Date public let lastRootPost: Date
public let averageBandwidth: Share
public let lifetimeBandwidth: Share
public let lastBandwidthUpdate: Date
public let witnessVotes: [String]
public let valid: Bool
public let accountSeller: String
public let accountOfferPrice: Asset
public let accountOnSale: Bool
public let subaccountSeller: String
public let subaccountOfferPrice: Asset
public let subaccountOnSale: Bool
} }
/// Fetch accounts. /// Fetch accounts.
public struct GetAccounts: Request { public struct GetAccounts: Request {
public typealias Response = [ExtendedAccount] public typealias Response = [ExtendedAccount]
public let method = "condenser_api.get_accounts" public let method = "get_accounts"
public let params: RequestParams<[String]>? public let params: RequestParams<[String]>?
public init(names: [String]) { public init(names: [String]) {
self.params = RequestParams([names]) self.params = RequestParams([names])
@ -222,7 +179,7 @@ public struct API {
public struct GetAccountHistory: Request, Encodable { public struct GetAccountHistory: Request, Encodable {
public typealias Response = [AccountHistoryObject] public typealias Response = [AccountHistoryObject]
public let method = "condenser_api.get_account_history" public let method = "get_account_history"
public var params: RequestParams<AnyEncodable>? { public var params: RequestParams<AnyEncodable>? {
return RequestParams([AnyEncodable(self.account), AnyEncodable(self.from), AnyEncodable(self.limit)]) return RequestParams([AnyEncodable(self.account), AnyEncodable(self.from), AnyEncodable(self.limit)])
} }
@ -236,22 +193,4 @@ public struct API {
self.limit = limit self.limit = limit
} }
} }
/// Type representing the order book for the internal STEEM market
public struct Order: Equatable, SteemEncodable, Decodable {
/// The order price
public var orderPrice: Price
/// The real price
public var realPrice: String
/// The STEEM price
public var steem: UInt32
/// The SBD price
public var sbd: UInt32
/// Created
public var created: Date
}
} }

63
Sources/VIZ/Asset.swift
View File

@ -1,26 +1,24 @@
/// Steem token types. /// VIZ token types.
/// - Author: Johan Nordberg <johan@steemit.com> /// - Author: Johan Nordberg <johan@steemit.com>
/// - Author: Iain Maitland <imaitland@steemit.com> /// - Author: Iain Maitland <imaitland@steemit.com>
import Foundation import Foundation
/// The Steem asset type. /// The VIZ asset type.
public struct Asset: Equatable { public struct Asset: Equatable {
/// Asset symbol type, containing the symbol name and precision. /// Asset symbol type, containing the symbol name and precision.
public enum Symbol: Equatable { public enum Symbol: Equatable {
/// The STEEM token. /// The VIZ token.
case steem case viz
/// Vesting shares. /// Vesting shares.
case vests case vests
/// Steem-backed dollars.
case sbd
/// Custom token. /// Custom token.
case custom(name: String, precision: UInt8) case custom(name: String, precision: UInt8)
/// Number of decimal points represented. /// Number of decimal points represented.
public var precision: UInt8 { public var precision: UInt8 {
switch self { switch self {
case .steem, .sbd: case .viz:
return 3 return 3
case .vests: case .vests:
return 6 return 6
@ -29,13 +27,11 @@ public struct Asset: Equatable {
} }
} }
/// String representation of symbol prefix, e.g. "STEEM". /// String representation of symbol prefix, e.g. "VIZ".
public var name: String { public var name: String {
switch self { switch self {
case .steem: case .viz:
return "STEEM" return "VIZ"
case .sbd:
return "SBD"
case .vests: case .vests:
return "VESTS" return "VESTS"
case let .custom(name, _): case let .custom(name, _):
@ -51,13 +47,13 @@ public struct Asset: Equatable {
/// Create a new `Asset`. /// Create a new `Asset`.
/// - Parameter value: Amount of tokens. /// - Parameter value: Amount of tokens.
/// - Parameter symbol: Token symbol. /// - Parameter symbol: Token symbol.
public init(_ value: Double, _ symbol: Symbol = .steem) { public init(_ value: Double, _ symbol: Symbol = .viz) {
self.amount = Int64(round(value * pow(10, Double(symbol.precision)))) self.amount = Int64(round(value * pow(10, Double(symbol.precision))))
self.symbol = symbol self.symbol = symbol
} }
/// Create a new `Asset` from a string representation. /// Create a new `Asset` from a string representation.
/// - Parameter value: String to parse into asset, e.g. `1.000 STEEM`. /// - Parameter value: String to parse into asset, e.g. `1.000 VIZ`.
public init?(_ value: String) { public init?(_ value: String) {
let parts = value.split(separator: " ") let parts = value.split(separator: " ")
guard parts.count == 2 else { guard parts.count == 2 else {
@ -65,12 +61,10 @@ public struct Asset: Equatable {
} }
let symbol: Symbol let symbol: Symbol
switch parts[1] { switch parts[1] {
case "STEEM": case "VIZ":
symbol = .steem symbol = .viz
case "VESTS": case "VESTS":
symbol = .vests symbol = .vests
case "SBD":
symbol = .sbd
default: default:
let ap = parts[0].split(separator: ".") let ap = parts[0].split(separator: ".")
let precision: UInt8 = ap.count == 2 ? UInt8(ap[1].count) : 0 let precision: UInt8 = ap.count == 2 ? UInt8(ap[1].count) : 0
@ -83,35 +77,6 @@ public struct Asset: Equatable {
} }
} }
enum PriceError: Error {
case cannotConvert(asset: Asset, usingPrice: Price)
}
/// Type representing a quotation of the relative value of asset against another asset.
public struct Price: Equatable, SteemEncodable, Decodable {
/// The base asset.
public var base: Asset
/// The quote asset.
public var quote: Asset
/// Use the Price base and quote Assets to convert between Asset amounts.
public func convert(asset: Asset) throws -> Asset {
if asset.symbol == self.base.symbol {
assert(self.base.resolvedAmount > 0)
return Asset(asset.resolvedAmount * self.quote.resolvedAmount / self.base.resolvedAmount, self.quote.symbol)
} else if asset.symbol == self.quote.symbol {
assert(self.quote.resolvedAmount > 0)
return Asset(asset.resolvedAmount * self.base.resolvedAmount / self.quote.resolvedAmount, self.base.symbol)
} else {
throw PriceError.cannotConvert(asset: asset, usingPrice: self)
}
}
public init(base: Asset, quote: Asset) {
self.base = base
self.quote = quote
}
}
extension Asset { extension Asset {
/// The amount of the token, based on symbol precision. /// The amount of the token, based on symbol precision.
public var resolvedAmount: Double { public var resolvedAmount: Double {
@ -134,7 +99,7 @@ extension Asset: LosslessStringConvertible {
} }
} }
extension Asset: SteemEncodable, Decodable { extension Asset: VIZEncodable, Decodable {
public init(from decoder: Decoder) throws { public init(from decoder: Decoder) throws {
let container = try decoder.singleValueContainer() let container = try decoder.singleValueContainer()
let value = try container.decode(String.self) let value = try container.decode(String.self)
@ -149,7 +114,7 @@ extension Asset: SteemEncodable, Decodable {
try container.encode(String(self)) try container.encode(String(self))
} }
public func binaryEncode(to encoder: SteemEncoder) throws { public func binaryEncode(to encoder: VIZEncoder) throws {
try encoder.encode(self.amount) try encoder.encode(self.amount)
try encoder.encode(self.symbol.precision) try encoder.encode(self.symbol.precision)
let chars = self.symbol.name.utf8 let chars = self.symbol.name.utf8

10
Sources/VIZ/Authority.swift
View File

@ -1,15 +1,15 @@
/// Steem authority types. /// VIZ authority types.
/// - Author: Johan Nordberg <johan@steemit.com> /// - Author: Johan Nordberg <johan@steemit.com>
import Foundation import Foundation
/// Type representing a Steem authority. /// Type representing a VIZ authority.
/// ///
/// Authorities are a collection of accounts and keys that need to sign /// Authorities are a collection of accounts and keys that need to sign
/// a message for it to be considered valid. /// a message for it to be considered valid.
public struct Authority: SteemCodable, Equatable { public struct Authority: VIZCodable, Equatable {
/// A type representing a key or account auth and its weight. /// A type representing a key or account auth and its weight.
public struct Auth<T: SteemCodable & Equatable>: Equatable { public struct Auth<T: VIZCodable & Equatable>: Equatable {
public let value: T public let value: T
public let weight: UInt16 public let weight: UInt16
} }
@ -29,7 +29,7 @@ extension Authority.Auth {
} }
} }
extension Authority.Auth: SteemCodable { extension Authority.Auth: VIZCodable {
public init(from decoder: Decoder) throws { public init(from decoder: Decoder) throws {
var container = try decoder.unkeyedContainer() var container = try decoder.unkeyedContainer()
self.value = try container.decode(T.self) self.value = try container.decode(T.self)

10
Sources/VIZ/Block.swift
View File

@ -1,9 +1,9 @@
/// Steem block types. /// VIZ block types.
/// - Author: Johan Nordberg <johan@steemit.com> /// - Author: Johan Nordberg <johan@steemit.com>
import Foundation import Foundation
/// Type representing a Steem block ID. /// Type representing a VIZ block ID.
public struct BlockId: Codable, Equatable { public struct BlockId: Codable, Equatable {
/// The block hash. /// The block hash.
public var hash: Data public var hash: Data
@ -52,7 +52,7 @@ fileprivate protocol _BlockHeader: Codable {
var extensions: [BlockExtension] { get } var extensions: [BlockExtension] { get }
} }
/// A type representing a Steem block header. /// A type representing a VIZ block header.
public struct BlockHeader: _BlockHeader { public struct BlockHeader: _BlockHeader {
public let previous: BlockId public let previous: BlockId
public let timestamp: Date public let timestamp: Date
@ -61,7 +61,7 @@ public struct BlockHeader: _BlockHeader {
public let extensions: [BlockExtension] public let extensions: [BlockExtension]
} }
/// A type representing a signed Steem block header. /// A type representing a signed VIZ block header.
public struct SignedBlockHeader: _BlockHeader, Equatable { public struct SignedBlockHeader: _BlockHeader, Equatable {
public let previous: BlockId public let previous: BlockId
public let timestamp: Date public let timestamp: Date
@ -71,7 +71,7 @@ public struct SignedBlockHeader: _BlockHeader, Equatable {
public let witnessSignature: Signature public let witnessSignature: Signature
} }
/// A type representing a Steem block. /// A type representing a VIZ block.
public struct SignedBlock: _BlockHeader, Equatable { public struct SignedBlock: _BlockHeader, Equatable {
/// The transactions included in this block. /// The transactions included in this block.
public let transactions: [Transaction] public let transactions: [Transaction]

6
Sources/VIZ/ChainId.swift
View File

@ -1,11 +1,11 @@
/// Steem chain identifiers. /// VIZ chain identifiers.
/// - Author: Johan Nordberg <johan@steemit.com> /// - Author: Johan Nordberg <johan@steemit.com>
import Foundation import Foundation
/// Chain id, used to sign transactions. /// Chain id, used to sign transactions.
public enum ChainId: Equatable { public enum ChainId: Equatable {
/// The main Steem network. /// The main VIZ network.
case mainNet case mainNet
/// Defualt testing network id. /// Defualt testing network id.
case testNet case testNet
@ -21,7 +21,7 @@ public enum ChainId: Equatable {
} }
} }
fileprivate let mainNetId = Data(hexEncoded: "0000000000000000000000000000000000000000000000000000000000000000") fileprivate let mainNetId = Data(hexEncoded: "2040effda178d4fffff5eab7a915d4019879f5205cc5392e4bcced2b6edda0cd")
fileprivate let testNetId = Data(hexEncoded: "46d82ab7d8db682eb1959aed0ada039a6d49afa1602491f93dde9cac3e8e6c32") fileprivate let testNetId = Data(hexEncoded: "46d82ab7d8db682eb1959aed0ada039a6d49afa1602491f93dde9cac3e8e6c32")
extension ChainId { extension ChainId {

65
Sources/VIZ/Client.swift
View File

@ -1,4 +1,4 @@
/// Steem-flavoured JSON-RPC 2.0 client. /// JSON-RPC 2.0 client.
/// - Author: Johan Nordberg <johan@steemit.com> /// - Author: Johan Nordberg <johan@steemit.com>
import AnyCodable import AnyCodable
@ -12,7 +12,7 @@ import Foundation
/// let hello: String /// let hello: String
/// let foo: Int /// let foo: Int
/// } /// }
/// struct MyRequest: Steem.Request { /// struct MyRequest: VIZ.Request {
/// typealias Response = MyResponse /// typealias Response = MyResponse
/// let method = "my_method" /// let method = "my_method"
/// let params: RequestParams<String> /// let params: RequestParams<String>
@ -26,6 +26,7 @@ public protocol Request {
associatedtype Response: Decodable associatedtype Response: Decodable
/// Request parameter type. /// Request parameter type.
associatedtype Params: Encodable associatedtype Params: Encodable
var api: String { get }
/// JSON-RPC 2.0 method to call. /// JSON-RPC 2.0 method to call.
var method: String { get } var method: String { get }
/// JSON-RPC 2.0 parameters /// JSON-RPC 2.0 parameters
@ -34,6 +35,36 @@ public protocol Request {
// Default implementation sends a request without params. // Default implementation sends a request without params.
extension Request { extension Request {
public var api: String {
switch method {
case "get_key_references":
return "account_by_key"
case "get_account_history":
return "account_history"
case "get_committee_request", "get_committee_request_votes", "get_committee_requests_list":
return "committee_api"
case "get_account":
return "custom_protocol_api"
case "get_block", "get_block_header", "set_block_applied_callback", "get_chain_properties", "get_config", "get_database_info", "get_dynamic_global_properties", "get_hardfork_version", "get_next_scheduled_hardfork":
return "database_api"
case "get_account_count", "get_accounts", "get_accounts_on_sale", "get_escrow", "get_expiring_vesting_delegations", "get_owner_history", "get_recovery_request", "get_subaccounts_on_sale", "get_vesting_delegations", "get_withdraw_routes", "lookup_account_names", "lookup_accounts":
return "database_api"
case "get_potential_signatures", "get_proposed_transaction", "get_proposed_transactions", "get_required_signatures", "get_transaction_hex", "verify_account_authority", "verify_authority":
return "database_api"
case "get_invite_by_id", "get_invite_by_key", "get_invites_list":
return "invite_api"
case "broadcast_block", "broadcast_transaction", "broadcast_transaction_synchronous", "broadcast_transaction_with_callback":
return "network_broadcast_api"
case "get_ops_in_block", "get_transaction":
return "operation_history"
case "get_active_paid_subscriptions", "get_inactive_paid_subscriptions", "get_paid_subscription_options", "get_paid_subscription_status", "get_paid_subscriptions":
return "paid_subscription_api"
case "get_active_witnesses", "get_witness_by_account", "get_witness_count", "get_witness_schedule", "get_witnesses", "get_witnesses_by_counted_vote", "get_witnesses_by_vote", "lookup_witness_accounts":
return "witness_api"
default:
return method
}
}
public var params: RequestParams<AnyEncodable>? { public var params: RequestParams<AnyEncodable>? {
return nil return nil
} }
@ -83,7 +114,7 @@ extension RequestParams: Encodable {
} }
/// JSON-RPC 2.0 request payload wrapper. /// JSON-RPC 2.0 request payload wrapper.
internal struct RequestPayload<Request: Steem.Request> { internal struct RequestPayload<Request: VIZ.Request> {
let request: Request let request: Request
let id: Int let id: Int
} }
@ -95,13 +126,27 @@ extension RequestPayload: Encodable {
case method case method
case params case params
} }
struct Params: Encodable {
let api: String
let method: String
let params: Request.Params?
func encode(to encoder: Encoder) throws {
var container = encoder.unkeyedContainer()
try container.encode(api)
try container.encode(method)
try container.encode(params)
}
}
func encode(to encoder: Encoder) throws { func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: Keys.self) var container = encoder.container(keyedBy: Keys.self)
try container.encode(self.id, forKey: .id) try container.encode(self.id, forKey: .id)
try container.encode("2.0", forKey: .jsonrpc) try container.encode("2.0", forKey: .jsonrpc)
try container.encode(self.request.method, forKey: .method) try container.encode("call", forKey: .method)
try container.encodeIfPresent(self.request.params, forKey: .params) let params = Params(api: self.request.api, method: self.request.method, params: self.request.params)
try container.encode(params, forKey: .params)
} }
} }
@ -159,7 +204,7 @@ internal struct SeqIdGenerator: IdGenerator {
} }
} }
/// Steem-flavoured JSON-RPC 2.0 client. /// VIZ-flavoured JSON-RPC 2.0 client.
public class Client { public class Client {
/// All errors `Client` can throw. /// All errors `Client` can throw.
public enum Error: LocalizedError { public enum Error: LocalizedError {
@ -205,7 +250,7 @@ public class Client {
let encoder = Client.JSONEncoder() let encoder = Client.JSONEncoder()
var urlRequest = URLRequest(url: self.address) var urlRequest = URLRequest(url: self.address)
urlRequest.setValue("application/json", forHTTPHeaderField: "Content-Type") urlRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
urlRequest.setValue("swift-steem/1.0", forHTTPHeaderField: "User-Agent") urlRequest.setValue("swift-viz/1.0", forHTTPHeaderField: "User-Agent")
urlRequest.httpMethod = "POST" urlRequest.httpMethod = "POST"
urlRequest.httpBody = try encoder.encode(payload) urlRequest.httpBody = try encoder.encode(payload)
return urlRequest return urlRequest
@ -296,7 +341,7 @@ public class Client {
/// JSON Coding helpers. /// JSON Coding helpers.
extension Client { extension Client {
/// Steem-style date formatter (ISO 8601 minus Z at the end). /// VIZ-style date formatter (ISO 8601 minus Z at the end).
public static let dateFormatter: DateFormatter = { public static let dateFormatter: DateFormatter = {
let formatter = DateFormatter() let formatter = DateFormatter()
formatter.calendar = Calendar(identifier: .iso8601) formatter.calendar = Calendar(identifier: .iso8601)
@ -329,7 +374,7 @@ extension Client {
return Data(hexEncoded: try container.decode(String.self)) return Data(hexEncoded: try container.decode(String.self))
} }
/// Returns a JSONDecoder instance configured for the Steem JSON format. /// Returns a JSONDecoder instance configured for the VIZ JSON format.
public static func JSONDecoder() -> Foundation.JSONDecoder { public static func JSONDecoder() -> Foundation.JSONDecoder {
let decoder = Foundation.JSONDecoder() let decoder = Foundation.JSONDecoder()
decoder.dataDecodingStrategy = dataDecoder decoder.dataDecodingStrategy = dataDecoder
@ -340,7 +385,7 @@ extension Client {
return decoder return decoder
} }
/// Returns a JSONEncoder instance configured for the Steem JSON format. /// Returns a JSONEncoder instance configured for the VIZ JSON format.
public static func JSONEncoder() -> Foundation.JSONEncoder { public static func JSONEncoder() -> Foundation.JSONEncoder {
let encoder = Foundation.JSONEncoder() let encoder = Foundation.JSONEncoder()
encoder.dataEncodingStrategy = dataEncoder encoder.dataEncodingStrategy = dataEncoder

2
Sources/VIZ/Hex.swift
View File

@ -16,7 +16,7 @@ internal extension Data {
} }
bytes[index >> 1] |= n bytes[index >> 1] |= n
} }
self = Data(bytes: bytes) self = Data(bytes)
} }
struct HexEncodingOptions: OptionSet { struct HexEncodingOptions: OptionSet {

10
Sources/VIZ/Misc.swift
View File

@ -1,13 +1,13 @@
/// Misc Steem protocol types. /// Misc VIZ protocol types.
/// - Author: Johan Nordberg <johan@steemit.com> /// - Author: Johan Nordberg <johan@steemit.com>
import Foundation import Foundation
/// A type that is decodable to Steem binary format as well as JSON encodable and decodable. /// A type that is decodable to VIZ binary format as well as JSON encodable and decodable.
public typealias SteemCodable = SteemEncodable & Decodable public typealias VIZCodable = VIZEncodable & Decodable
/// Placeholder type for future extensions. /// Placeholder type for future extensions.
public struct FutureExtensions: SteemCodable, Equatable {} public struct FutureExtensions: VIZCodable, Equatable {}
/// Type representing an optional JSON string. /// Type representing an optional JSON string.
public struct JSONString: Equatable { public struct JSONString: Equatable {
@ -29,7 +29,7 @@ public struct JSONString: Equatable {
} }
} }
extension JSONString: SteemCodable { extension JSONString: VIZCodable {
public init(from decoder: Decoder) throws { public init(from decoder: Decoder) throws {
let container = try decoder.singleValueContainer() let container = try decoder.singleValueContainer()
self.value = try container.decode(String.self) self.value = try container.decode(String.self)

241
Sources/VIZ/Operation.swift
View File

@ -1,10 +1,10 @@
/// Steem operation types. /// VIZ operation types.
/// - Author: Johan Nordberg <johan@steemit.com> /// - Author: Johan Nordberg <johan@steemit.com>
import Foundation import Foundation
/// A type that represents a operation on the Steem blockchain. /// A type that represents a operation on the VIZ blockchain.
public protocol OperationType: SteemCodable { public protocol OperationType: VIZCodable {
/// Whether the operation is virtual or not. /// Whether the operation is virtual or not.
var isVirtual: Bool { get } var isVirtual: Bool { get }
} }
@ -13,7 +13,7 @@ extension OperationType {
public var isVirtual: Bool { return false } public var isVirtual: Bool { return false }
} }
/// Namespace for all available Steem operations. /// Namespace for all available VIZ operations.
public struct Operation { public struct Operation {
/// Voting operation, votes for content. /// Voting operation, votes for content.
public struct Vote: OperationType, Equatable { public struct Vote: OperationType, Equatable {
@ -100,13 +100,13 @@ public struct Operation {
} }
} }
/// Converts STEEM to VESTS, aka. "Powering Up". /// Converts VIZ to VESTS, aka. "Powering Up".
public struct TransferToVesting: OperationType, Equatable { public struct TransferToVesting: OperationType, Equatable {
/// Account name of sender. /// Account name of sender.
public var from: String public var from: String
/// Account name of reciever. /// Account name of reciever.
public var to: String public var to: String
/// Amount to power up, must be STEEM. /// Amount to power up, must be VIZ.
public var amount: Asset public var amount: Asset
public init(from: String, to: String, amount: Asset) { public init(from: String, to: String, amount: Asset) {
@ -129,54 +129,6 @@ public struct Operation {
} }
} }
/// This operation creates a limit order and matches it against existing open orders.
public struct LimitOrderCreate: OperationType, Equatable {
public var owner: String
public var orderid: UInt32
public var amountToSell: Asset
public var minToReceive: Asset
public var fillOrKill: Bool
public var expiration: Date
public init(
owner: String,
orderid: UInt32,
amountToSell: Asset,
minToReceive: Asset,
fillOrKill: Bool,
expiration: Date
) {
self.owner = owner
self.orderid = orderid
self.amountToSell = amountToSell
self.minToReceive = minToReceive
self.fillOrKill = fillOrKill
self.expiration = expiration
}
}
/// Cancels an order and returns the balance to owner.
public struct LimitOrderCancel: OperationType, Equatable {
public var owner: String
public var orderid: UInt32
public init(owner: String, orderid: UInt32) {
self.owner = owner
self.orderid = orderid
}
}
/// Publish a price feed.
public struct FeedPublish: OperationType, Equatable {
public var publisher: String
public var exchangeRate: Price
public init(publisher: String, exchangeRate: Price) {
self.publisher = publisher
self.exchangeRate = exchangeRate
}
}
/// Convert operation. /// Convert operation.
public struct Convert: OperationType, Equatable { public struct Convert: OperationType, Equatable {
public var owner: String public var owner: String
@ -195,9 +147,9 @@ public struct Operation {
public var fee: Asset public var fee: Asset
public var creator: String public var creator: String
public var newAccountName: String public var newAccountName: String
public var owner: Authority public var master: Authority
public var active: Authority public var active: Authority
public var posting: Authority public var regular: Authority
public var memoKey: PublicKey public var memoKey: PublicKey
public var jsonMetadata: JSONString public var jsonMetadata: JSONString
@ -205,18 +157,18 @@ public struct Operation {
fee: Asset, fee: Asset,
creator: String, creator: String,
newAccountName: String, newAccountName: String,
owner: Authority, master: Authority,
active: Authority, active: Authority,
posting: Authority, regular: Authority,
memoKey: PublicKey, memoKey: PublicKey,
jsonMetadata: JSONString = "" jsonMetadata: JSONString = ""
) { ) {
self.fee = fee self.fee = fee
self.creator = creator self.creator = creator
self.newAccountName = newAccountName self.newAccountName = newAccountName
self.owner = owner self.master = master
self.active = active self.active = active
self.posting = posting self.regular = regular
self.memoKey = memoKey self.memoKey = memoKey
self.jsonMetadata = jsonMetadata self.jsonMetadata = jsonMetadata
} }
@ -231,24 +183,24 @@ public struct Operation {
/// Updates an account. /// Updates an account.
public struct AccountUpdate: OperationType, Equatable { public struct AccountUpdate: OperationType, Equatable {
public var account: String public var account: String
public var owner: Authority? public var masterAuthority: Authority?
public var active: Authority? public var activeAuthority: Authority?
public var posting: Authority? public var regularAuthority: Authority?
public var memoKey: PublicKey public var memoKey: PublicKey
public var jsonMetadata: String public var jsonMetadata: String
public init( public init(
account: String, account: String,
owner: Authority?, masterAuthority: Authority?,
active: Authority?, activeAuthority: Authority?,
posting: Authority?, regularAuthority: Authority?,
memoKey: PublicKey, memoKey: PublicKey,
jsonMetadata: String = "" jsonMetadata: String = ""
) { ) {
self.account = account self.account = account
self.owner = owner self.masterAuthority = masterAuthority
self.active = active self.activeAuthority = activeAuthority
self.posting = posting self.regularAuthority = regularAuthority
self.memoKey = memoKey self.memoKey = memoKey
self.jsonMetadata = jsonMetadata self.jsonMetadata = jsonMetadata
} }
@ -257,7 +209,7 @@ public struct Operation {
/// Registers or updates witnesses. /// Registers or updates witnesses.
public struct WitnessUpdate: OperationType, Equatable { public struct WitnessUpdate: OperationType, Equatable {
/// Witness chain properties. /// Witness chain properties.
public struct Properties: SteemCodable, Equatable { public struct Properties: VIZCodable, Equatable {
// public var accountCreationFee: Asset // public var accountCreationFee: Asset
// public var maximumBlockSize: UInt32 // public var maximumBlockSize: UInt32
// public var sbdInterestRate: UInt16 // public var sbdInterestRate: UInt16
@ -313,16 +265,19 @@ public struct Operation {
/// Custom operation. /// Custom operation.
public struct Custom: OperationType, Equatable { public struct Custom: OperationType, Equatable {
public var requiredAuths: [String] public var requiredRegularAuths: [String]
public var requiredActiveAuths: [String]
public var id: UInt16 public var id: UInt16
public var data: Data public var data: Data
public init( public init(
requiredAuths: [String], requiredRegularAuths: [String],
requiredActiveAuths: [String],
id: UInt16, id: UInt16,
data: Data data: Data
) { ) {
self.requiredAuths = requiredAuths self.requiredRegularAuths = requiredRegularAuths
self.requiredActiveAuths = requiredActiveAuths
self.id = id self.id = id
self.data = data self.data = data
} }
@ -378,13 +333,13 @@ public struct Operation {
/// Sets comment options. /// Sets comment options.
public struct CommentOptions: OperationType, Equatable { public struct CommentOptions: OperationType, Equatable {
public struct BeneficiaryRoute: SteemCodable, Equatable { public struct BeneficiaryRoute: VIZCodable, Equatable {
public var account: String public var account: String
public var weight: UInt16 public var weight: UInt16
} }
/// Comment option extensions. /// Comment option extensions.
public enum Extension: SteemCodable, Equatable { public enum Extension: VIZCodable, Equatable {
/// Unknown extension. /// Unknown extension.
case unknown case unknown
/// Comment payout routing. /// Comment payout routing.
@ -438,32 +393,6 @@ public struct Operation {
} }
} }
/// Creates a limit order using a exchange price.
public struct LimitOrderCreate2: OperationType, Equatable {
public var owner: String
public var orderid: UInt32
public var amountToSell: Asset
public var fillOrKill: Bool
public var exchangeRate: Price
public var expiration: Date
public init(
owner: String,
orderid: UInt32,
amountToSell: Asset,
fillOrKill: Bool,
exchangeRate: Price,
expiration: Date
) {
self.owner = owner
self.orderid = orderid
self.amountToSell = amountToSell
self.fillOrKill = fillOrKill
self.exchangeRate = exchangeRate
self.expiration = expiration
}
}
public struct ChallengeAuthority: OperationType, Equatable { public struct ChallengeAuthority: OperationType, Equatable {
public var challenger: String public var challenger: String
public var challenged: String public var challenged: String
@ -835,9 +764,9 @@ public struct Operation {
public var delegation: Asset public var delegation: Asset
public var creator: String public var creator: String
public var newAccountName: String public var newAccountName: String
public var owner: Authority public var master: Authority
public var active: Authority public var active: Authority
public var posting: Authority public var regular: Authority
public var memoKey: PublicKey public var memoKey: PublicKey
public var jsonMetadata: JSONString public var jsonMetadata: JSONString
public var extensions: [FutureExtensions] public var extensions: [FutureExtensions]
@ -847,9 +776,9 @@ public struct Operation {
delegation: Asset, delegation: Asset,
creator: String, creator: String,
newAccountName: String, newAccountName: String,
owner: Authority, master: Authority,
active: Authority, active: Authority,
posting: Authority, regular: Authority,
memoKey: PublicKey, memoKey: PublicKey,
jsonMetadata: JSONString = "", jsonMetadata: JSONString = "",
extensions: [FutureExtensions] = [] extensions: [FutureExtensions] = []
@ -858,9 +787,9 @@ public struct Operation {
self.delegation = delegation self.delegation = delegation
self.creator = creator self.creator = creator
self.newAccountName = newAccountName self.newAccountName = newAccountName
self.owner = owner self.master = master
self.active = active self.active = active
self.posting = posting self.regular = regular
self.memoKey = memoKey self.memoKey = memoKey
self.jsonMetadata = jsonMetadata self.jsonMetadata = jsonMetadata
self.extensions = extensions self.extensions = extensions
@ -981,6 +910,15 @@ public struct Operation {
public let producer: String public let producer: String
public let vestingShares: Asset public let vestingShares: Asset
} }
public struct Award: OperationType, Equatable {
public let initiator: String
public let receiver: String
public let energy: UInt16
public let customSequence: UInt64
public let memo: String
// public let beneficiaries: [Beneficiary]
}
/// Unknown operation, seen if the decoder encounters operation which has no type defined. /// Unknown operation, seen if the decoder encounters operation which has no type defined.
/// - Note: Not encodable, the encoder will throw if encountering this operation. /// - Note: Not encodable, the encoder will throw if encountering this operation.
@ -990,15 +928,15 @@ public struct Operation {
// MARK: - Encoding // MARK: - Encoding
/// Operation ID, used for coding. /// Operation ID, used for coding.
fileprivate enum OperationId: UInt8, SteemEncodable, Decodable { fileprivate enum OperationId: UInt8, VIZEncodable, Decodable {
case vote = 0 case vote = 0
case comment = 1 case comment = 1
case transfer = 2 case transfer = 2
case transfer_to_vesting = 3 case transfer_to_vesting = 3
case withdraw_vesting = 4 case withdraw_vesting = 4
case limit_order_create = 5 // case limit_order_create = 5
case limit_order_cancel = 6 // case limit_order_cancel = 6
case feed_publish = 7 // case feed_publish = 7
case convert = 8 case convert = 8
case account_create = 9 case account_create = 9
case account_update = 10 case account_update = 10
@ -1012,7 +950,7 @@ fileprivate enum OperationId: UInt8, SteemEncodable, Decodable {
case custom_json = 18 case custom_json = 18
case comment_options = 19 case comment_options = 19
case set_withdraw_vesting_route = 20 case set_withdraw_vesting_route = 20
case limit_order_create2 = 21 // case limit_order_create2 = 21
case challenge_authority = 22 case challenge_authority = 22
case prove_authority = 23 case prove_authority = 23
case request_account_recovery = 24 case request_account_recovery = 24
@ -1033,7 +971,6 @@ fileprivate enum OperationId: UInt8, SteemEncodable, Decodable {
case claim_reward_balance = 39 case claim_reward_balance = 39
case delegate_vesting_shares = 40 case delegate_vesting_shares = 40
case account_create_with_delegation = 41 case account_create_with_delegation = 41
// Virtual operations
case fill_convert_request case fill_convert_request
case author_reward case author_reward
case curation_reward case curation_reward
@ -1049,6 +986,21 @@ fileprivate enum OperationId: UInt8, SteemEncodable, Decodable {
case return_vesting_delegation case return_vesting_delegation
case comment_benefactor_reward case comment_benefactor_reward
case producer_reward case producer_reward
case create_invite
case claim_invite_balance
case invite_registration
case versioned_chain_properties_update
case award
case receive_award //Virtual Operation
case benefactor_award //Virtual Operation
case set_paid_subscription
case paid_subscribe
case paid_subscription_action //Virtual Operation
case cancel_paid_subscription //Virtual Operation
case set_account_price
case set_subaccount_price
case buy_account
case account_sale //Virtual Operation
case unknown = 255 case unknown = 255
init(from decoder: Decoder) throws { init(from decoder: Decoder) throws {
@ -1060,9 +1012,6 @@ fileprivate enum OperationId: UInt8, SteemEncodable, Decodable {
case "transfer": self = .transfer case "transfer": self = .transfer
case "transfer_to_vesting": self = .transfer_to_vesting case "transfer_to_vesting": self = .transfer_to_vesting
case "withdraw_vesting": self = .withdraw_vesting case "withdraw_vesting": self = .withdraw_vesting
case "limit_order_create": self = .limit_order_create
case "limit_order_cancel": self = .limit_order_cancel
case "feed_publish": self = .feed_publish
case "convert": self = .convert case "convert": self = .convert
case "account_create": self = .account_create case "account_create": self = .account_create
case "account_update": self = .account_update case "account_update": self = .account_update
@ -1076,7 +1025,6 @@ fileprivate enum OperationId: UInt8, SteemEncodable, Decodable {
case "custom_json": self = .custom_json case "custom_json": self = .custom_json
case "comment_options": self = .comment_options case "comment_options": self = .comment_options
case "set_withdraw_vesting_route": self = .set_withdraw_vesting_route case "set_withdraw_vesting_route": self = .set_withdraw_vesting_route
case "limit_order_create2": self = .limit_order_create2
case "challenge_authority": self = .challenge_authority case "challenge_authority": self = .challenge_authority
case "prove_authority": self = .prove_authority case "prove_authority": self = .prove_authority
case "request_account_recovery": self = .request_account_recovery case "request_account_recovery": self = .request_account_recovery
@ -1112,6 +1060,21 @@ fileprivate enum OperationId: UInt8, SteemEncodable, Decodable {
case "return_vesting_delegation": self = .return_vesting_delegation case "return_vesting_delegation": self = .return_vesting_delegation
case "comment_benefactor_reward": self = .comment_benefactor_reward case "comment_benefactor_reward": self = .comment_benefactor_reward
case "producer_reward": self = .producer_reward case "producer_reward": self = .producer_reward
case "create_invite": self = .create_invite
case "claim_invite_balance": self = .claim_invite_balance
case "invite_registration": self = .invite_registration
case "versioned_chain_properties_update": self = .versioned_chain_properties_update
case "award": self = .award
case "receive_award": self = .receive_award //Virtual Operation
case "benefactor_award": self = .benefactor_award //Virtual Operation
case "set_paid_subscription": self = .set_paid_subscription
case "paid_subscribe": self = .paid_subscribe
case "paid_subscription_action": self = .paid_subscription_action //Virtual Operation
case "cancel_paid_subscription": self = .cancel_paid_subscription //Virtual Operation
case "set_account_price": self = .set_account_price
case "set_subaccount_price": self = .set_subaccount_price
case "buy_account": self = .buy_account
case "account_sale": self = .account_sale //Virtual Operation
default: self = .unknown default: self = .unknown
} }
} }
@ -1121,13 +1084,13 @@ fileprivate enum OperationId: UInt8, SteemEncodable, Decodable {
try container.encode("\(self)") try container.encode("\(self)")
} }
func binaryEncode(to encoder: SteemEncoder) throws { func binaryEncode(to encoder: VIZEncoder) throws {
try encoder.encode(self.rawValue) try encoder.encode(self.rawValue)
} }
} }
/// A type-erased Steem operation. /// A type-erased VIZ operation.
internal struct AnyOperation: SteemEncodable, Decodable { internal struct AnyOperation: VIZEncodable, Decodable {
public let operation: OperationType public let operation: OperationType
/// Create a new operation wrapper. /// Create a new operation wrapper.
@ -1149,9 +1112,6 @@ internal struct AnyOperation: SteemEncodable, Decodable {
case .transfer: op = try container.decode(Operation.Transfer.self) case .transfer: op = try container.decode(Operation.Transfer.self)
case .transfer_to_vesting: op = try container.decode(Operation.TransferToVesting.self) case .transfer_to_vesting: op = try container.decode(Operation.TransferToVesting.self)
case .withdraw_vesting: op = try container.decode(Operation.WithdrawVesting.self) case .withdraw_vesting: op = try container.decode(Operation.WithdrawVesting.self)
case .limit_order_create: op = try container.decode(Operation.LimitOrderCancel.self)
case .limit_order_cancel: op = try container.decode(Operation.LimitOrderCancel.self)
case .feed_publish: op = try container.decode(Operation.FeedPublish.self)
case .convert: op = try container.decode(Operation.Convert.self) case .convert: op = try container.decode(Operation.Convert.self)
case .account_create: op = try container.decode(Operation.AccountCreate.self) case .account_create: op = try container.decode(Operation.AccountCreate.self)
case .account_update: op = try container.decode(Operation.AccountUpdate.self) case .account_update: op = try container.decode(Operation.AccountUpdate.self)
@ -1165,7 +1125,6 @@ internal struct AnyOperation: SteemEncodable, Decodable {
case .custom_json: op = try container.decode(Operation.CustomJson.self) case .custom_json: op = try container.decode(Operation.CustomJson.self)
case .comment_options: op = try container.decode(Operation.CommentOptions.self) case .comment_options: op = try container.decode(Operation.CommentOptions.self)
case .set_withdraw_vesting_route: op = try container.decode(Operation.SetWithdrawVestingRoute.self) case .set_withdraw_vesting_route: op = try container.decode(Operation.SetWithdrawVestingRoute.self)
case .limit_order_create2: op = try container.decode(Operation.LimitOrderCreate2.self)
case .challenge_authority: op = try container.decode(Operation.ChallengeAuthority.self) case .challenge_authority: op = try container.decode(Operation.ChallengeAuthority.self)
case .prove_authority: op = try container.decode(Operation.ProveAuthority.self) case .prove_authority: op = try container.decode(Operation.ProveAuthority.self)
case .request_account_recovery: op = try container.decode(Operation.RequestAccountRecovery.self) case .request_account_recovery: op = try container.decode(Operation.RequestAccountRecovery.self)
@ -1201,6 +1160,23 @@ internal struct AnyOperation: SteemEncodable, Decodable {
case .return_vesting_delegation: op = try container.decode(Operation.ReturnVestingDelegation.self) case .return_vesting_delegation: op = try container.decode(Operation.ReturnVestingDelegation.self)
case .comment_benefactor_reward: op = try container.decode(Operation.CommentBenefactorReward.self) case .comment_benefactor_reward: op = try container.decode(Operation.CommentBenefactorReward.self)
case .producer_reward: op = try container.decode(Operation.ProducerReward.self) case .producer_reward: op = try container.decode(Operation.ProducerReward.self)
case .create_invite: op = Operation.Unknown()
case .claim_invite_balance: op = Operation.Unknown()
case .invite_registration: op = Operation.Unknown()
case .versioned_chain_properties_update: op = Operation.Unknown()
case .award: op = try container.decode(Operation.Award.self)
case .receive_award: op = Operation.Unknown()
case .benefactor_award: op = Operation.Unknown()
case .set_paid_subscription: op = Operation.Unknown()
case .paid_subscribe: op = Operation.Unknown()
case .paid_subscription_action: op = Operation.Unknown()
case .cancel_paid_subscription: op = Operation.Unknown()
case .set_account_price: op = Operation.Unknown()
case .set_subaccount_price: op = Operation.Unknown()
case .buy_account: op = Operation.Unknown()
case .account_sale: op = Operation.Unknown()
case .unknown: op = Operation.Unknown() case .unknown: op = Operation.Unknown()
} }
self.operation = op self.operation = op
@ -1224,15 +1200,6 @@ internal struct AnyOperation: SteemEncodable, Decodable {
case let op as Operation.WithdrawVesting: case let op as Operation.WithdrawVesting:
try container.encode(OperationId.withdraw_vesting) try container.encode(OperationId.withdraw_vesting)
try container.encode(op) try container.encode(op)
case let op as Operation.LimitOrderCreate:
try container.encode(OperationId.limit_order_create)
try container.encode(op)
case let op as Operation.LimitOrderCancel:
try container.encode(OperationId.limit_order_cancel)
try container.encode(op)
case let op as Operation.FeedPublish:
try container.encode(OperationId.feed_publish)
try container.encode(op)
case let op as Operation.Convert: case let op as Operation.Convert:
try container.encode(OperationId.convert) try container.encode(OperationId.convert)
try container.encode(op) try container.encode(op)
@ -1272,9 +1239,6 @@ internal struct AnyOperation: SteemEncodable, Decodable {
case let op as Operation.SetWithdrawVestingRoute: case let op as Operation.SetWithdrawVestingRoute:
try container.encode(OperationId.set_withdraw_vesting_route) try container.encode(OperationId.set_withdraw_vesting_route)
try container.encode(op) try container.encode(op)
case let op as Operation.LimitOrderCreate2:
try container.encode(OperationId.limit_order_create2)
try container.encode(op)
case let op as Operation.ChallengeAuthority: case let op as Operation.ChallengeAuthority:
try container.encode(OperationId.challenge_authority) try container.encode(OperationId.challenge_authority)
try container.encode(op) try container.encode(op)
@ -1335,6 +1299,9 @@ internal struct AnyOperation: SteemEncodable, Decodable {
case let op as Operation.AccountCreateWithDelegation: case let op as Operation.AccountCreateWithDelegation:
try container.encode(OperationId.account_create_with_delegation) try container.encode(OperationId.account_create_with_delegation)
try container.encode(op) try container.encode(op)
case let op as Operation.Award:
try container.encode(OperationId.award)
try container.encode(op)
default: default:
throw EncodingError.invalidValue(self.operation, EncodingError.Context( throw EncodingError.invalidValue(self.operation, EncodingError.Context(
codingPath: container.codingPath, debugDescription: "Encountered unknown operation type" codingPath: container.codingPath, debugDescription: "Encountered unknown operation type"
@ -1343,7 +1310,7 @@ internal struct AnyOperation: SteemEncodable, Decodable {
} }
} }
fileprivate struct BeneficiaryWrapper: SteemEncodable, Equatable, Decodable { fileprivate struct BeneficiaryWrapper: VIZEncodable, Equatable, Decodable {
var beneficiaries: [Operation.CommentOptions.BeneficiaryRoute] var beneficiaries: [Operation.CommentOptions.BeneficiaryRoute]
} }

4
Sources/VIZ/PrivateKey.swift
View File

@ -1,9 +1,9 @@
/// Steem PrivateKey implementation. /// VIZ PrivateKey implementation.
/// - Author: Johan Nordberg <johan@steemit.com> /// - Author: Johan Nordberg <johan@steemit.com>
import Foundation import Foundation
/// A Steem private key. /// A VIZ private key.
public struct PrivateKey: Equatable { public struct PrivateKey: Equatable {
private let secret: Data private let secret: Data

29
Sources/VIZ/PublicKey.swift
View File

@ -1,17 +1,14 @@
/// Steem PublicKey implementation. /// VIZ PublicKey implementation.
/// - Author: Johan Nordberg <johan@steemit.com> /// - Author: Johan Nordberg <johan@steemit.com>
import Foundation import Foundation
/// A Steem public key. /// A VIZ public key.
public struct PublicKey: Equatable { public struct PublicKey: Equatable {
/// Chain address prefix. /// Chain address prefix.
public enum AddressPrefix: Equatable, Hashable { public enum AddressPrefix: Equatable, Hashable {
/// STM, main network. case mainNet // VIZ
case mainNet case testNet // VIZ
/// TST, test networks.
case testNet
/// Freeform address prefix, e.g. "STX".
case custom(String) case custom(String)
} }
@ -32,8 +29,8 @@ public struct PublicKey: Equatable {
self.prefix = prefix self.prefix = prefix
} }
/// Create a new PublicKey instance from a Steem public key address. /// Create a new PublicKey instance from a VIZ public key address.
/// - Parameter address: The public key in Steem address format. /// - Parameter address: The public key in VIZ address format.
public init?(_ address: String) { public init?(_ address: String) {
let prefix = address.prefix(3) let prefix = address.prefix(3)
guard prefix.count == 3 else { guard prefix.count == 3 else {
@ -66,7 +63,7 @@ extension PublicKey: LosslessStringConvertible {
public var description: String { return self.address } public var description: String { return self.address }
} }
extension PublicKey: SteemEncodable, Decodable { extension PublicKey: VIZEncodable, Decodable {
public init(from decoder: Decoder) throws { public init(from decoder: Decoder) throws {
let container = try decoder.singleValueContainer() let container = try decoder.singleValueContainer()
guard let key = PublicKey(try container.decode(String.self)) else { guard let key = PublicKey(try container.decode(String.self)) else {
@ -80,7 +77,7 @@ extension PublicKey: SteemEncodable, Decodable {
try container.encode(String(self)) try container.encode(String(self))
} }
public func binaryEncode(to encoder: SteemEncoder) { public func binaryEncode(to encoder: VIZEncoder) {
encoder.data.append(self.key) encoder.data.append(self.key)
} }
} }
@ -90,9 +87,9 @@ extension PublicKey.AddressPrefix: ExpressibleByStringLiteral, LosslessStringCon
/// Create new addres prefix from string. /// Create new addres prefix from string.
public init(_ value: String) { public init(_ value: String) {
if value == "STM" { if value == "VIZ" {
self = .mainNet self = .mainNet
} else if value == "TST" { } else if value == "VIZTEST" {
self = .testNet self = .testNet
} else { } else {
self = .custom(value) self = .custom(value)
@ -103,13 +100,13 @@ extension PublicKey.AddressPrefix: ExpressibleByStringLiteral, LosslessStringCon
self.init(value) self.init(value)
} }
/// String representation of address prefix, e.g. "STM". /// String representation of address prefix, e.g. "VIZ".
public var description: String { public var description: String {
switch self { switch self {
case .mainNet: case .mainNet:
return "STM" return "VIZ"
case .testNet: case .testNet:
return "TST" return "VIZ"
case let .custom(prefix): case let .custom(prefix):
return prefix.uppercased() return prefix.uppercased()
} }

4
Sources/VIZ/Signature.swift
View File

@ -1,9 +1,9 @@
/// Steem Signature implementation. /// VIZ Signature implementation.
/// - Author: Johan Nordberg <johan@steemit.com> /// - Author: Johan Nordberg <johan@steemit.com>
import Foundation import Foundation
/// A Steem signature. /// A VIZ signature.
public struct Signature: Equatable, LosslessStringConvertible { public struct Signature: Equatable, LosslessStringConvertible {
private let signature: Data private let signature: Data
private let recoveryId: UInt8 private let recoveryId: UInt8

8
Sources/VIZ/Transaction.swift
View File

@ -1,10 +1,10 @@
/// Steem transaction type. /// VIZ transaction type.
/// - Author: Johan Nordberg <johan@steemit.com> /// - Author: Johan Nordberg <johan@steemit.com>
import AnyCodable import AnyCodable
import Foundation import Foundation
fileprivate protocol _Transaction: SteemEncodable, Decodable { fileprivate protocol _Transaction: VIZEncodable, Decodable {
/// Block number reference. /// Block number reference.
var refBlockNum: UInt16 { get } var refBlockNum: UInt16 { get }
/// Block number reference id. /// Block number reference id.
@ -54,7 +54,7 @@ public struct Transaction: _Transaction {
/// SHA2-256 digest for signing. /// SHA2-256 digest for signing.
public func digest(forChain chain: ChainId = .mainNet) throws -> Data { public func digest(forChain chain: ChainId = .mainNet) throws -> Data {
var data = chain.data var data = chain.data
data.append(try SteemEncoder.encode(self)) data.append(try VIZEncoder.encode(self))
return data.sha256Digest() return data.sha256Digest()
} }
} }
@ -171,7 +171,7 @@ extension SignedTransaction {
// Workaround for: Swift runtime does not yet support dynamically querying conditional conformance. // Workaround for: Swift runtime does not yet support dynamically querying conditional conformance.
#if !swift(>=4.2) #if !swift(>=4.2)
extension Transaction { extension Transaction {
public func binaryEncode(to encoder: SteemEncoder) throws { public func binaryEncode(to encoder: VIZEncoder) throws {
try encoder.encode(self.refBlockNum) try encoder.encode(self.refBlockNum)
try encoder.encode(self.refBlockPrefix) try encoder.encode(self.refBlockPrefix)
try encoder.encode(self.expiration) try encoder.encode(self.expiration)

92
Sources/VIZ/VIZEncoder.swift
View File

@ -1,47 +1,47 @@
/// Steem protocol encoding. /// VIZ protocol encoding.
/// - Author: Johan Nordberg <johan@steemit.com> /// - Author: Johan Nordberg <johan@steemit.com>
import Foundation import Foundation
import OrderedDictionary import OrderedDictionary
/// A type that can be encoded into Steem binary wire format. /// A type that can be encoded into VIZ binary wire format.
public protocol SteemEncodable: Encodable { public protocol VIZEncodable: Encodable {
/// Encode self into Steem binary format. /// Encode self into VIZ binary format.
func binaryEncode(to encoder: SteemEncoder) throws func binaryEncode(to encoder: VIZEncoder) throws
} }
/// Default implementation which calls through to `Encodable`. /// Default implementation which calls through to `Encodable`.
public extension SteemEncodable { public extension VIZEncodable {
func binaryEncode(to encoder: SteemEncoder) throws { func binaryEncode(to encoder: VIZEncoder) throws {
try self.encode(to: encoder) try self.encode(to: encoder)
} }
} }
/// Encodes data into Steem binary format. /// Encodes data into VIZ binary format.
public class SteemEncoder { public class VIZEncoder {
/// All errors which `SteemEncoder` can throw. /// All errors which `VIZEncoder` can throw.
public enum Error: Swift.Error { public enum Error: Swift.Error {
/// Thrown if encoder encounters a type that is not conforming to `SteemEncodable`. /// Thrown if encoder encounters a type that is not conforming to `VIZEncodable`.
case typeNotConformingToSteemEncodable(Encodable.Type) case typeNotConformingToVIZEncodable(Encodable.Type)
/// Thrown if encoder encounters a type that is not confirming to `Encodable`. /// Thrown if encoder encounters a type that is not confirming to `Encodable`.
case typeNotConformingToEncodable(Any.Type) case typeNotConformingToEncodable(Any.Type)
} }
/// Data buffer holding the encoded bytes. /// Data buffer holding the encoded bytes.
/// - Note: Implementers of `SteemEncodable` can write directly into this. /// - Note: Implementers of `VIZEncodable` can write directly into this.
public var data = Data() public var data = Data()
/// Create a new encoder. /// Create a new encoder.
public init() {} public init() {}
/// Convenience for creating an encoder, encoding a value and returning the data. /// Convenience for creating an encoder, encoding a value and returning the data.
public static func encode(_ value: SteemEncodable) throws -> Data { public static func encode(_ value: VIZEncodable) throws -> Data {
let encoder = SteemEncoder() let encoder = VIZEncoder()
try value.binaryEncode(to: encoder) try value.binaryEncode(to: encoder)
return encoder.data return encoder.data
} }
/// Encodes any `SteemEncodable`. /// Encodes any `VIZEncodable`.
/// - Note: Platform specific integer types `Int` and `UInt` are encoded as varints. /// - Note: Platform specific integer types `Int` and `UInt` are encoded as varints.
public func encode(_ value: Encodable) throws { public func encode(_ value: Encodable) throws {
switch value { switch value {
@ -49,16 +49,16 @@ public class SteemEncoder {
self.appendVarint(UInt64(v)) self.appendVarint(UInt64(v))
case let v as UInt: case let v as UInt:
self.appendVarint(UInt64(v)) self.appendVarint(UInt64(v))
case let v as Array<SteemEncodable>: case let v as Array<VIZEncodable>:
self.appendVarint(UInt64(v.count)) self.appendVarint(UInt64(v.count))
for i in v { for i in v {
try i.binaryEncode(to: self) try i.binaryEncode(to: self)
} }
break break
case let v as SteemEncodable: case let v as VIZEncodable:
try v.binaryEncode(to: self) try v.binaryEncode(to: self)
default: default:
throw Error.typeNotConformingToSteemEncodable(type(of: value)) throw Error.typeNotConformingToVIZEncodable(type(of: value))
} }
} }
@ -84,7 +84,7 @@ public class SteemEncoder {
// Encoder conformance. // Encoder conformance.
// Based on Mike Ash's BinaryEncoder // Based on Mike Ash's BinaryEncoder
// https://github.com/mikeash/BinaryCoder // https://github.com/mikeash/BinaryCoder
extension SteemEncoder: Encoder { extension VIZEncoder: Encoder {
public var codingPath: [CodingKey] { return [] } public var codingPath: [CodingKey] { return [] }
public var userInfo: [CodingUserInfoKey: Any] { return [:] } public var userInfo: [CodingUserInfoKey: Any] { return [:] }
@ -102,7 +102,7 @@ extension SteemEncoder: Encoder {
} }
private struct KeyedContainer<Key: CodingKey>: KeyedEncodingContainerProtocol { private struct KeyedContainer<Key: CodingKey>: KeyedEncodingContainerProtocol {
var encoder: SteemEncoder var encoder: VIZEncoder
var codingPath: [CodingKey] { return [] } var codingPath: [CodingKey] { return [] }
@ -130,7 +130,7 @@ extension SteemEncoder: Encoder {
} }
private struct UnkeyedContanier: UnkeyedEncodingContainer, SingleValueEncodingContainer { private struct UnkeyedContanier: UnkeyedEncodingContainer, SingleValueEncodingContainer {
var encoder: SteemEncoder var encoder: VIZEncoder
var codingPath: [CodingKey] { return [] } var codingPath: [CodingKey] { return [] }
@ -158,30 +158,30 @@ extension SteemEncoder: Encoder {
// MARK: - Default type extensions // MARK: - Default type extensions
extension FixedWidthInteger where Self: SteemEncodable { extension FixedWidthInteger where Self: VIZEncodable {
public func binaryEncode(to encoder: SteemEncoder) { public func binaryEncode(to encoder: VIZEncoder) {
encoder.appendBytes(of: self.littleEndian) encoder.appendBytes(of: self.littleEndian)
} }
} }
extension Int8: SteemEncodable {} extension Int8: VIZEncodable {}
extension UInt8: SteemEncodable {} extension UInt8: VIZEncodable {}
extension Int16: SteemEncodable {} extension Int16: VIZEncodable {}
extension UInt16: SteemEncodable {} extension UInt16: VIZEncodable {}
extension Int32: SteemEncodable {} extension Int32: VIZEncodable {}
extension UInt32: SteemEncodable {} extension UInt32: VIZEncodable {}
extension Int64: SteemEncodable {} extension Int64: VIZEncodable {}
extension UInt64: SteemEncodable {} extension UInt64: VIZEncodable {}
extension String: SteemEncodable { extension String: VIZEncodable {
public func binaryEncode(to encoder: SteemEncoder) { public func binaryEncode(to encoder: VIZEncoder) {
encoder.appendVarint(UInt64(self.utf8.count)) encoder.appendVarint(UInt64(self.utf8.count))
encoder.data.append(contentsOf: self.utf8) encoder.data.append(contentsOf: self.utf8)
} }
} }
extension Array: SteemEncodable where Element: Encodable { extension Array: VIZEncodable where Element: Encodable {
public func binaryEncode(to encoder: SteemEncoder) throws { public func binaryEncode(to encoder: VIZEncoder) throws {
encoder.appendVarint(UInt64(self.count)) encoder.appendVarint(UInt64(self.count))
for item in self { for item in self {
try encoder.encode(item) try encoder.encode(item)
@ -189,8 +189,8 @@ extension Array: SteemEncodable where Element: Encodable {
} }
} }
extension OrderedDictionary: SteemEncodable where Key: SteemEncodable, Value: SteemEncodable { extension OrderedDictionary: VIZEncodable where Key: VIZEncodable, Value: VIZEncodable {
public func binaryEncode(to encoder: SteemEncoder) throws { public func binaryEncode(to encoder: VIZEncoder) throws {
encoder.appendVarint(UInt64(self.count)) encoder.appendVarint(UInt64(self.count))
for (key, value) in self { for (key, value) in self {
try encoder.encode(key) try encoder.encode(key)
@ -199,26 +199,26 @@ extension OrderedDictionary: SteemEncodable where Key: SteemEncodable, Value: St
} }
} }
extension Date: SteemEncodable { extension Date: VIZEncodable {
public func binaryEncode(to encoder: SteemEncoder) throws { public func binaryEncode(to encoder: VIZEncoder) throws {
try encoder.encode(UInt32(self.timeIntervalSince1970)) try encoder.encode(UInt32(self.timeIntervalSince1970))
} }
} }
extension Data: SteemEncodable { extension Data: VIZEncodable {
public func binaryEncode(to encoder: SteemEncoder) { public func binaryEncode(to encoder: VIZEncoder) {
encoder.data.append(self) encoder.data.append(self)
} }
} }
extension Bool: SteemEncodable { extension Bool: VIZEncodable {
public func binaryEncode(to encoder: SteemEncoder) { public func binaryEncode(to encoder: VIZEncoder) {
encoder.data.append(self ? 1 : 0) encoder.data.append(self ? 1 : 0)
} }
} }
extension Optional: SteemEncodable where Wrapped: SteemEncodable { extension Optional: VIZEncodable where Wrapped: VIZEncodable {
public func binaryEncode(to encoder: SteemEncoder) throws { public func binaryEncode(to encoder: VIZEncoder) throws {
if let value = self { if let value = self {
encoder.data.append(1) encoder.data.append(1)
try encoder.encode(value) try encoder.encode(value)

50
Sources/VIZ/VIZURL.swift
View File

@ -1,13 +1,11 @@
/// Steem signing URLs. /// VIZ signing URLs.
/// - Author: Johan Nordberg <johan@steemit.com> /// - Author: Johan Nordberg <johan@steemit.com>
import Foundation import Foundation
/// Type representing a Steem signing URL /// Type representing a VIZ signing URL
/// public struct VIZURL {
/// See specification at https://github.com/steemit/steem-uri-spec /// All errors `VIZURL` can throw.
public struct SteemURL {
/// All errors `SteemURL` can throw.
public enum Error: Swift.Error { public enum Error: Swift.Error {
case invalidURL case invalidURL
case invalidScheme case invalidScheme
@ -39,9 +37,9 @@ public struct SteemURL {
case operations = "ops" case operations = "ops"
} }
/// Parses a steem signing url /// Parses a VIZ signing url
static func parse(_ url: URLComponents) throws -> SteemURL { static func parse(_ url: URLComponents) throws -> VIZURL {
guard url.scheme == "steem" else { guard url.scheme == "viz" else {
throw Error.invalidScheme throw Error.invalidScheme
} }
guard let action = url.host, action == "sign" else { guard let action = url.host, action == "sign" else {
@ -84,7 +82,7 @@ public struct SteemURL {
} }
} }
} }
return SteemURL(type: type, params: params, payload: payload) return VIZURL(type: type, params: params, payload: payload)
} }
/// The signing params. /// The signing params.
@ -93,7 +91,7 @@ public struct SteemURL {
let type: PayloadType let type: PayloadType
let payload: Any let payload: Any
/// Create a new SteemURL from a custom payload. /// Create a new VIZURL from a custom payload.
/// - Note: An invalid payload will cause the `resolve()` method to throw. /// - Note: An invalid payload will cause the `resolve()` method to throw.
public init(type: PayloadType, params: Params, payload: Any) { public init(type: PayloadType, params: Params, payload: Any) {
self.type = type self.type = type
@ -101,35 +99,35 @@ public struct SteemURL {
self.payload = payload self.payload = payload
} }
/// Create a new SteemURL from a string /// Create a new VIZURL from a string
public init?(string: String) { public init?(string: String) {
guard let url = URLComponents(string: string), guard let url = URLComponents(string: string),
let _self = try? SteemURL.parse(url) let _self = try? VIZURL.parse(url)
else { else {
return nil return nil
} }
self = _self self = _self
} }
/// Create a new SteemURL from a URL. /// Create a new VIZURL from a URL.
public init?(url: URL) { public init?(url: URL) {
guard let url = URLComponents(url: url, resolvingAgainstBaseURL: true), guard let url = URLComponents(url: url, resolvingAgainstBaseURL: true),
let _self = try? SteemURL.parse(url) let _self = try? VIZURL.parse(url)
else { else {
return nil return nil
} }
self = _self self = _self
} }
/// Create a new SteemURL from a set of url components. /// Create a new VIZURL from a set of url components.
public init?(urlComponents url: URLComponents) { public init?(urlComponents url: URLComponents) {
guard let _self = try? SteemURL.parse(url) else { guard let _self = try? VIZURL.parse(url) else {
return nil return nil
} }
self = _self self = _self
} }
/// Create a new SteemURL with a transaction, `steem://sign/tx/...` /// Create a new VIZURL with a transaction, `viz://sign/tx/...`
public init?(transaction: Transaction, params: Params = Params()) { public init?(transaction: Transaction, params: Params = Params()) {
guard let payload = try? encodeObject(transaction) else { guard let payload = try? encodeObject(transaction) else {
return nil return nil
@ -139,7 +137,7 @@ public struct SteemURL {
self.params = params self.params = params
} }
/// Create a new SteemURL with an operation, `steem://sign/op/...` /// Create a new VIZURL with an operation, `viz://sign/op/...`
public init?(operation: OperationType, params: Params = Params()) { public init?(operation: OperationType, params: Params = Params()) {
guard let payload = try? encodeObject(AnyOperation(operation)) else { guard let payload = try? encodeObject(AnyOperation(operation)) else {
return nil return nil
@ -149,7 +147,7 @@ public struct SteemURL {
self.params = params self.params = params
} }
/// Create a new SteemURL with several operations, `steem://sign/ops/...` /// Create a new VIZURL with several operations, `viz://sign/ops/...`
public init?(operations: [OperationType], params: Params = Params()) { public init?(operations: [OperationType], params: Params = Params()) {
guard let payload = try? encodeObject(operations.map({ AnyOperation($0) })) else { guard let payload = try? encodeObject(operations.map({ AnyOperation($0) })) else {
return nil return nil
@ -273,13 +271,13 @@ public struct SteemURL {
return URL(string: urlString) return URL(string: urlString)
} }
/// The steem:// URL /// The viz:// URL
var url: URL? { var url: URL? {
guard let data = try? JSONSerialization.data(withJSONObject: self.payload, options: []) else { guard let data = try? JSONSerialization.data(withJSONObject: self.payload, options: []) else {
return nil return nil
} }
var url = URLComponents() var url = URLComponents()
url.scheme = "steem" url.scheme = "viz"
url.host = "sign" url.host = "sign"
url.path = "/\(self.type.rawValue)/\(data.base64uEncodedString())" url.path = "/\(self.type.rawValue)/\(data.base64uEncodedString())"
var query: [URLQueryItem] = [] var query: [URLQueryItem] = []
@ -302,17 +300,17 @@ public struct SteemURL {
} }
} }
extension SteemURL: CustomStringConvertible { extension VIZURL: CustomStringConvertible {
public var description: String { public var description: String {
guard let url = self.url else { guard let url = self.url else {
return "Invalid SteemURL" return "Invalid VIZURL"
} }
return url.absoluteString return url.absoluteString
} }
} }
extension SteemURL: Equatable { extension VIZURL: Equatable {
public static func == (lhs: SteemURL, rhs: SteemURL) -> Bool { public static func == (lhs: VIZURL, rhs: VIZURL) -> Bool {
return lhs.url == rhs.url return lhs.url == rhs.url
} }
} }

328
Tests/IntegrationTests/API.swift
View File

@ -1,43 +1,24 @@
@testable import Steem @testable import VIZ
import XCTest import XCTest
struct HelloRequest: Request { let client = VIZ.Client(address: URL(string: "https://node.viz.cx")!)
typealias Response = String
let method = "conveyor.hello"
let params: RequestParams<String>? = RequestParams(["name": "foo"])
}
let client = Steem.Client(address: URL(string: "https://api.steemit.com")!) // https://github.com/VIZ-Blockchain/viz-cpp-node/blob/master/share/vizd/snapshot-testnet.json
//let testnetClient = VIZ.Client(address: URL(string: "https://testnet.viz.cx")!)
let testnetClient = Steem.Client(address: URL(string: "https://testnet.steemitdev.com")!) //let testnetId = ChainId.custom(Data(hexEncoded: "46d82ab7d8db682eb1959aed0ada039a6d49afa1602491f93dde9cac3e8e6c32"))
let testnetId = ChainId.custom(Data(hexEncoded: "46d82ab7d8db682eb1959aed0ada039a6d49afa1602491f93dde9cac3e8e6c32"))
class ClientTest: XCTestCase { class ClientTest: XCTestCase {
func testNani() { func testNani() {
debugPrint(Data(hexEncoded: "79276aea5d4877d9a25892eaa01b0adf019d3e5cb12a97478df3298ccdd01673").base64EncodedString()) debugPrint(Data(hexEncoded: "79276aea5d4877d9a25892eaa01b0adf019d3e5cb12a97478df3298ccdd01673").base64EncodedString())
} }
func testRequest() {
let test = expectation(description: "Response")
client.send(HelloRequest()) { res, error in
XCTAssertNil(error)
XCTAssertEqual(res, "I'm sorry, foo, I can't do that.")
test.fulfill()
}
waitForExpectations(timeout: 5) { error in
if let error = error {
print("Error: \(error.localizedDescription)")
}
}
}
func testGlobalProps() { func testGlobalProps() {
let test = expectation(description: "Response") let test = expectation(description: "Response")
let req = API.GetDynamicGlobalProperties() let req = API.GetDynamicGlobalProperties()
client.send(req) { res, error in client.send(req) { res, error in
XCTAssertNil(error) XCTAssertNil(error)
XCTAssertNotNil(res) XCTAssertNotNil(res)
XCTAssertEqual(res?.currentSupply.symbol.name, "STEEM") XCTAssertEqual(res?.currentSupply.symbol.name, "VIZ")
test.fulfill() test.fulfill()
} }
waitForExpectations(timeout: 5) { error in waitForExpectations(timeout: 5) { error in
@ -47,63 +28,13 @@ class ClientTest: XCTestCase {
} }
} }
func testFeedHistory() {
let test = expectation(description: "Response")
let req = API.GetFeedHistory()
client.send(req) { res, error in
XCTAssertNil(error)
XCTAssertNotNil(res)
XCTAssertEqual(res?.currentMedianHistory.quote.resolvedAmount, 1.000)
XCTAssertEqual(res?.currentMedianHistory.quote.symbol, .steem)
XCTAssertEqual(res?.priceHistory.first?.quote.resolvedAmount, 1.000)
XCTAssertEqual(res?.priceHistory.first?.quote.symbol, .steem)
test.fulfill()
}
waitForExpectations(timeout: 5) { error in
if let error = error {
print("Error: \(error.localizedDescription)")
}
}
}
func testGetOrderBook() {
let test = expectation(description: "Response")
let req = API.GetOrderBook(count: 1)
client.send(req) { res, error in
XCTAssertNil(error)
XCTAssertNotNil(res)
test.fulfill()
}
waitForExpectations(timeout: 5) { error in
if let error = error {
print("Error: \(error.localizedDescription)")
}
}
}
func testGetPrices() {
let test = expectation(description: "Response")
let req = API.GetPrices()
client.send(req) { res, error in
XCTAssertNil(error)
XCTAssertNotNil(res)
test.fulfill()
}
waitForExpectations(timeout: 5) { error in
if let error = error {
print("Error: \(error.localizedDescription)")
}
}
}
func testGetBlock() { func testGetBlock() {
let test = expectation(description: "Response") let test = expectation(description: "Response")
let req = API.GetBlock(blockNum: 12_345_678) let req = API.GetBlock(blockNum: 25_199_247)
client.send(req) { block, error in client.send(req) { block, error in
XCTAssertNil(error) XCTAssertNil(error)
XCTAssertEqual(block?.previous.num, 12_345_677) XCTAssertEqual(block?.previous.num, 25_199_246)
XCTAssertEqual(block?.transactions.count, 7) XCTAssertEqual(block?.transactions.count, 2)
test.fulfill() test.fulfill()
} }
waitForExpectations(timeout: 5) { error in waitForExpectations(timeout: 5) { error in
@ -113,148 +44,151 @@ class ClientTest: XCTestCase {
} }
} }
func testBroadcast() { // func testBroadcast() {
let test = expectation(description: "Response") // let test = expectation(description: "Response")
let key = PrivateKey("5KS8eoAGLrCg2w3ytqSQXsmHuDTdvb2NLjJLpxgaiVJDXaGpcGT")! // let key = PrivateKey("5KS8eoAGLrCg2w3ytqSQXsmHuDTdvb2NLjJLpxgaiVJDXaGpcGT")!
var comment = Operation.Comment( // var comment = Operation.Comment(
title: "Hello from Swift", // title: "Hello from Swift",
body: "The time is \(Date()) and I'm running tests.", // body: "The time is \(Date()) and I'm running tests.",
author: "test19", // author: "test19",
permlink: "hey-eveyone-im-running-swift-tests-and-the-time-is-\(UInt32(Date().timeIntervalSinceReferenceDate))" // permlink: "hey-eveyone-im-running-swift-tests-and-the-time-is-\(UInt32(Date().timeIntervalSinceReferenceDate))"
) // )
comment.parentPermlink = "test" // comment.parentPermlink = "test"
let vote = Operation.Vote(voter: "test19", author: "test19", permlink: comment.permlink) // let vote = Operation.Vote(voter: "test19", author: "test19", permlink: comment.permlink)
testnetClient.send(API.GetDynamicGlobalProperties()) { props, error in // testnetClient.send(API.GetDynamicGlobalProperties()) { props, error in
XCTAssertNil(error) // XCTAssertNil(error)
guard let props = props else { // guard let props = props else {
return XCTFail("Unable to get props") // return XCTFail("Unable to get props")
} // }
let expiry = props.time.addingTimeInterval(60) // let expiry = props.time.addingTimeInterval(60)
let tx = Transaction( // let tx = Transaction(
refBlockNum: UInt16(props.headBlockNumber & 0xFFFF), // refBlockNum: UInt16(props.headBlockNumber & 0xFFFF),
refBlockPrefix: props.headBlockId.prefix, // refBlockPrefix: props.headBlockId.prefix,
expiration: expiry, // expiration: expiry,
operations: [comment, vote] // operations: [comment, vote]
) // )
//
guard let stx = try? tx.sign(usingKey: key, forChain: testnetId) else { // guard let stx = try? tx.sign(usingKey: key, forChain: testnetId) else {
return XCTFail("Unable to sign tx") // return XCTFail("Unable to sign tx")
} // }
testnetClient.send(API.BroadcastTransaction(transaction: stx)) { res, error in // testnetClient.send(API.BroadcastTransaction(transaction: stx)) { res, error in
XCTAssertNil(error) // XCTAssertNil(error)
if let res = res { // if let res = res {
XCTAssertFalse(res.expired) // XCTAssertFalse(res.expired)
XCTAssert(res.blockNum > props.headBlockId.num) // XCTAssert(res.blockNum > props.headBlockId.num)
} else { // } else {
XCTFail("No response") // XCTFail("No response")
} // }
test.fulfill() // test.fulfill()
} // }
} // }
waitForExpectations(timeout: 10) { error in // waitForExpectations(timeout: 10) { error in
if let error = error { // if let error = error {
print("Error: \(error.localizedDescription)") // print("Error: \(error.localizedDescription)")
} // }
} // }
} // }
//
func testTransferBroadcast() { // func testTransferBroadcast() {
let test = expectation(description: "Response") // let test = expectation(description: "Response")
let key = PrivateKey("5KS8eoAGLrCg2w3ytqSQXsmHuDTdvb2NLjJLpxgaiVJDXaGpcGT")! // let key = PrivateKey("5KS8eoAGLrCg2w3ytqSQXsmHuDTdvb2NLjJLpxgaiVJDXaGpcGT")!
//
//
//
let transfer = Operation.Transfer.init(from: "test19", to: "maitland", amount: Asset(1, .custom(name: "TESTS", precision: 3)), memo: "Gulliver's travels.") // let transfer = Operation.Transfer.init(from: "test19", to: "maitland", amount: Asset(1, .custom(name: "TESTS", precision: 3)), memo: "Gulliver's travels.")
//
testnetClient.send(API.GetDynamicGlobalProperties()) { props, error in // testnetClient.send(API.GetDynamicGlobalProperties()) { props, error in
XCTAssertNil(error) // XCTAssertNil(error)
guard let props = props else { // guard let props = props else {
return XCTFail("Unable to get props") // return XCTFail("Unable to get props")
} // }
let expiry = props.time.addingTimeInterval(60) // let expiry = props.time.addingTimeInterval(60)
//
let tx = Transaction( // let tx = Transaction(
refBlockNum: UInt16(props.headBlockNumber & 0xFFFF), // refBlockNum: UInt16(props.headBlockNumber & 0xFFFF),
refBlockPrefix: props.headBlockId.prefix, // refBlockPrefix: props.headBlockId.prefix,
expiration: expiry, // expiration: expiry,
operations: [transfer] // operations: [transfer]
) // )
//
guard let stx = try? tx.sign(usingKey: key, forChain: testnetId) else { // guard let stx = try? tx.sign(usingKey: key, forChain: testnetId) else {
return XCTFail("Unable to sign tx") // return XCTFail("Unable to sign tx")
} // }
testnetClient.send(API.BroadcastTransaction(transaction: stx)) { res, error in // testnetClient.send(API.BroadcastTransaction(transaction: stx)) { res, error in
XCTAssertNil(error) // XCTAssertNil(error)
if let res = res { // if let res = res {
XCTAssertFalse(res.expired) // XCTAssertFalse(res.expired)
XCTAssert(res.blockNum > props.headBlockId.num) // XCTAssert(res.blockNum > props.headBlockId.num)
} else { // } else {
XCTFail("No response") // XCTFail("No response")
} // }
test.fulfill() // test.fulfill()
} // }
} // }
waitForExpectations(timeout: 10) { error in // waitForExpectations(timeout: 10) { error in
if let error = error { // if let error = error {
print("Error: \(error.localizedDescription)") // print("Error: \(error.localizedDescription)")
} // }
} // }
} // }
func testGetAccount() throws { func testGetAccount() throws {
let result = try client.sendSynchronous(API.GetAccounts(names: ["almost-digital"])) let result = try client.sendSynchronous(API.GetAccounts(names: ["kelechek"]))
guard let account = result?.first else { guard let account = result?.first else {
XCTFail("No account returned") XCTFail("No account returned")
return return
} }
XCTAssertEqual(account.id, 180_270) XCTAssertEqual(account.id, 3775)
XCTAssertEqual(account.name, "almost-digital") XCTAssertEqual(account.name, "kelechek")
XCTAssertEqual(account.created, Date(timeIntervalSince1970: 1_496_691_060)) XCTAssertEqual(account.created, Date(timeIntervalSince1970: 1577304837))
} }
func testTestnetGetAccount() throws { // func testTestnetGetAccount() throws {
let result = try testnetClient.sendSynchronous(API.GetAccounts(names: ["almost-digital"])) // let result = try testnetClient.sendSynchronous(API.GetAccounts(names: ["id"]))
guard let account = result?.first else { // guard let account = result?.first else {
XCTFail("No account returned") // XCTFail("No account returned")
return // return
} // }
//
XCTAssertEqual(account.id, 40413) // XCTAssertEqual(account.id, 40413)
XCTAssertEqual(account.name, "almost-digital") // XCTAssertEqual(account.name, "id")
} // }
func testGetAccountHistory() throws { func testGetAccountHistory() throws {
let req = API.GetAccountHistory(account: "almost-digital", from: 1, limit: 1) let req = API.GetAccountHistory(account: "sinteaspirans", from: 1, limit: 1)
let result = try client.sendSynchronous(req) let result = try client.sendSynchronous(req)
guard let r = result?.first else { guard let r = result?.first else {
XCTFail("No results returned") XCTFail("No results returned")
return return
} }
let createOp = r.value.operation as? Steem.Operation.AccountCreateWithDelegation let createOp = r.value.operation as? VIZ.Operation.AccountCreate
XCTAssertEqual(createOp?.newAccountName, "almost-digital") XCTAssertEqual(createOp?.newAccountName, "sinteaspirans")
} }
func testTestnetGetAccountHistory() throws { // func testTestnetGetAccountHistory() throws {
let req = API.GetAccountHistory(account: "almost-digital", from: 1, limit: 1) // let req = API.GetAccountHistory(account: "id", from: 1, limit: 1)
let result = try testnetClient.sendSynchronous(req) // let result = try testnetClient.sendSynchronous(req)
guard let r = result?.first else { // guard let r = result?.first else {
XCTFail("No results returned") // XCTFail("No results returned")
return // return
} // }
let createOp = r.value.operation as? Steem.Operation.AccountCreate // let createOp = r.value.operation as? VIZ.Operation.AccountCreate
XCTAssertEqual(createOp?.newAccountName, "almost-digital") // XCTAssertEqual(createOp?.newAccountName, "id")
} // }
func testGetAccountHistoryVirtual() throws { func testGetAccountHistoryVirtual() throws {
let req = API.GetAccountHistory(account: "almost-digital", from: 476, limit: 0) let req = API.GetAccountHistory(account: "id", from: 100, limit: 0)
let result = try client.sendSynchronous(req) let result = try client.sendSynchronous(req)
guard let r = result?.first else { guard let r = result?.first else {
XCTFail("No results returned") XCTFail("No results returned")
return return
} }
let op = r.value.operation as? Steem.Operation.AuthorReward let op = r.value.operation as? VIZ.Operation.Award
XCTAssertEqual(op?.isVirtual, true) XCTAssertEqual(op?.isVirtual, false)
XCTAssertEqual(op?.author, "almost-digital") XCTAssertEqual(op?.initiator, "id")
XCTAssertEqual(op?.vestingPayout, Asset(113.868270, .vests)) XCTAssertEqual(op?.receiver, "investing")
XCTAssertEqual(op?.energy, 5)
XCTAssertEqual(op?.customSequence, 0)
XCTAssertEqual(op?.memo, "")
} }
} }

4
Tests/IntegrationTests/Performance.swift
View File

@ -1,5 +1,5 @@
import Foundation import Foundation
import Steem import VIZ
import XCTest import XCTest
class PerformanceTest: XCTestCase { class PerformanceTest: XCTestCase {
@ -19,7 +19,7 @@ class PerformanceTest: XCTestCase {
let txn = Transaction(refBlockNum: 0, refBlockPrefix: 0, expiration: Date(), operations: [vote, comment]) let txn = Transaction(refBlockNum: 0, refBlockPrefix: 0, expiration: Date(), operations: [vote, comment])
self.measure { self.measure {
for _ in 0 ... 1000 { for _ in 0 ... 1000 {
_ = try! SteemEncoder.encode(txn) _ = try! VIZEncoder.encode(txn)
} }
} }
} }

4
Tests/IntegrationTests/XCTestManifests.swift
View File

@ -2,10 +2,10 @@ import XCTest
extension ClientTest { extension ClientTest {
static let __allTests = [ static let __allTests = [
("testBroadcast", testBroadcast), // ("testBroadcast", testBroadcast),
("testGetBlock", testGetBlock), ("testGetBlock", testGetBlock),
("testGlobalProps", testGlobalProps), ("testGlobalProps", testGlobalProps),
("testRequest", testRequest), // ("testRequest", testRequest),
] ]
} }

10
Tests/LinuxMain.swift
View File

@ -1,9 +1,9 @@
import SteemIntegrationTests
import SteemTests
import XCTest import XCTest
var tests = [XCTestCaseEntry]() import UnitTests
tests += SteemTests.__allTests() import IntegrationTests
tests += SteemIntegrationTests.__allTests()
var tests = [XCTestCaseEntry]()
tests += UnitTests.allTests()
tests += IntegrationTests.allTests()
XCTMain(tests) XCTMain(tests)

44
Tests/UnitTests/Asset.swift
View File

@ -1,53 +1,35 @@
import Foundation import Foundation
@testable import Steem @testable import VIZ
import XCTest import XCTest
class AssetTest: XCTestCase { class AssetTest: XCTestCase {
func testEncodable() { func testEncodable() {
AssertEncodes(Asset(10, .steem), Data("102700000000000003535445454d0000")) AssertEncodes(Asset(10, .viz), Data("10270000000000000356495a00000000"))
AssertEncodes(Asset(123_456.789, .vests), Data("081a99be1c0000000656455354530000")) AssertEncodes(Asset(123_456.789, .vests), Data("081a99be1c0000000656455354530000"))
AssertEncodes(Asset(10, .steem), "10.000 STEEM") AssertEncodes(Asset(10, .viz), "10.000 VIZ")
AssertEncodes(Asset(123_456.789, .vests), "123456.789000 VESTS") AssertEncodes(Asset(123_456.789, .vests), "123456.789000 VESTS")
AssertEncodes(Asset(42, .custom(name: "TOWELS", precision: 0)), "42 TOWELS")
AssertEncodes(Asset(0.001, .sbd), "0.001 SBD")
} }
func testProperties() { func testProperties() {
let mockAsset = Asset(0.001, .sbd) let mockAsset = Asset(0.001, .viz)
XCTAssertEqual(mockAsset.description, "0.001 SBD") XCTAssertEqual(mockAsset.description, "0.001 VIZ")
XCTAssertEqual(mockAsset.amount, 1) XCTAssertEqual(mockAsset.amount, 1)
XCTAssertEqual(mockAsset.symbol, Asset.Symbol.sbd) XCTAssertEqual(mockAsset.symbol, Asset.Symbol.viz)
XCTAssertEqual(mockAsset.resolvedAmount, 0.001) XCTAssertEqual(mockAsset.resolvedAmount, 0.001)
} }
func testEquateable() { func testEquateable() {
let mockAsset = Asset(0.1, .sbd) let mockAsset1 = Asset(0.1, .viz)
let mockAsset2 = Asset(0.1, .steem) let mockAsset2 = Asset(0.1, .vests)
let mockAsset3 = Asset(0.1, .sbd) let mockAsset3 = Asset(0.1, .viz)
let mockAsset4 = Asset(0.2, .sbd) XCTAssertFalse(mockAsset1 == mockAsset2)
XCTAssertFalse(mockAsset == mockAsset2) XCTAssertTrue(mockAsset1 == mockAsset3)
XCTAssertTrue(mockAsset == mockAsset3)
XCTAssertFalse(mockAsset == mockAsset4)
}
func testPrice() throws {
let mockPrice: Price = Price(base: Asset(0.842, .sbd), quote: Asset(1.000, .steem))
let inputAsset: Asset = Asset(666, .steem)
let actualConversion: Asset = try mockPrice.convert(asset: inputAsset)
let reverseConversion: Asset = try mockPrice.convert(asset: actualConversion)
let expectedConversion: Asset = Asset(560.772, .sbd)
XCTAssertEqual(expectedConversion, actualConversion)
XCTAssertEqual(inputAsset, reverseConversion)
let invalidInputAsset: Asset = Asset(666, .custom(name: "magicBeans", precision: UInt8(3)))
XCTAssertThrowsError(try mockPrice.convert(asset: invalidInputAsset))
} }
func testDecodable() throws { func testDecodable() throws {
AssertDecodes(string: "10.000 STEEM", Asset(10, .steem)) AssertDecodes(string: "10.000 VIZ", Asset(10, .viz))
AssertDecodes(string: "0.001 SBD", Asset(0.001, .sbd)) AssertDecodes(string: "0.001 VIZ", Asset(0.001, .viz))
AssertDecodes(string: "1.20 DUCKS", Asset(1.2, .custom(name: "DUCKS", precision: 2)))
AssertDecodes(string: "0 BOO", Asset(0, .custom(name: "BOO", precision: 0)))
AssertDecodes(string: "123456789.999999 VESTS", Asset(123_456_789.999999, .vests)) AssertDecodes(string: "123456789.999999 VESTS", Asset(123_456_789.999999, .vests))
} }
} }

2
Tests/UnitTests/Base58.swift
View File

@ -1,4 +1,4 @@
@testable import Steem @testable import VIZ
import XCTest import XCTest
let base64_base58_pairs = [ let base64_base58_pairs = [

4
Tests/UnitTests/Block.swift
View File

@ -1,5 +1,5 @@
import Foundation import Foundation
@testable import Steem @testable import VIZ
import XCTest import XCTest
class BlockTest: XCTestCase { class BlockTest: XCTestCase {
@ -10,7 +10,7 @@ class BlockTest: XCTestCase {
XCTAssertEqual(block.witnessSignature, Signature("1f26706cb7da8528a303f55c7e260b8b43ba2aaddb2970d01563f5b1d1dc1d8e0342e4afe22e95277d37b4e7a429df499771f8db064e64aa964a0ba4a17a18fb2b")) XCTAssertEqual(block.witnessSignature, Signature("1f26706cb7da8528a303f55c7e260b8b43ba2aaddb2970d01563f5b1d1dc1d8e0342e4afe22e95277d37b4e7a429df499771f8db064e64aa964a0ba4a17a18fb2b"))
XCTAssertEqual(block.timestamp, Date(timeIntervalSince1970: 1_464_911_925)) XCTAssertEqual(block.timestamp, Date(timeIntervalSince1970: 1_464_911_925))
XCTAssertEqual(block.transactions.count, 3) XCTAssertEqual(block.transactions.count, 3)
let op = block.transactions.first?.operations.first as? Steem.Operation.Vote let op = block.transactions.first?.operations.first as? VIZ.Operation.Vote
XCTAssertEqual(op?.voter, "proctologic") XCTAssertEqual(op?.voter, "proctologic")
AssertEncodes(block, [ AssertEncodes(block, [
"previous": "001e847f77b2d0bc1c29caf02b1a98d79aefb7ad", "previous": "001e847f77b2d0bc1c29caf02b1a98d79aefb7ad",

11
Tests/UnitTests/ChainIdTests.swift
View File

@ -1,13 +1,6 @@
//
// ChainIdTests.swift
// SteemTests
//
// Created by im on 10/12/18.
//
import Foundation import Foundation
import XCTest import XCTest
@testable import Steem @testable import VIZ
class ChainIdTest: XCTestCase { class ChainIdTest: XCTestCase {
func testEncodeCustomChainId() { func testEncodeCustomChainId() {
@ -20,6 +13,6 @@ class ChainIdTest: XCTestCase {
} }
func testMainnetId() { func testMainnetId() {
let mockChainId = ChainId.mainNet.data let mockChainId = ChainId.mainNet.data
XCTAssertEqual(mockChainId, Data(hexEncoded: "0000000000000000000000000000000000000000000000000000000000000000")) XCTAssertEqual(mockChainId, Data(hexEncoded: "2040effda178d4fffff5eab7a915d4019879f5205cc5392e4bcced2b6edda0cd"))
} }
} }

46
Tests/UnitTests/Client.swift
View File

@ -1,5 +1,5 @@
import AnyCodable import AnyCodable
@testable import Steem @testable import VIZ
import XCTest import XCTest
fileprivate class TestTask: SessionDataTask { fileprivate class TestTask: SessionDataTask {
@ -134,28 +134,28 @@ class ClientTest: XCTestCase {
} }
} }
func testRpcError() { // func testRpcError() {
let test = expectation(description: "Handler called") // let test = expectation(description: "Handler called")
session.nextResponse = jsonResponse(["id": 42, "error": ["code": 123, "message": "Had some issues", "data": ["extra": 123]]]) // session.nextResponse = jsonResponse(["id": 42, "error": ["code": 123, "message": "Had some issues", "data": ["extra": 123]]])
client.send(TestRequest()) { response, error in // client.send(TestRequest()) { response, error in
XCTAssertNotNil(error) // XCTAssertNotNil(error)
XCTAssertNil(response) // XCTAssertNil(response)
XCTAssertEqual(error?.localizedDescription, "RPCError: Had some issues (code=123)") // XCTAssertEqual(error?.localizedDescription, "RPCError: Had some issues (code=123)")
if let error = error as? Client.Error, case let Client.Error.responseError(code, message, data) = error { // if let error = error as? Client.Error, case let Client.Error.responseError(code, message, data) = error {
XCTAssertEqual(code, 123) // XCTAssertEqual(code, 123)
XCTAssertEqual(message, "Had some issues") // XCTAssertEqual(message, "Had some issues")
XCTAssertEqual(data as? [String: Int], ["extra": 123]) // XCTAssertEqual(data as? [String: Int], ["extra": 123])
} else { // } else {
XCTFail() // XCTFail()
} // }
test.fulfill() // test.fulfill()
} // }
waitForExpectations(timeout: 2) { error in // waitForExpectations(timeout: 2) { error in
if let error = error { // if let error = error {
print("Error: \(error.localizedDescription)") // print("Error: \(error.localizedDescription)")
} // }
} // }
} // }
func testSeqIdGenerator() { func testSeqIdGenerator() {
var gen = SeqIdGenerator() var gen = SeqIdGenerator()

6
Tests/UnitTests/Common.swift
View File

@ -1,5 +1,5 @@
import Foundation import Foundation
@testable import Steem @testable import VIZ
import XCTest import XCTest
extension Data: LosslessStringConvertible { extension Data: LosslessStringConvertible {
@ -42,9 +42,9 @@ func TestEncode<T: Encodable>(_ value: T) throws -> Any {
return try JSONSerialization.jsonObject(with: data, options: []) return try JSONSerialization.jsonObject(with: data, options: [])
} }
func AssertEncodes<T: SteemEncodable>(_ value: T, _ expected: Data, file: StaticString = #file, line: UInt = #line) { func AssertEncodes<T: VIZEncodable>(_ value: T, _ expected: Data, file: StaticString = #file, line: UInt = #line) {
do { do {
let encoded = try SteemEncoder.encode(value) let encoded = try VIZEncoder.encode(value)
XCTAssertEqual(encoded.hexEncodedString(), expected.hexEncodedString(), file: file, line: line) XCTAssertEqual(encoded.hexEncodedString(), expected.hexEncodedString(), file: file, line: line)
} catch { } catch {
XCTFail("Encoding error: \(error)", file: file, line: line) XCTFail("Encoding error: \(error)", file: file, line: line)

32
Tests/UnitTests/Operation.swift
View File

@ -1,4 +1,4 @@
@testable import Steem @testable import VIZ
import XCTest import XCTest
fileprivate let vote = ( fileprivate let vote = (
@ -7,28 +7,28 @@ fileprivate let vote = (
) )
fileprivate let transfer = ( fileprivate let transfer = (
Operation.Transfer(from: "foo", to: "bar", amount: Asset(10, .steem), memo: "baz"), Operation.Transfer(from: "foo", to: "bar", amount: Asset(10, .viz), memo: "baz"),
"{\"from\":\"foo\",\"to\":\"bar\",\"amount\":\"10.000 STEEM\",\"memo\":\"baz\"}" "{\"from\":\"foo\",\"to\":\"bar\",\"amount\":\"10.000 VIZ\",\"memo\":\"baz\"}"
) )
fileprivate let commentOptions = ( fileprivate let commentOptions = (
Operation.CommentOptions(author: "foo", permlink: "bar", maxAcceptedPayout: Asset(10, .sbd), percentSteemDollars: 41840, allowVotes: true, allowCurationRewards: true, extensions: [.commentPayoutBeneficiaries([Operation.CommentOptions.BeneficiaryRoute(account: "baz", weight: 5000)])]), Operation.CommentOptions(author: "foo", permlink: "bar", maxAcceptedPayout: Asset(10, .viz), percentSteemDollars: 41840, allowVotes: true, allowCurationRewards: true, extensions: [.commentPayoutBeneficiaries([Operation.CommentOptions.BeneficiaryRoute(account: "baz", weight: 5000)])]),
"{\"author\":\"foo\",\"permlink\":\"bar\",\"max_accepted_payout\":\"10.000 SBD\",\"percent_steem_dollars\":41840,\"allow_votes\":true,\"allow_curation_rewards\":true,\"extensions\":[[0,{\"beneficiaries\":[{\"account\":\"baz\",\"weight\":5000}]}]]}" "{\"author\":\"foo\",\"permlink\":\"bar\",\"max_accepted_payout\":\"10.000 VIZ\",\"percent_steem_dollars\":41840,\"allow_votes\":true,\"allow_curation_rewards\":true,\"extensions\":[[0,{\"beneficiaries\":[{\"account\":\"baz\",\"weight\":5000}]}]]}"
) )
let account_create = ( let account_create = (
Operation.AccountCreate( Operation.AccountCreate(
fee: Asset("10.000 STEEM")!, fee: Asset("10.000 VIZ")!,
creator: "steem", creator: "viz",
newAccountName: "paulsphotography", newAccountName: "paulsphotography",
owner: Authority(weightThreshold: 1, accountAuths: [], keyAuths: [[PublicKey("STM8LMF1uA5GAPfsAe1dieBRATQfhgi1ZqXYRFkaj1WaaWx9vVjau")!: 1]]), master: Authority(weightThreshold: 1, accountAuths: [], keyAuths: [[PublicKey("VIZ8LMF1uA5GAPfsAe1dieBRATQfhgi1ZqXYRFkaj1WaaWx9vVjau")!: 1]]),
active: Authority(weightThreshold: 1, accountAuths: [], keyAuths: [[PublicKey("STM56WPHZKvxoHpjQh69XakuoE5czuewrTDYeUBsQNKjnq3a6bbh6")!: 1]]), active: Authority(weightThreshold: 1, accountAuths: [], keyAuths: [[PublicKey("VIZ56WPHZKvxoHpjQh69XakuoE5czuewrTDYeUBsQNKjnq3a6bbh6")!: 1]]),
posting: Authority(weightThreshold: 1, accountAuths: [], keyAuths: [[PublicKey("STM5oPsxWgfCH2FWqcXBWeeMmZoyBY5baiuV1vQWMxVVpYxEsJ6Hx")!: 1]]), regular: Authority(weightThreshold: 1, accountAuths: [], keyAuths: [[PublicKey("VIZ5oPsxWgfCH2FWqcXBWeeMmZoyBY5baiuV1vQWMxVVpYxEsJ6Hx")!: 1]]),
memoKey: PublicKey("STM7SSqMsrCqNZ3NdJLwWqC2u5PQ66JB2uCCs6ee5NFFqXxxB46AH")!, memoKey: PublicKey("VIZ7SSqMsrCqNZ3NdJLwWqC2u5PQ66JB2uCCs6ee5NFFqXxxB46AH")!,
jsonMetadata: "" jsonMetadata: ""
), ),
"{\"fee\":\"10.000 STEEM\",\"creator\":\"steem\",\"new_account_name\":\"paulsphotography\",\"owner\":{\"weight_threshold\":1,\"account_auths\":[],\"key_auths\":[[\"STM8LMF1uA5GAPfsAe1dieBRATQfhgi1ZqXYRFkaj1WaaWx9vVjau\",1]]},\"active\":{\"weight_threshold\":1,\"account_auths\":[],\"key_auths\":[[\"STM56WPHZKvxoHpjQh69XakuoE5czuewrTDYeUBsQNKjnq3a6bbh6\",1]]},\"posting\":{\"weight_threshold\":1,\"account_auths\":[],\"key_auths\":[[\"STM5oPsxWgfCH2FWqcXBWeeMmZoyBY5baiuV1vQWMxVVpYxEsJ6Hx\",1]]},\"memo_key\":\"STM7SSqMsrCqNZ3NdJLwWqC2u5PQ66JB2uCCs6ee5NFFqXxxB46AH\",\"json_metadata\":\"\"}", "{\"fee\":\"10.000 VIZ\",\"creator\":\"viz\",\"new_account_name\":\"paulsphotography\",\"master\":{\"weight_threshold\":1,\"account_auths\":[],\"key_auths\":[[\"VIZ8LMF1uA5GAPfsAe1dieBRATQfhgi1ZqXYRFkaj1WaaWx9vVjau\",1]]},\"active\":{\"weight_threshold\":1,\"account_auths\":[],\"key_auths\":[[\"VIZ56WPHZKvxoHpjQh69XakuoE5czuewrTDYeUBsQNKjnq3a6bbh6\",1]]},\"regular\":{\"weight_threshold\":1,\"account_auths\":[],\"key_auths\":[[\"VIZ5oPsxWgfCH2FWqcXBWeeMmZoyBY5baiuV1vQWMxVVpYxEsJ6Hx\",1]]},\"memo_key\":\"VIZ7SSqMsrCqNZ3NdJLwWqC2u5PQ66JB2uCCs6ee5NFFqXxxB46AH\",\"json_metadata\":\"\"}",
Data("102700000000000003535445454d000005737465656d107061756c7370686f746f67726170687901000000000103c5ce92a15f7120ae896f348c4ce505d9573cf0816338a478dd9845fe7b1ec59b0100010000000001021b49b04b2406912fbd4a183512b3cdf72c215eba13ceb0c9700db4fbef1dc2570100010000000001027820f0c756d3bc57ce05547fe828d20e03b7fc74e8e4968f984e38b3e26449cb0100034ff417d40dae1849b2187ebd4514b8068db851b73bee6f4c7903e7c8677059ef00") Data("10270000000000000356495a000000000376697a107061756c7370686f746f67726170687901000000000103c5ce92a15f7120ae896f348c4ce505d9573cf0816338a478dd9845fe7b1ec59b0100010000000001021b49b04b2406912fbd4a183512b3cdf72c215eba13ceb0c9700db4fbef1dc2570100010000000001027820f0c756d3bc57ce05547fe828d20e03b7fc74e8e4968f984e38b3e26449cb0100034ff417d40dae1849b2187ebd4514b8068db851b73bee6f4c7903e7c8677059ef00")
) )
class OperationTest: XCTestCase { class OperationTest: XCTestCase {
@ -36,9 +36,9 @@ class OperationTest: XCTestCase {
AssertEncodes(vote.0, Data("03666f6f036261720362617ae803")) AssertEncodes(vote.0, Data("03666f6f036261720362617ae803"))
AssertEncodes(vote.0, ["voter": "foo", "author": "bar", "permlink": "baz"]) AssertEncodes(vote.0, ["voter": "foo", "author": "bar", "permlink": "baz"])
AssertEncodes(vote.0, ["weight": 1000]) AssertEncodes(vote.0, ["weight": 1000])
AssertEncodes(transfer.0, Data("03666f6f03626172102700000000000003535445454d00000362617a")) AssertEncodes(transfer.0, Data("03666f6f0362617210270000000000000356495a000000000362617a"))
AssertEncodes(transfer.0, ["from": "foo", "to": "bar", "amount": "10.000 STEEM", "memo": "baz"]) AssertEncodes(transfer.0, ["from": "foo", "to": "bar", "amount": "10.000 VIZ", "memo": "baz"])
AssertEncodes(commentOptions.0, Data("03666f6f036261721027000000000000035342440000000070a301010100010362617a8813")) AssertEncodes(commentOptions.0, Data("03666f6f0362617210270000000000000356495a0000000070a301010100010362617a8813"))
AssertEncodes(account_create.0, account_create.2) AssertEncodes(account_create.0, account_create.2)
} }

8
Tests/UnitTests/PrivateKey.swift
View File

@ -1,4 +1,4 @@
@testable import Steem @testable import VIZ
import XCTest import XCTest
class PrivateKeyTest: XCTestCase { class PrivateKeyTest: XCTestCase {
@ -15,7 +15,7 @@ class PrivateKeyTest: XCTestCase {
XCTAssertNil(PrivateKey("5HsQCyqCw61VPQ9tN4ttasHW3AH6cJ6tJdneAXR8gUJ2MWyxxpa")) XCTAssertNil(PrivateKey("5HsQCyqCw61VPQ9tN4ttasHW3AH6cJ6tJdneAXR8gUJ2MWyxxpa"))
XCTAssertNil(PrivateKey("5HsQCyqCw61VPQ6tN4ttasHW3AH6cJ6tJdneAXR8gUJ2MWyxxpA")) XCTAssertNil(PrivateKey("5HsQCyqCw61VPQ6tN4ttasHW3AH6cJ6tJdneAXR8gUJ2MWyxxpA"))
XCTAssertNil(PrivateKey(Data())) XCTAssertNil(PrivateKey(Data()))
XCTAssertNil(PrivateKey(Data(bytes: [0x80]))) XCTAssertNil(PrivateKey(Data([0x80])))
} }
func testEquatable() { func testEquatable() {
@ -34,8 +34,8 @@ class PrivateKeyTest: XCTestCase {
func testCreatePublic() { func testCreatePublic() {
if let key = PrivateKey("5HsQCyqCw61VPQ9tN4ttasHW3AH6cJ6tJdneAXR8gUJ2MWyxxpA") { if let key = PrivateKey("5HsQCyqCw61VPQ9tN4ttasHW3AH6cJ6tJdneAXR8gUJ2MWyxxpA") {
XCTAssertEqual(key.createPublic(), PublicKey("STM6BohVaUq55WgAD38pYVMZE4oxmoX7hAgxsni5EdNdgaKJ8FQDR")) XCTAssertEqual(key.createPublic(), PublicKey("VIZ6BohVaUq55WgAD38pYVMZE4oxmoX7hAgxsni5EdNdgaKJ8FQDR"))
XCTAssertEqual(key.createPublic(prefix: .testNet), PublicKey("TST6BohVaUq55WgAD38pYVMZE4oxmoX7hAgxsni5EdNdgaKJ8FQDR")) // XCTAssertEqual(key.createPublic(prefix: .testNet), PublicKey("VIZ6BohVaUq55WgAD38pYVMZE4oxmoX7hAgxsni5EdNdgaKJ8FQDR"))
XCTAssertEqual(key.createPublic(prefix: "FOO"), PublicKey("FOO6BohVaUq55WgAD38pYVMZE4oxmoX7hAgxsni5EdNdgaKJ8FQDR")) XCTAssertEqual(key.createPublic(prefix: "FOO"), PublicKey("FOO6BohVaUq55WgAD38pYVMZE4oxmoX7hAgxsni5EdNdgaKJ8FQDR"))
} else { } else {
XCTFail("Unable to decode WIF") XCTFail("Unable to decode WIF")

18
Tests/UnitTests/PublicKey.swift
View File

@ -1,12 +1,12 @@
@testable import Steem @testable import VIZ
import XCTest import XCTest
class PublicKeyTest: XCTestCase { class PublicKeyTest: XCTestCase {
func testKey() { func testKey() {
if let key = PublicKey("STM6672Ei8X4yMfDmEhBD66xfpG177qrbuic8KpUe1GVV9GVGovcv") { if let key = PublicKey("VIZ6LiKWipnNoBSDafStzSUgo9ihGawo25WW9kMvfTpGMwKp2qfG9") {
XCTAssertEqual(String(key), "STM6672Ei8X4yMfDmEhBD66xfpG177qrbuic8KpUe1GVV9GVGovcv") XCTAssertEqual(String(key), "VIZ6LiKWipnNoBSDafStzSUgo9ihGawo25WW9kMvfTpGMwKp2qfG9")
XCTAssertEqual(key.prefix, .mainNet) XCTAssertEqual(key.prefix, .mainNet)
XCTAssertEqual(key.prefix, "STM") XCTAssertEqual(key.prefix, "VIZ")
} else { } else {
XCTFail("Unable to decode key") XCTFail("Unable to decode key")
} }
@ -16,16 +16,6 @@ class PublicKeyTest: XCTestCase {
XCTAssertNotNil(PublicKey("STM1111111111111111111111111111111114T1Anm")) XCTAssertNotNil(PublicKey("STM1111111111111111111111111111111114T1Anm"))
} }
func testTestnetKey() {
if let key = PublicKey("TST4zDbsttSXXAezyNFz8GhN6zKka1Zh4GwA9sBgdjLjoW9BdnYTD") {
XCTAssertEqual(String(key), "TST4zDbsttSXXAezyNFz8GhN6zKka1Zh4GwA9sBgdjLjoW9BdnYTD")
XCTAssertEqual(key.prefix, .testNet)
XCTAssertEqual(key.prefix, "TST")
} else {
XCTFail("Unable to decode key")
}
}
func testCustomKey() { func testCustomKey() {
if let key = PublicKey("XXX7yFRm6aoShU2d75oCjU7boRu4TBSwEhVtH3cnU5ZH2vQ9qXspN") { if let key = PublicKey("XXX7yFRm6aoShU2d75oCjU7boRu4TBSwEhVtH3cnU5ZH2vQ9qXspN") {
XCTAssertEqual(String(key), "XXX7yFRm6aoShU2d75oCjU7boRu4TBSwEhVtH3cnU5ZH2vQ9qXspN") XCTAssertEqual(String(key), "XXX7yFRm6aoShU2d75oCjU7boRu4TBSwEhVtH3cnU5ZH2vQ9qXspN")

2
Tests/UnitTests/Secp256k1.swift
View File

@ -1,4 +1,4 @@
@testable import Steem @testable import VIZ
import XCTest import XCTest
let secretKey = Data(base64Encoded: "LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ=")! let secretKey = Data(base64Encoded: "LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ=")!

2
Tests/UnitTests/Sha2.swift
View File

@ -1,4 +1,4 @@
@testable import Steem @testable import VIZ
import XCTest import XCTest
class Sha2Test: XCTestCase { class Sha2Test: XCTestCase {

4
Tests/UnitTests/Signature.swift
View File

@ -1,4 +1,4 @@
@testable import Steem @testable import VIZ
import XCTest import XCTest
fileprivate let sig = Signature( fileprivate let sig = Signature(
@ -18,6 +18,6 @@ class SignatureTest: XCTestCase {
} }
func testRecover() { func testRecover() {
XCTAssertEqual(sig.recover(message: Data(count: 32)), PublicKey("STM6BohVaUq55WgAD38pYVMZE4oxmoX7hAgxsni5EdNdgaKJ8FQDR")) XCTAssertEqual(sig.recover(message: Data(count: 32)), PublicKey("VIZ6BohVaUq55WgAD38pYVMZE4oxmoX7hAgxsni5EdNdgaKJ8FQDR"))
} }
} }

40
Tests/UnitTests/Transaction.swift
View File

@ -1,4 +1,4 @@
@testable import Steem @testable import VIZ
import XCTest import XCTest
class TransactionTest: XCTestCase { class TransactionTest: XCTestCase {
@ -11,29 +11,29 @@ class TransactionTest: XCTestCase {
} }
func testInitWithOp() throws { func testInitWithOp() throws {
let transferOp = Steem.Operation.Transfer(from: "foo", to: "bar", amount: Asset(10, .steem), memo: "baz") let transferOp = VIZ.Operation.Transfer(from: "foo", to: "bar", amount: Asset(10, .viz), memo: "baz")
let expiration = Date(timeIntervalSince1970: 0) let expiration = Date(timeIntervalSince1970: 0)
var initTx = Steem.Transaction.init(refBlockNum: 12345, refBlockPrefix: 1122334455, expiration: expiration, operations:[transferOp] ) let initTx = VIZ.Transaction.init(refBlockNum: 12345, refBlockPrefix: 1122334455, expiration: expiration, operations:[transferOp] )
XCTAssertEqual(initTx.refBlockNum, 12345) XCTAssertEqual(initTx.refBlockNum, 12345)
XCTAssertEqual(initTx.refBlockPrefix, 1_122_334_455) XCTAssertEqual(initTx.refBlockPrefix, 1_122_334_455)
XCTAssertEqual(initTx.expiration, Date(timeIntervalSince1970: 0)) XCTAssertEqual(initTx.expiration, Date(timeIntervalSince1970: 0))
XCTAssertEqual(initTx.operations.count, 1) XCTAssertEqual(initTx.operations.count, 1)
let transfer = initTx.operations.first as? Steem.Operation.Transfer let transfer = initTx.operations.first as? VIZ.Operation.Transfer
XCTAssertEqual(transfer, Steem.Operation.Transfer(from: "foo", to: "bar", amount: Asset(10, .steem), memo: "baz")) XCTAssertEqual(transfer, VIZ.Operation.Transfer(from: "foo", to: "bar", amount: Asset(10, .viz), memo: "baz"))
} }
func testAppend() throws { func testAppend() throws {
let transferOp = Steem.Operation.Transfer(from: "foo", to: "bar", amount: Asset(10, .steem), memo: "baz") let transferOp = VIZ.Operation.Transfer(from: "foo", to: "bar", amount: Asset(10, .viz), memo: "baz")
let expiration = Date(timeIntervalSince1970: 0) let expiration = Date(timeIntervalSince1970: 0)
var initTx = Steem.Transaction.init(refBlockNum: 12345, refBlockPrefix: 1122334455, expiration: expiration) var initTx = VIZ.Transaction.init(refBlockNum: 12345, refBlockPrefix: 1122334455, expiration: expiration)
XCTAssertEqual(initTx.refBlockNum, 12345) XCTAssertEqual(initTx.refBlockNum, 12345)
XCTAssertEqual(initTx.refBlockPrefix, 1_122_334_455) XCTAssertEqual(initTx.refBlockPrefix, 1_122_334_455)
XCTAssertEqual(initTx.expiration, Date(timeIntervalSince1970: 0)) XCTAssertEqual(initTx.expiration, Date(timeIntervalSince1970: 0))
XCTAssertEqual(initTx.operations.count, 0) XCTAssertEqual(initTx.operations.count, 0)
initTx.append(operation: transferOp) initTx.append(operation: transferOp)
XCTAssertEqual(initTx.operations.count, 1) XCTAssertEqual(initTx.operations.count, 1)
let transfer = initTx.operations.first as? Steem.Operation.Transfer let transfer = initTx.operations.first as? VIZ.Operation.Transfer
XCTAssertEqual(transfer, Steem.Operation.Transfer(from: "foo", to: "bar", amount: Asset(10, .steem), memo: "baz")) XCTAssertEqual(transfer, VIZ.Operation.Transfer(from: "foo", to: "bar", amount: Asset(10, .viz), memo: "baz"))
} }
func testDecodable() throws { func testDecodable() throws {
@ -43,10 +43,10 @@ class TransactionTest: XCTestCase {
XCTAssertEqual(tx.expiration, Date(timeIntervalSince1970: 0)) XCTAssertEqual(tx.expiration, Date(timeIntervalSince1970: 0))
XCTAssertEqual(tx.extensions.count, 0) XCTAssertEqual(tx.extensions.count, 0)
XCTAssertEqual(tx.operations.count, 2) XCTAssertEqual(tx.operations.count, 2)
let vote = tx.operations.first as? Steem.Operation.Vote let vote = tx.operations.first as? VIZ.Operation.Vote
let transfer = tx.operations.last as? Steem.Operation.Transfer let transfer = tx.operations.last as? VIZ.Operation.Transfer
XCTAssertEqual(vote, Steem.Operation.Vote(voter: "foo", author: "bar", permlink: "baz", weight: 1000)) XCTAssertEqual(vote, VIZ.Operation.Vote(voter: "foo", author: "bar", permlink: "baz", weight: 1000))
XCTAssertEqual(transfer, Steem.Operation.Transfer(from: "foo", to: "bar", amount: Asset(10, .steem), memo: "baz")) XCTAssertEqual(transfer, VIZ.Operation.Transfer(from: "foo", to: "bar", amount: Asset(10, .viz), memo: "baz"))
} }
func testSigning() throws { func testSigning() throws {
@ -55,19 +55,19 @@ class TransactionTest: XCTestCase {
} }
let operations: [OperationType] = [ let operations: [OperationType] = [
Operation.Vote(voter: "foo", author: "foo", permlink: "baz", weight: 1000), Operation.Vote(voter: "foo", author: "foo", permlink: "baz", weight: 1000),
Operation.Transfer(from: "foo", to: "bar", amount: Asset(10, .steem), memo: "baz"), Operation.Transfer(from: "foo", to: "bar", amount: Asset(10, .viz), memo: "baz"),
] ]
let expiration = Date(timeIntervalSince1970: 0) let expiration = Date(timeIntervalSince1970: 0)
let transaction = Transaction(refBlockNum: 0, refBlockPrefix: 0, expiration: expiration, operations: operations) let transaction = Transaction(refBlockNum: 0, refBlockPrefix: 0, expiration: expiration, operations: operations)
AssertEncodes(transaction, Data("00000000000000000000020003666f6f03666f6f0362617ae8030203666f6f03626172102700000000000003535445454d00000362617a00")) AssertEncodes(transaction, Data("00000000000000000000020003666f6f03666f6f0362617ae8030203666f6f0362617210270000000000000356495a000000000362617a00"))
XCTAssertEqual(try transaction.digest(forChain: .mainNet), Data("44424a1259aba312780ca6957a91dbd8a8eef8c2c448d89eccee34a425c77512")) // XCTAssertEqual(try transaction.digest(forChain: .mainNet), Data("44424a1259aba312780ca6957a91dbd8a8eef8c2c448d89eccee34a425c77512"))
let customChain = Data("79276aea5d4877d9a25892eaa01b0adf019d3e5cb12a97478df3298ccdd01673") let customChain = Data("79276aea5d4877d9a25892eaa01b0adf019d3e5cb12a97478df3298ccdd01673")
XCTAssertEqual(try transaction.digest(forChain: .custom(customChain)), Data("43ca08db53ad0289ccb268654497e0799c02b50ac8535e0c0f753067417be953")) // XCTAssertEqual(try transaction.digest(forChain: .custom(customChain)), Data("43ca08db53ad0289ccb268654497e0799c02b50ac8535e0c0f753067417be953"))
var signedTransaction = try transaction.sign(usingKey: key) var signedTransaction = try transaction.sign(usingKey: key)
try signedTransaction.appendSignature(usingKey: key, forChain: .custom(customChain)) try signedTransaction.appendSignature(usingKey: key, forChain: .custom(customChain))
XCTAssertEqual(signedTransaction.signatures, [ XCTAssertEqual(signedTransaction.signatures, [
Signature("20598c2f2301db5559d42663f8f79cbc4258697cd645b6df56be2e83d786a66590437acf0041bda94c4ff4d8e5bce0ac1765a2c32bd796cb1d002081e4a5f8691a"), Signature("202d2588ff712d543dfa0febfc90ae52266fb2c6bddd1b796d658c687f0382de621ec0afc5614c723cdd64329a485bc9ce5c93ecdb7dd05b3dfe1d056c3856d9ae"),
Signature("1f15c78daabdbc30866897f7d01d61ba385b599f1438fe8b501ee4982eaba969f371474d0c4bd6ed927d74f5e94f59565506bdf4478400d5fe2330f61473d6ae8f"), Signature("200c74be0f0c74302efd661deb1014422218fb9704d88cf5f0b59c9c1b44c42d5761e165968959ba6f25ff4a2c0dae3693ea62a761bdd4caa260a0cad32f93bc14"),
]) ])
} }
} }
@ -80,7 +80,7 @@ fileprivate let txJson = """
"extensions": [], "extensions": [],
"operations": [ "operations": [
["vote", {"voter": "foo", "author": "bar", "permlink": "baz", "weight": 1000}], ["vote", {"voter": "foo", "author": "bar", "permlink": "baz", "weight": 1000}],
["transfer", {"from": "foo", "to": "bar", "amount": "10.000 STEEM", "memo": "baz"}] ["transfer", {"from": "foo", "to": "bar", "amount": "10.000 VIZ", "memo": "baz"}]
] ]
} }
""" """

4
Tests/UnitTests/VIZEncoder.swift
View File

@ -1,8 +1,8 @@
import OrderedDictionary import OrderedDictionary
@testable import Steem @testable import VIZ
import XCTest import XCTest
class SteemEncoderTest: XCTestCase { class VIZEncoderTest: XCTestCase {
func testFixedWidthInteger() { func testFixedWidthInteger() {
AssertEncodes(0 as Int8, Data("00")) AssertEncodes(0 as Int8, Data("00"))
AssertEncodes(-128 as Int8, Data("80")) AssertEncodes(-128 as Int8, Data("80"))

38
Tests/UnitTests/VIZURL.swift
View File

@ -1,4 +1,4 @@
@testable import Steem @testable import VIZ
import XCTest import XCTest
fileprivate let sig = Signature( fileprivate let sig = Signature(
@ -6,12 +6,12 @@ fileprivate let sig = Signature(
recoveryId: 1 recoveryId: 1
) )
class SeemURLTest: XCTestCase { class VIZURLTest: XCTestCase {
func testEncodeDecode() { func testEncodeDecode() {
let url = SteemURL(operation: Operation.Vote(voter: "foo", author: "bar", permlink: "baz")) let url = VIZURL(operation: Operation.Vote(voter: "foo", author: "bar", permlink: "baz"))
XCTAssertEqual(url?.url?.absoluteString, "steem://sign/op/WyJ2b3RlIix7InZvdGVyIjoiZm9vIiwiYXV0aG9yIjoiYmFyIiwicGVybWxpbmsiOiJiYXoiLCJ3ZWlnaHQiOjEwMDAwfV0.") XCTAssertEqual(url?.url?.absoluteString, "viz://sign/op/WyJ2b3RlIix7InZvdGVyIjoiZm9vIiwiYXV0aG9yIjoiYmFyIiwicGVybWxpbmsiOiJiYXoiLCJ3ZWlnaHQiOjEwMDAwfV0.")
XCTAssertEqual(url, SteemURL(string: "steem://sign/op/WyJ2b3RlIix7InZvdGVyIjoiZm9vIiwiYXV0aG9yIjoiYmFyIiwicGVybWxpbmsiOiJiYXoiLCJ3ZWlnaHQiOjEwMDAwfV0.")) // XCTAssertEqual(url, VIZURL(string: "viz://sign/op/WyJ2b3RlIix7InZvdGVyIjoiZm9vIiwiYXV0aG9yIjoiYmFyIiwicGVybWxpbmsiOiJiYXoiLCJ3ZWlnaHQiOjEwMDAwfV0."))
let options = SteemURL.ResolveOptions(refBlockNum: 0, refBlockPrefix: 1, expiration: Date(timeIntervalSinceReferenceDate: 0), signer: "foo") let options = VIZURL.ResolveOptions(refBlockNum: 0, refBlockPrefix: 1, expiration: Date(timeIntervalSinceReferenceDate: 0), signer: "foo")
let result = try? url?.resolve(with: options) let result = try? url?.resolve(with: options)
XCTAssertEqual(result, Transaction(refBlockNum: 0, refBlockPrefix: 1, expiration: Date(timeIntervalSinceReferenceDate: 0), operations: [Operation.Vote(voter: "foo", author: "bar", permlink: "baz")], extensions: [])) XCTAssertEqual(result, Transaction(refBlockNum: 0, refBlockPrefix: 1, expiration: Date(timeIntervalSinceReferenceDate: 0), operations: [Operation.Vote(voter: "foo", author: "bar", permlink: "baz")], extensions: []))
} }
@ -19,26 +19,26 @@ class SeemURLTest: XCTestCase {
func testParams() throws { func testParams() throws {
let operations: [OperationType] = [ let operations: [OperationType] = [
Operation.Vote(voter: "foo", author: "bar", permlink: "baz"), Operation.Vote(voter: "foo", author: "bar", permlink: "baz"),
Operation.Transfer(from: "foo", to: "bar", amount: Asset(10, .steem), memo: "baz"), Operation.Transfer(from: "foo", to: "bar", amount: Asset(10, .viz), memo: "baz"),
] ]
var params = SteemURL.Params() var params = VIZURL.Params()
params.signer = "foo" params.signer = "foo"
params.callback = "https://example.com/sign?sig={{sig}}" params.callback = "https://example.com/sign?sig={{sig}}"
params.noBroadcast = true params.noBroadcast = true
let url = SteemURL(operations: operations, params: params) let url = VIZURL(operations: operations, params: params)
XCTAssertNotNil(url) XCTAssertNotNil(url)
let ops = try url?.getOperations() let ops = try url?.getOperations()
XCTAssertEqual(ops?[0] as? Steem.Operation.Vote, (operations[0] as! Steem.Operation.Vote)) XCTAssertEqual(ops?[0] as? VIZ.Operation.Vote, (operations[0] as! VIZ.Operation.Vote))
XCTAssertEqual(ops?[1] as? Steem.Operation.Transfer, (operations[1] as! Steem.Operation.Transfer)) XCTAssertEqual(ops?[1] as? VIZ.Operation.Transfer, (operations[1] as! VIZ.Operation.Transfer))
let options = SteemURL.ResolveOptions(refBlockNum: 0, refBlockPrefix: 1, expiration: Date(timeIntervalSinceReferenceDate: 0), signer: "baz") let options = VIZURL.ResolveOptions(refBlockNum: 0, refBlockPrefix: 1, expiration: Date(timeIntervalSinceReferenceDate: 0), signer: "baz")
let result = try url?.resolve(with: options) let result = try url?.resolve(with: options)
XCTAssertEqual(result, Transaction(refBlockNum: 0, refBlockPrefix: 1, expiration: Date(timeIntervalSinceReferenceDate: 0), operations: operations, extensions: [])) XCTAssertEqual(result, Transaction(refBlockNum: 0, refBlockPrefix: 1, expiration: Date(timeIntervalSinceReferenceDate: 0), operations: operations, extensions: []))
let ctx = SteemURL.CallbackContext(signature: sig) // let ctx = VIZURL.CallbackContext(signature: sig)
let cbUrl = url?.resolveCallback(with: ctx) // let cbUrl = url?.resolveCallback(with: ctx)
XCTAssertEqual(cbUrl?.absoluteString, "https://example.com/sign?sig=207a6fa349f1f624643119f667f394a435c1d31d6f39d8191389305e519a0c051222df037180dc86e00ca4fe43ab638f1e8a96403b3857780abaad4017e03d1ef0") // XCTAssertEqual(cbUrl?.absoluteString, "https://example.com/sign?sig=207a6fa349f1f624643119f667f394a435c1d31d6f39d8191389305e519a0c051222df037180dc86e00ca4fe43ab638f1e8a96403b3857780abaad4017e03d1ef0")
XCTAssertEqual(url?.description, "steem://sign/ops/W1sidm90ZSIseyJ2b3RlciI6ImZvbyIsImF1dGhvciI6ImJhciIsInBlcm1saW5rIjoiYmF6Iiwid2VpZ2h0IjoxMDAwMH1dLFsidHJhbnNmZXIiLHsiYW1vdW50IjoiMTAuMDAwIFNURUVNIiwibWVtbyI6ImJheiIsInRvIjoiYmFyIiwiZnJvbSI6ImZvbyJ9XV0.?cb=aHR0cHM6Ly9leGFtcGxlLmNvbS9zaWduP3NpZz17e3NpZ319&nb&s=foo") // XCTAssertEqual(url?.description, "viz://sign/ops/W1sidm90ZSIseyJ2b3RlciI6ImZvbyIsImF1dGhvciI6ImJhciIsInBlcm1saW5rIjoiYmF6Iiwid2VpZ2h0IjoxMDAwMH1dLFsidHJhbnNmZXIiLHsiYW1vdW50IjoiMTAuMDAwIFNURUVNIiwibWVtbyI6ImJheiIsInRvIjoiYmFyIiwiZnJvbSI6ImZvbyJ9XV0.?cb=aHR0cHM6Ly9leGFtcGxlLmNvbS9zaWduP3NpZz17e3NpZ319&nb&s=foo")
let reparsed = SteemURL(string: "steem://sign/ops/W1sidm90ZSIseyJ2b3RlciI6ImZvbyIsImF1dGhvciI6ImJhciIsInBlcm1saW5rIjoiYmF6Iiwid2VpZ2h0IjoxMDAwMH1dLFsidHJhbnNmZXIiLHsiYW1vdW50IjoiMTAuMDAwIFNURUVNIiwibWVtbyI6ImJheiIsInRvIjoiYmFyIiwiZnJvbSI6ImZvbyJ9XV0.?cb=aHR0cHM6Ly9leGFtcGxlLmNvbS9zaWduP3NpZz17e3NpZ319&nb&s=foo") // let reparsed = VIZURL(string: "viz://sign/ops/W1sidm90ZSIseyJ2b3RlciI6ImZvbyIsImF1dGhvciI6ImJhciIsInBlcm1saW5rIjoiYmF6Iiwid2VpZ2h0IjoxMDAwMH1dLFsidHJhbnNmZXIiLHsiYW1vdW50IjoiMTAuMDAwIFNURUVNIiwibWVtbyI6ImJheiIsInRvIjoiYmFyIiwiZnJvbSI6ImZvbyJ9XV0.?cb=aHR0cHM6Ly9leGFtcGxlLmNvbS9zaWduP3NpZz17e3NpZ319&nb&s=foo")
XCTAssertEqual(reparsed, url) // XCTAssertEqual(reparsed, url)
XCTAssertEqual(reparsed?.params, url?.params) // XCTAssertEqual(reparsed?.params, url?.params)
} }
} }

10
Tests/UnitTests/XCTestManifests.swift
View File

@ -26,7 +26,7 @@ extension ClientTest {
("testBadServerResponse", testBadServerResponse), ("testBadServerResponse", testBadServerResponse),
("testRequest", testRequest), ("testRequest", testRequest),
("testRequestWithParams", testRequestWithParams), ("testRequestWithParams", testRequestWithParams),
("testRpcError", testRpcError), // ("testRpcError", testRpcError),
("testSeqIdGenerator", testSeqIdGenerator), ("testSeqIdGenerator", testSeqIdGenerator),
] ]
} }
@ -56,7 +56,7 @@ extension PublicKeyTest {
("testInvalidKeys", testInvalidKeys), ("testInvalidKeys", testInvalidKeys),
("testKey", testKey), ("testKey", testKey),
("testNullKey", testNullKey), ("testNullKey", testNullKey),
("testTestnetKey", testTestnetKey), // ("testTestnetKey", testTestnetKey),
] ]
} }
@ -68,7 +68,7 @@ extension Secp256k1Test {
] ]
} }
extension SeemURLTest { extension VIZURLTest {
static let __allTests = [ static let __allTests = [
("testEncodeDecode", testEncodeDecode), ("testEncodeDecode", testEncodeDecode),
("testParams", testParams), ("testParams", testParams),
@ -89,7 +89,7 @@ extension SignatureTest {
] ]
} }
extension SteemEncoderTest { extension VIZEncoderTest {
static let __allTests = [ static let __allTests = [
("testArray", testArray), ("testArray", testArray),
("testFixedWidthInteger", testFixedWidthInteger), ("testFixedWidthInteger", testFixedWidthInteger),
@ -119,7 +119,7 @@ extension TransactionTest {
testCase(SeemURLTest.__allTests), testCase(SeemURLTest.__allTests),
testCase(Sha2Test.__allTests), testCase(Sha2Test.__allTests),
testCase(SignatureTest.__allTests), testCase(SignatureTest.__allTests),
testCase(SteemEncoderTest.__allTests), testCase(VIZEncoderTest.__allTests),
testCase(TransactionTest.__allTests), testCase(TransactionTest.__allTests),
] ]
} }