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
/Packages
/*.xcodeproj
xcuserdata/
Package.resolved
/build
/docs
/.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
let package = Package(
name: "Steem",
name: "VIZ",
products: [
.library(name: "Steem", targets: ["Steem"]),
.library(name: "VIZ", targets: ["VIZ"]),
],
dependencies: [
.package(url: "https://github.com/Flight-School/AnyCodable.git", .revision("396ccc3dba5bdee04c1e742e7fab40582861401e")),
@ -21,16 +22,16 @@ let package = Package(
dependencies: []
),
.target(
name: "Steem",
name: "VIZ",
dependencies: ["Crypto", "AnyCodable", "OrderedDictionary", "secp256k1"]
),
.testTarget(
name: "SteemTests",
dependencies: ["Steem"]
name: "UnitTests",
dependencies: ["VIZ"]
),
.testTarget(
name: "SteemIntegrationTests",
dependencies: ["Steem"]
name: "IntegrationTests",
dependencies: ["VIZ"]
),
]
)

25
README.md
View File

@ -1,43 +1,32 @@
# viz-swift-lib
swift-hive
===========
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)
VIZ library for Swift.
Installation
------------
Using the [Swift package manager](https://swift.org/package-manager/):
In your Package.swift add:
In your `Package.swift` just add:
```
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
-------------
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
----------
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.

2
Sources/Crypto/options.h
View File

@ -66,7 +66,7 @@
#define USE_ETHEREUM 0
#endif
// support Graphene operations (STEEM, BitShares)
// support Graphene operations (VIZ, BitShares)
#ifndef USE_GRAPHENE
#define USE_GRAPHENE 1
#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: Iain Maitland <imaitland@steemit.com>
import AnyCodable
import Foundation
/// Steem RPC API request- and response-types.
/// VIZ RPC API request- and response-types.
public struct API {
/// Wrapper for pre-appbase steemd calls.
/// Wrapper for pre-appbase vizd calls.
public struct CallParams<T: Encodable>: Encodable {
let api: String
let method: String
let params: [T]
init(_ api: String, _ method: String, _ params: [T]) {
self.api = api
init(_ method: String, _ params: [T]) {
self.method = method
self.params = params
}
public func encode(to encoder: Encoder) throws {
var container = encoder.unkeyedContainer()
try container.encode(api)
try container.encode(method)
try container.encode(params)
}
@ -29,73 +26,37 @@ public struct API {
public struct DynamicGlobalProperties: Decodable {
public let headBlockNumber: UInt32
public let headBlockId: BlockId
public let time: Date
public let genesisTime: Date
public let currentWitness: String
public let numPowWitnesses: UInt32
public let virtualSupply: Asset
public let committeeFund: Asset
public let committeeRequests: UInt32
public let currentSupply: Asset
public let confidentialSupply: Asset
public let currentSbdSupply: Asset
public let confidentialSbdSupply: Asset
public let totalVestingFundSteem: Asset
public let totalVestingFund: Asset
public let totalVestingShares: Asset
public let totalRewardFundSteem: Asset
public let totalRewardShares2: String
public let pendingRewardedVestingShares: Asset
public let pendingRewardedVestingSteem: Asset
public let sbdInterestRate: UInt32
public let sbdPrintRate: UInt32
public let totalRewardFund: Asset
public let totalRewardShares: String
public let inflationCalcBlockNum: UInt32
public let inflationWitnessPercent: Int16
public let inflationRatio: Int16
public let averageBlockSize: UInt32
public let maximumBlockSize: UInt32
public let currentAslot: UInt32
public let recentSlotsFilled: String
public let participationCount: UInt32
public let lastIrreversibleBlockNum: UInt32
public let votePowerReserveRate: UInt32
public let time: Date
public let maxVirtualBandwidth: String
public let currentReserveRatio: UInt64
public let voteRegenerationPerDay: UInt32
}
public struct GetDynamicGlobalProperties: Request {
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 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 let id: Data
public let blockNum: Int32
@ -108,7 +69,7 @@ public struct API {
public let method = "call"
public let params: CallParams<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 let id: Int
public let name: String
public let owner: Authority
public let active: Authority
public let posting: Authority
public let masterAuthority: Authority
public let activeAuthority: Authority
public let regularAuthority: Authority
public let memoKey: PublicKey
public let jsonMetadata: String
public let proxy: String
public let lastOwnerUpdate: Date
public let referrer: String
public let lastMasterUpdate: Date
public let lastAccountUpdate: Date
public let created: Date
public let mined: Bool
public let recoveryAccount: String
public let resetAccount: String
public let lastAccountRecovery: Date
public let commentCount: UInt32
public let lifetimeVoteCount: UInt32
public let postCount: UInt32
public let canVote: Bool
public let votingPower: UInt16
public let awardedRshares: UInt64
public let customSequence: UInt64
public let customSequenceBlockNum: UInt64
public let energy: Int32
public let lastVoteTime: Date
public let balance: Asset
public let savingsBalance: Asset
public let sbdBalance: Asset
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 receiverAwards: UInt64
public let benefactorAwards: UInt64
public let vestingShares: Asset
public let delegatedVestingShares: Asset
public let receivedVestingShares: Asset
@ -183,14 +128,26 @@ public struct API {
public let withdrawRoutes: UInt16
public let proxiedVsfVotes: [Share]
public let witnessesVotedFor: UInt16
public let witnessesVoteWeight: Share
public let lastPost: 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.
public struct GetAccounts: Request {
public typealias Response = [ExtendedAccount]
public let method = "condenser_api.get_accounts"
public let method = "get_accounts"
public let params: RequestParams<[String]>?
public init(names: [String]) {
self.params = RequestParams([names])
@ -222,7 +179,7 @@ public struct API {
public struct GetAccountHistory: Request, Encodable {
public typealias Response = [AccountHistoryObject]
public let method = "condenser_api.get_account_history"
public let method = "get_account_history"
public var params: RequestParams<AnyEncodable>? {
return RequestParams([AnyEncodable(self.account), AnyEncodable(self.from), AnyEncodable(self.limit)])
}
@ -236,22 +193,4 @@ public struct API {
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: Iain Maitland <imaitland@steemit.com>
import Foundation
/// The Steem asset type.
/// The VIZ asset type.
public struct Asset: Equatable {
/// Asset symbol type, containing the symbol name and precision.
public enum Symbol: Equatable {
/// The STEEM token.
case steem
/// The VIZ token.
case viz
/// Vesting shares.
case vests
/// Steem-backed dollars.
case sbd
/// Custom token.
case custom(name: String, precision: UInt8)
/// Number of decimal points represented.
public var precision: UInt8 {
switch self {
case .steem, .sbd:
case .viz:
return 3
case .vests:
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 {
switch self {
case .steem:
return "STEEM"
case .sbd:
return "SBD"
case .viz:
return "VIZ"
case .vests:
return "VESTS"
case let .custom(name, _):
@ -51,13 +47,13 @@ public struct Asset: Equatable {
/// Create a new `Asset`.
/// - Parameter value: Amount of tokens.
/// - 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.symbol = symbol
}
/// 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) {
let parts = value.split(separator: " ")
guard parts.count == 2 else {
@ -65,12 +61,10 @@ public struct Asset: Equatable {
}
let symbol: Symbol
switch parts[1] {
case "STEEM":
symbol = .steem
case "VIZ":
symbol = .viz
case "VESTS":
symbol = .vests
case "SBD":
symbol = .sbd
default:
let ap = parts[0].split(separator: ".")
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 {
/// The amount of the token, based on symbol precision.
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 {
let container = try decoder.singleValueContainer()
let value = try container.decode(String.self)
@ -149,7 +114,7 @@ extension Asset: SteemEncodable, Decodable {
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.symbol.precision)
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>
import Foundation
/// Type representing a Steem authority.
/// Type representing a VIZ authority.
///
/// Authorities are a collection of accounts and keys that need to sign
/// 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.
public struct Auth<T: SteemCodable & Equatable>: Equatable {
public struct Auth<T: VIZCodable & Equatable>: Equatable {
public let value: T
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 {
var container = try decoder.unkeyedContainer()
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>
import Foundation
/// Type representing a Steem block ID.
/// Type representing a VIZ block ID.
public struct BlockId: Codable, Equatable {
/// The block hash.
public var hash: Data
@ -52,7 +52,7 @@ fileprivate protocol _BlockHeader: Codable {
var extensions: [BlockExtension] { get }
}
/// A type representing a Steem block header.
/// A type representing a VIZ block header.
public struct BlockHeader: _BlockHeader {
public let previous: BlockId
public let timestamp: Date
@ -61,7 +61,7 @@ public struct BlockHeader: _BlockHeader {
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 let previous: BlockId
public let timestamp: Date
@ -71,7 +71,7 @@ public struct SignedBlockHeader: _BlockHeader, Equatable {
public let witnessSignature: Signature
}
/// A type representing a Steem block.
/// A type representing a VIZ block.
public struct SignedBlock: _BlockHeader, Equatable {
/// The transactions included in this block.
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>
import Foundation
/// Chain id, used to sign transactions.
public enum ChainId: Equatable {
/// The main Steem network.
/// The main VIZ network.
case mainNet
/// Defualt testing network id.
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")
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>
import AnyCodable
@ -12,7 +12,7 @@ import Foundation
/// let hello: String
/// let foo: Int
/// }
/// struct MyRequest: Steem.Request {
/// struct MyRequest: VIZ.Request {
/// typealias Response = MyResponse
/// let method = "my_method"
/// let params: RequestParams<String>
@ -26,6 +26,7 @@ public protocol Request {
associatedtype Response: Decodable
/// Request parameter type.
associatedtype Params: Encodable
var api: String { get }
/// JSON-RPC 2.0 method to call.
var method: String { get }
/// JSON-RPC 2.0 parameters
@ -34,6 +35,36 @@ public protocol Request {
// Default implementation sends a request without params.
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>? {
return nil
}
@ -83,7 +114,7 @@ extension RequestParams: Encodable {
}
/// JSON-RPC 2.0 request payload wrapper.
internal struct RequestPayload<Request: Steem.Request> {
internal struct RequestPayload<Request: VIZ.Request> {
let request: Request
let id: Int
}
@ -96,12 +127,26 @@ extension RequestPayload: Encodable {
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 {
var container = encoder.container(keyedBy: Keys.self)
try container.encode(self.id, forKey: .id)
try container.encode("2.0", forKey: .jsonrpc)
try container.encode(self.request.method, forKey: .method)
try container.encodeIfPresent(self.request.params, forKey: .params)
try container.encode("call", forKey: .method)
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 {
/// All errors `Client` can throw.
public enum Error: LocalizedError {
@ -205,7 +250,7 @@ public class Client {
let encoder = Client.JSONEncoder()
var urlRequest = URLRequest(url: self.address)
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.httpBody = try encoder.encode(payload)
return urlRequest
@ -296,7 +341,7 @@ public class Client {
/// JSON Coding helpers.
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 = {
let formatter = DateFormatter()
formatter.calendar = Calendar(identifier: .iso8601)
@ -329,7 +374,7 @@ extension Client {
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 {
let decoder = Foundation.JSONDecoder()
decoder.dataDecodingStrategy = dataDecoder
@ -340,7 +385,7 @@ extension Client {
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 {
let encoder = Foundation.JSONEncoder()
encoder.dataEncodingStrategy = dataEncoder

2
Sources/VIZ/Hex.swift
View File

@ -16,7 +16,7 @@ internal extension Data {
}
bytes[index >> 1] |= n
}
self = Data(bytes: bytes)
self = Data(bytes)
}
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>
import Foundation
/// A type that is decodable to Steem binary format as well as JSON encodable and decodable.
public typealias SteemCodable = SteemEncodable & Decodable
/// A type that is decodable to VIZ binary format as well as JSON encodable and decodable.
public typealias VIZCodable = VIZEncodable & Decodable
/// Placeholder type for future extensions.
public struct FutureExtensions: SteemCodable, Equatable {}
public struct FutureExtensions: VIZCodable, Equatable {}
/// Type representing an optional JSON string.
public struct JSONString: Equatable {
@ -29,7 +29,7 @@ public struct JSONString: Equatable {
}
}
extension JSONString: SteemCodable {
extension JSONString: VIZCodable {
public init(from decoder: Decoder) throws {
let container = try decoder.singleValueContainer()
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>
import Foundation
/// A type that represents a operation on the Steem blockchain.
public protocol OperationType: SteemCodable {
/// A type that represents a operation on the VIZ blockchain.
public protocol OperationType: VIZCodable {
/// Whether the operation is virtual or not.
var isVirtual: Bool { get }
}
@ -13,7 +13,7 @@ extension OperationType {
public var isVirtual: Bool { return false }
}
/// Namespace for all available Steem operations.
/// Namespace for all available VIZ operations.
public struct Operation {
/// Voting operation, votes for content.
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 {
/// Account name of sender.
public var from: String
/// Account name of reciever.
public var to: String
/// Amount to power up, must be STEEM.
/// Amount to power up, must be VIZ.
public var 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.
public struct Convert: OperationType, Equatable {
public var owner: String
@ -195,9 +147,9 @@ public struct Operation {
public var fee: Asset
public var creator: String
public var newAccountName: String
public var owner: Authority
public var master: Authority
public var active: Authority
public var posting: Authority
public var regular: Authority
public var memoKey: PublicKey
public var jsonMetadata: JSONString
@ -205,18 +157,18 @@ public struct Operation {
fee: Asset,
creator: String,
newAccountName: String,
owner: Authority,
master: Authority,
active: Authority,
posting: Authority,
regular: Authority,
memoKey: PublicKey,
jsonMetadata: JSONString = ""
) {
self.fee = fee
self.creator = creator
self.newAccountName = newAccountName
self.owner = owner
self.master = master
self.active = active
self.posting = posting
self.regular = regular
self.memoKey = memoKey
self.jsonMetadata = jsonMetadata
}
@ -231,24 +183,24 @@ public struct Operation {
/// Updates an account.
public struct AccountUpdate: OperationType, Equatable {
public var account: String
public var owner: Authority?
public var active: Authority?
public var posting: Authority?
public var masterAuthority: Authority?
public var activeAuthority: Authority?
public var regularAuthority: Authority?
public var memoKey: PublicKey
public var jsonMetadata: String
public init(
account: String,
owner: Authority?,
active: Authority?,
posting: Authority?,
masterAuthority: Authority?,
activeAuthority: Authority?,
regularAuthority: Authority?,
memoKey: PublicKey,
jsonMetadata: String = ""
) {
self.account = account
self.owner = owner
self.active = active
self.posting = posting
self.masterAuthority = masterAuthority
self.activeAuthority = activeAuthority
self.regularAuthority = regularAuthority
self.memoKey = memoKey
self.jsonMetadata = jsonMetadata
}
@ -257,7 +209,7 @@ public struct Operation {
/// Registers or updates witnesses.
public struct WitnessUpdate: OperationType, Equatable {
/// Witness chain properties.
public struct Properties: SteemCodable, Equatable {
public struct Properties: VIZCodable, Equatable {
// public var accountCreationFee: Asset
// public var maximumBlockSize: UInt32
// public var sbdInterestRate: UInt16
@ -313,16 +265,19 @@ public struct Operation {
/// Custom operation.
public struct Custom: OperationType, Equatable {
public var requiredAuths: [String]
public var requiredRegularAuths: [String]
public var requiredActiveAuths: [String]
public var id: UInt16
public var data: Data
public init(
requiredAuths: [String],
requiredRegularAuths: [String],
requiredActiveAuths: [String],
id: UInt16,
data: Data
) {
self.requiredAuths = requiredAuths
self.requiredRegularAuths = requiredRegularAuths
self.requiredActiveAuths = requiredActiveAuths
self.id = id
self.data = data
}
@ -378,13 +333,13 @@ public struct Operation {
/// Sets comment options.
public struct CommentOptions: OperationType, Equatable {
public struct BeneficiaryRoute: SteemCodable, Equatable {
public struct BeneficiaryRoute: VIZCodable, Equatable {
public var account: String
public var weight: UInt16
}
/// Comment option extensions.
public enum Extension: SteemCodable, Equatable {
public enum Extension: VIZCodable, Equatable {
/// Unknown extension.
case unknown
/// 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 var challenger: String
public var challenged: String
@ -835,9 +764,9 @@ public struct Operation {
public var delegation: Asset
public var creator: String
public var newAccountName: String
public var owner: Authority
public var master: Authority
public var active: Authority
public var posting: Authority
public var regular: Authority
public var memoKey: PublicKey
public var jsonMetadata: JSONString
public var extensions: [FutureExtensions]
@ -847,9 +776,9 @@ public struct Operation {
delegation: Asset,
creator: String,
newAccountName: String,
owner: Authority,
master: Authority,
active: Authority,
posting: Authority,
regular: Authority,
memoKey: PublicKey,
jsonMetadata: JSONString = "",
extensions: [FutureExtensions] = []
@ -858,9 +787,9 @@ public struct Operation {
self.delegation = delegation
self.creator = creator
self.newAccountName = newAccountName
self.owner = owner
self.master = master
self.active = active
self.posting = posting
self.regular = regular
self.memoKey = memoKey
self.jsonMetadata = jsonMetadata
self.extensions = extensions
@ -982,6 +911,15 @@ public struct Operation {
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.
/// - Note: Not encodable, the encoder will throw if encountering this operation.
public struct Unknown: OperationType, Equatable {}
@ -990,15 +928,15 @@ public struct Operation {
// MARK: - Encoding
/// Operation ID, used for coding.
fileprivate enum OperationId: UInt8, SteemEncodable, Decodable {
fileprivate enum OperationId: UInt8, VIZEncodable, Decodable {
case vote = 0
case comment = 1
case transfer = 2
case transfer_to_vesting = 3
case withdraw_vesting = 4
case limit_order_create = 5
case limit_order_cancel = 6
case feed_publish = 7
// case limit_order_create = 5
// case limit_order_cancel = 6
// case feed_publish = 7
case convert = 8
case account_create = 9
case account_update = 10
@ -1012,7 +950,7 @@ fileprivate enum OperationId: UInt8, SteemEncodable, Decodable {
case custom_json = 18
case comment_options = 19
case set_withdraw_vesting_route = 20
case limit_order_create2 = 21
// case limit_order_create2 = 21
case challenge_authority = 22
case prove_authority = 23
case request_account_recovery = 24
@ -1033,7 +971,6 @@ fileprivate enum OperationId: UInt8, SteemEncodable, Decodable {
case claim_reward_balance = 39
case delegate_vesting_shares = 40
case account_create_with_delegation = 41
// Virtual operations
case fill_convert_request
case author_reward
case curation_reward
@ -1049,6 +986,21 @@ fileprivate enum OperationId: UInt8, SteemEncodable, Decodable {
case return_vesting_delegation
case comment_benefactor_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
init(from decoder: Decoder) throws {
@ -1060,9 +1012,6 @@ fileprivate enum OperationId: UInt8, SteemEncodable, Decodable {
case "transfer": self = .transfer
case "transfer_to_vesting": self = .transfer_to_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 "account_create": self = .account_create
case "account_update": self = .account_update
@ -1076,7 +1025,6 @@ fileprivate enum OperationId: UInt8, SteemEncodable, Decodable {
case "custom_json": self = .custom_json
case "comment_options": self = .comment_options
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 "prove_authority": self = .prove_authority
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 "comment_benefactor_reward": self = .comment_benefactor_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
}
}
@ -1121,13 +1084,13 @@ fileprivate enum OperationId: UInt8, SteemEncodable, Decodable {
try container.encode("\(self)")
}
func binaryEncode(to encoder: SteemEncoder) throws {
func binaryEncode(to encoder: VIZEncoder) throws {
try encoder.encode(self.rawValue)
}
}
/// A type-erased Steem operation.
internal struct AnyOperation: SteemEncodable, Decodable {
/// A type-erased VIZ operation.
internal struct AnyOperation: VIZEncodable, Decodable {
public let operation: OperationType
/// 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_to_vesting: op = try container.decode(Operation.TransferToVesting.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 .account_create: op = try container.decode(Operation.AccountCreate.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 .comment_options: op = try container.decode(Operation.CommentOptions.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 .prove_authority: op = try container.decode(Operation.ProveAuthority.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 .comment_benefactor_reward: op = try container.decode(Operation.CommentBenefactorReward.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()
}
self.operation = op
@ -1224,15 +1200,6 @@ internal struct AnyOperation: SteemEncodable, Decodable {
case let op as Operation.WithdrawVesting:
try container.encode(OperationId.withdraw_vesting)
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:
try container.encode(OperationId.convert)
try container.encode(op)
@ -1272,9 +1239,6 @@ internal struct AnyOperation: SteemEncodable, Decodable {
case let op as Operation.SetWithdrawVestingRoute:
try container.encode(OperationId.set_withdraw_vesting_route)
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:
try container.encode(OperationId.challenge_authority)
try container.encode(op)
@ -1335,6 +1299,9 @@ internal struct AnyOperation: SteemEncodable, Decodable {
case let op as Operation.AccountCreateWithDelegation:
try container.encode(OperationId.account_create_with_delegation)
try container.encode(op)
case let op as Operation.Award:
try container.encode(OperationId.award)
try container.encode(op)
default:
throw EncodingError.invalidValue(self.operation, EncodingError.Context(
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]
}

4
Sources/VIZ/PrivateKey.swift
View File

@ -1,9 +1,9 @@
/// Steem PrivateKey implementation.
/// VIZ PrivateKey implementation.
/// - Author: Johan Nordberg <johan@steemit.com>
import Foundation
/// A Steem private key.
/// A VIZ private key.
public struct PrivateKey: Equatable {
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>
import Foundation
/// A Steem public key.
/// A VIZ public key.
public struct PublicKey: Equatable {
/// Chain address prefix.
public enum AddressPrefix: Equatable, Hashable {
/// STM, main network.
case mainNet
/// TST, test networks.
case testNet
/// Freeform address prefix, e.g. "STX".
case mainNet // VIZ
case testNet // VIZ
case custom(String)
}
@ -32,8 +29,8 @@ public struct PublicKey: Equatable {
self.prefix = prefix
}
/// Create a new PublicKey instance from a Steem public key address.
/// - Parameter address: The public key in Steem address format.
/// Create a new PublicKey instance from a VIZ public key address.
/// - Parameter address: The public key in VIZ address format.
public init?(_ address: String) {
let prefix = address.prefix(3)
guard prefix.count == 3 else {
@ -66,7 +63,7 @@ extension PublicKey: LosslessStringConvertible {
public var description: String { return self.address }
}
extension PublicKey: SteemEncodable, Decodable {
extension PublicKey: VIZEncodable, Decodable {
public init(from decoder: Decoder) throws {
let container = try decoder.singleValueContainer()
guard let key = PublicKey(try container.decode(String.self)) else {
@ -80,7 +77,7 @@ extension PublicKey: SteemEncodable, Decodable {
try container.encode(String(self))
}
public func binaryEncode(to encoder: SteemEncoder) {
public func binaryEncode(to encoder: VIZEncoder) {
encoder.data.append(self.key)
}
}
@ -90,9 +87,9 @@ extension PublicKey.AddressPrefix: ExpressibleByStringLiteral, LosslessStringCon
/// Create new addres prefix from string.
public init(_ value: String) {
if value == "STM" {
if value == "VIZ" {
self = .mainNet
} else if value == "TST" {
} else if value == "VIZTEST" {
self = .testNet
} else {
self = .custom(value)
@ -103,13 +100,13 @@ extension PublicKey.AddressPrefix: ExpressibleByStringLiteral, LosslessStringCon
self.init(value)
}
/// String representation of address prefix, e.g. "STM".
/// String representation of address prefix, e.g. "VIZ".
public var description: String {
switch self {
case .mainNet:
return "STM"
return "VIZ"
case .testNet:
return "TST"
return "VIZ"
case let .custom(prefix):
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>
import Foundation
/// A Steem signature.
/// A VIZ signature.
public struct Signature: Equatable, LosslessStringConvertible {
private let signature: Data
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>
import AnyCodable
import Foundation
fileprivate protocol _Transaction: SteemEncodable, Decodable {
fileprivate protocol _Transaction: VIZEncodable, Decodable {
/// Block number reference.
var refBlockNum: UInt16 { get }
/// Block number reference id.
@ -54,7 +54,7 @@ public struct Transaction: _Transaction {
/// SHA2-256 digest for signing.
public func digest(forChain chain: ChainId = .mainNet) throws -> Data {
var data = chain.data
data.append(try SteemEncoder.encode(self))
data.append(try VIZEncoder.encode(self))
return data.sha256Digest()
}
}
@ -171,7 +171,7 @@ extension SignedTransaction {
// Workaround for: Swift runtime does not yet support dynamically querying conditional conformance.
#if !swift(>=4.2)
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.refBlockPrefix)
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>
import Foundation
import OrderedDictionary
/// A type that can be encoded into Steem binary wire format.
public protocol SteemEncodable: Encodable {
/// Encode self into Steem binary format.
func binaryEncode(to encoder: SteemEncoder) throws
/// A type that can be encoded into VIZ binary wire format.
public protocol VIZEncodable: Encodable {
/// Encode self into VIZ binary format.
func binaryEncode(to encoder: VIZEncoder) throws
}
/// Default implementation which calls through to `Encodable`.
public extension SteemEncodable {
func binaryEncode(to encoder: SteemEncoder) throws {
public extension VIZEncodable {
func binaryEncode(to encoder: VIZEncoder) throws {
try self.encode(to: encoder)
}
}
/// Encodes data into Steem binary format.
public class SteemEncoder {
/// All errors which `SteemEncoder` can throw.
/// Encodes data into VIZ binary format.
public class VIZEncoder {
/// All errors which `VIZEncoder` can throw.
public enum Error: Swift.Error {
/// Thrown if encoder encounters a type that is not conforming to `SteemEncodable`.
case typeNotConformingToSteemEncodable(Encodable.Type)
/// Thrown if encoder encounters a type that is not conforming to `VIZEncodable`.
case typeNotConformingToVIZEncodable(Encodable.Type)
/// Thrown if encoder encounters a type that is not confirming to `Encodable`.
case typeNotConformingToEncodable(Any.Type)
}
/// 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()
/// Create a new encoder.
public init() {}
/// Convenience for creating an encoder, encoding a value and returning the data.
public static func encode(_ value: SteemEncodable) throws -> Data {
let encoder = SteemEncoder()
public static func encode(_ value: VIZEncodable) throws -> Data {
let encoder = VIZEncoder()
try value.binaryEncode(to: encoder)
return encoder.data
}
/// Encodes any `SteemEncodable`.
/// Encodes any `VIZEncodable`.
/// - Note: Platform specific integer types `Int` and `UInt` are encoded as varints.
public func encode(_ value: Encodable) throws {
switch value {
@ -49,16 +49,16 @@ public class SteemEncoder {
self.appendVarint(UInt64(v))
case let v as UInt:
self.appendVarint(UInt64(v))
case let v as Array<SteemEncodable>:
case let v as Array<VIZEncodable>:
self.appendVarint(UInt64(v.count))
for i in v {
try i.binaryEncode(to: self)
}
break
case let v as SteemEncodable:
case let v as VIZEncodable:
try v.binaryEncode(to: self)
default:
throw Error.typeNotConformingToSteemEncodable(type(of: value))
throw Error.typeNotConformingToVIZEncodable(type(of: value))
}
}
@ -84,7 +84,7 @@ public class SteemEncoder {
// Encoder conformance.
// Based on Mike Ash's BinaryEncoder
// https://github.com/mikeash/BinaryCoder
extension SteemEncoder: Encoder {
extension VIZEncoder: Encoder {
public var codingPath: [CodingKey] { return [] }
public var userInfo: [CodingUserInfoKey: Any] { return [:] }
@ -102,7 +102,7 @@ extension SteemEncoder: Encoder {
}
private struct KeyedContainer<Key: CodingKey>: KeyedEncodingContainerProtocol {
var encoder: SteemEncoder
var encoder: VIZEncoder
var codingPath: [CodingKey] { return [] }
@ -130,7 +130,7 @@ extension SteemEncoder: Encoder {
}
private struct UnkeyedContanier: UnkeyedEncodingContainer, SingleValueEncodingContainer {
var encoder: SteemEncoder
var encoder: VIZEncoder
var codingPath: [CodingKey] { return [] }
@ -158,30 +158,30 @@ extension SteemEncoder: Encoder {
// MARK: - Default type extensions
extension FixedWidthInteger where Self: SteemEncodable {
public func binaryEncode(to encoder: SteemEncoder) {
extension FixedWidthInteger where Self: VIZEncodable {
public func binaryEncode(to encoder: VIZEncoder) {
encoder.appendBytes(of: self.littleEndian)
}
}
extension Int8: SteemEncodable {}
extension UInt8: SteemEncodable {}
extension Int16: SteemEncodable {}
extension UInt16: SteemEncodable {}
extension Int32: SteemEncodable {}
extension UInt32: SteemEncodable {}
extension Int64: SteemEncodable {}
extension UInt64: SteemEncodable {}
extension Int8: VIZEncodable {}
extension UInt8: VIZEncodable {}
extension Int16: VIZEncodable {}
extension UInt16: VIZEncodable {}
extension Int32: VIZEncodable {}
extension UInt32: VIZEncodable {}
extension Int64: VIZEncodable {}
extension UInt64: VIZEncodable {}
extension String: SteemEncodable {
public func binaryEncode(to encoder: SteemEncoder) {
extension String: VIZEncodable {
public func binaryEncode(to encoder: VIZEncoder) {
encoder.appendVarint(UInt64(self.utf8.count))
encoder.data.append(contentsOf: self.utf8)
}
}
extension Array: SteemEncodable where Element: Encodable {
public func binaryEncode(to encoder: SteemEncoder) throws {
extension Array: VIZEncodable where Element: Encodable {
public func binaryEncode(to encoder: VIZEncoder) throws {
encoder.appendVarint(UInt64(self.count))
for item in self {
try encoder.encode(item)
@ -189,8 +189,8 @@ extension Array: SteemEncodable where Element: Encodable {
}
}
extension OrderedDictionary: SteemEncodable where Key: SteemEncodable, Value: SteemEncodable {
public func binaryEncode(to encoder: SteemEncoder) throws {
extension OrderedDictionary: VIZEncodable where Key: VIZEncodable, Value: VIZEncodable {
public func binaryEncode(to encoder: VIZEncoder) throws {
encoder.appendVarint(UInt64(self.count))
for (key, value) in self {
try encoder.encode(key)
@ -199,26 +199,26 @@ extension OrderedDictionary: SteemEncodable where Key: SteemEncodable, Value: St
}
}
extension Date: SteemEncodable {
public func binaryEncode(to encoder: SteemEncoder) throws {
extension Date: VIZEncodable {
public func binaryEncode(to encoder: VIZEncoder) throws {
try encoder.encode(UInt32(self.timeIntervalSince1970))
}
}
extension Data: SteemEncodable {
public func binaryEncode(to encoder: SteemEncoder) {
extension Data: VIZEncodable {
public func binaryEncode(to encoder: VIZEncoder) {
encoder.data.append(self)
}
}
extension Bool: SteemEncodable {
public func binaryEncode(to encoder: SteemEncoder) {
extension Bool: VIZEncodable {
public func binaryEncode(to encoder: VIZEncoder) {
encoder.data.append(self ? 1 : 0)
}
}
extension Optional: SteemEncodable where Wrapped: SteemEncodable {
public func binaryEncode(to encoder: SteemEncoder) throws {
extension Optional: VIZEncodable where Wrapped: VIZEncodable {
public func binaryEncode(to encoder: VIZEncoder) throws {
if let value = self {
encoder.data.append(1)
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>
import Foundation
/// Type representing a Steem signing URL
///
/// See specification at https://github.com/steemit/steem-uri-spec
public struct SteemURL {
/// All errors `SteemURL` can throw.
/// Type representing a VIZ signing URL
public struct VIZURL {
/// All errors `VIZURL` can throw.
public enum Error: Swift.Error {
case invalidURL
case invalidScheme
@ -39,9 +37,9 @@ public struct SteemURL {
case operations = "ops"
}
/// Parses a steem signing url
static func parse(_ url: URLComponents) throws -> SteemURL {
guard url.scheme == "steem" else {
/// Parses a VIZ signing url
static func parse(_ url: URLComponents) throws -> VIZURL {
guard url.scheme == "viz" else {
throw Error.invalidScheme
}
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.
@ -93,7 +91,7 @@ public struct SteemURL {
let type: PayloadType
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.
public init(type: PayloadType, params: Params, payload: Any) {
self.type = type
@ -101,35 +99,35 @@ public struct SteemURL {
self.payload = payload
}
/// Create a new SteemURL from a string
/// Create a new VIZURL from a string
public init?(string: String) {
guard let url = URLComponents(string: string),
let _self = try? SteemURL.parse(url)
let _self = try? VIZURL.parse(url)
else {
return nil
}
self = _self
}
/// Create a new SteemURL from a URL.
/// Create a new VIZURL from a URL.
public init?(url: URL) {
guard let url = URLComponents(url: url, resolvingAgainstBaseURL: true),
let _self = try? SteemURL.parse(url)
let _self = try? VIZURL.parse(url)
else {
return nil
}
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) {
guard let _self = try? SteemURL.parse(url) else {
guard let _self = try? VIZURL.parse(url) else {
return nil
}
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()) {
guard let payload = try? encodeObject(transaction) else {
return nil
@ -139,7 +137,7 @@ public struct SteemURL {
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()) {
guard let payload = try? encodeObject(AnyOperation(operation)) else {
return nil
@ -149,7 +147,7 @@ public struct SteemURL {
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()) {
guard let payload = try? encodeObject(operations.map({ AnyOperation($0) })) else {
return nil
@ -273,13 +271,13 @@ public struct SteemURL {
return URL(string: urlString)
}
/// The steem:// URL
/// The viz:// URL
var url: URL? {
guard let data = try? JSONSerialization.data(withJSONObject: self.payload, options: []) else {
return nil
}
var url = URLComponents()
url.scheme = "steem"
url.scheme = "viz"
url.host = "sign"
url.path = "/\(self.type.rawValue)/\(data.base64uEncodedString())"
var query: [URLQueryItem] = []
@ -302,17 +300,17 @@ public struct SteemURL {
}
}
extension SteemURL: CustomStringConvertible {
extension VIZURL: CustomStringConvertible {
public var description: String {
guard let url = self.url else {
return "Invalid SteemURL"
return "Invalid VIZURL"
}
return url.absoluteString
}
}
extension SteemURL: Equatable {
public static func == (lhs: SteemURL, rhs: SteemURL) -> Bool {
extension VIZURL: Equatable {
public static func == (lhs: VIZURL, rhs: VIZURL) -> Bool {
return lhs.url == rhs.url
}
}

328
Tests/IntegrationTests/API.swift
View File

@ -1,43 +1,24 @@
@testable import Steem
@testable import VIZ
import XCTest
struct HelloRequest: Request {
typealias Response = String
let method = "conveyor.hello"
let params: RequestParams<String>? = RequestParams(["name": "foo"])
}
let client = VIZ.Client(address: URL(string: "https://node.viz.cx")!)
let client = Steem.Client(address: URL(string: "https://api.steemit.com")!)
let testnetClient = Steem.Client(address: URL(string: "https://testnet.steemitdev.com")!)
let testnetId = ChainId.custom(Data(hexEncoded: "46d82ab7d8db682eb1959aed0ada039a6d49afa1602491f93dde9cac3e8e6c32"))
// 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 testnetId = ChainId.custom(Data(hexEncoded: "46d82ab7d8db682eb1959aed0ada039a6d49afa1602491f93dde9cac3e8e6c32"))
class ClientTest: XCTestCase {
func testNani() {
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() {
let test = expectation(description: "Response")
let req = API.GetDynamicGlobalProperties()
client.send(req) { res, error in
XCTAssertNil(error)
XCTAssertNotNil(res)
XCTAssertEqual(res?.currentSupply.symbol.name, "STEEM")
XCTAssertEqual(res?.currentSupply.symbol.name, "VIZ")
test.fulfill()
}
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() {
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
XCTAssertNil(error)
XCTAssertEqual(block?.previous.num, 12_345_677)
XCTAssertEqual(block?.transactions.count, 7)
XCTAssertEqual(block?.previous.num, 25_199_246)
XCTAssertEqual(block?.transactions.count, 2)
test.fulfill()
}
waitForExpectations(timeout: 5) { error in
@ -113,148 +44,151 @@ class ClientTest: XCTestCase {
}
}
func testBroadcast() {
let test = expectation(description: "Response")
let key = PrivateKey("5KS8eoAGLrCg2w3ytqSQXsmHuDTdvb2NLjJLpxgaiVJDXaGpcGT")!
var comment = Operation.Comment(
title: "Hello from Swift",
body: "The time is \(Date()) and I'm running tests.",
author: "test19",
permlink: "hey-eveyone-im-running-swift-tests-and-the-time-is-\(UInt32(Date().timeIntervalSinceReferenceDate))"
)
comment.parentPermlink = "test"
let vote = Operation.Vote(voter: "test19", author: "test19", permlink: comment.permlink)
testnetClient.send(API.GetDynamicGlobalProperties()) { props, error in
XCTAssertNil(error)
guard let props = props else {
return XCTFail("Unable to get props")
}
let expiry = props.time.addingTimeInterval(60)
let tx = Transaction(
refBlockNum: UInt16(props.headBlockNumber & 0xFFFF),
refBlockPrefix: props.headBlockId.prefix,
expiration: expiry,
operations: [comment, vote]
)
guard let stx = try? tx.sign(usingKey: key, forChain: testnetId) else {
return XCTFail("Unable to sign tx")
}
testnetClient.send(API.BroadcastTransaction(transaction: stx)) { res, error in
XCTAssertNil(error)
if let res = res {
XCTAssertFalse(res.expired)
XCTAssert(res.blockNum > props.headBlockId.num)
} else {
XCTFail("No response")
}
test.fulfill()
}
}
waitForExpectations(timeout: 10) { error in
if let error = error {
print("Error: \(error.localizedDescription)")
}
}
}
func testTransferBroadcast() {
let test = expectation(description: "Response")
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.")
testnetClient.send(API.GetDynamicGlobalProperties()) { props, error in
XCTAssertNil(error)
guard let props = props else {
return XCTFail("Unable to get props")
}
let expiry = props.time.addingTimeInterval(60)
let tx = Transaction(
refBlockNum: UInt16(props.headBlockNumber & 0xFFFF),
refBlockPrefix: props.headBlockId.prefix,
expiration: expiry,
operations: [transfer]
)
guard let stx = try? tx.sign(usingKey: key, forChain: testnetId) else {
return XCTFail("Unable to sign tx")
}
testnetClient.send(API.BroadcastTransaction(transaction: stx)) { res, error in
XCTAssertNil(error)
if let res = res {
XCTAssertFalse(res.expired)
XCTAssert(res.blockNum > props.headBlockId.num)
} else {
XCTFail("No response")
}
test.fulfill()
}
}
waitForExpectations(timeout: 10) { error in
if let error = error {
print("Error: \(error.localizedDescription)")
}
}
}
// func testBroadcast() {
// let test = expectation(description: "Response")
// let key = PrivateKey("5KS8eoAGLrCg2w3ytqSQXsmHuDTdvb2NLjJLpxgaiVJDXaGpcGT")!
// var comment = Operation.Comment(
// title: "Hello from Swift",
// body: "The time is \(Date()) and I'm running tests.",
// author: "test19",
// permlink: "hey-eveyone-im-running-swift-tests-and-the-time-is-\(UInt32(Date().timeIntervalSinceReferenceDate))"
// )
// comment.parentPermlink = "test"
// let vote = Operation.Vote(voter: "test19", author: "test19", permlink: comment.permlink)
// testnetClient.send(API.GetDynamicGlobalProperties()) { props, error in
// XCTAssertNil(error)
// guard let props = props else {
// return XCTFail("Unable to get props")
// }
// let expiry = props.time.addingTimeInterval(60)
// let tx = Transaction(
// refBlockNum: UInt16(props.headBlockNumber & 0xFFFF),
// refBlockPrefix: props.headBlockId.prefix,
// expiration: expiry,
// operations: [comment, vote]
// )
//
// guard let stx = try? tx.sign(usingKey: key, forChain: testnetId) else {
// return XCTFail("Unable to sign tx")
// }
// testnetClient.send(API.BroadcastTransaction(transaction: stx)) { res, error in
// XCTAssertNil(error)
// if let res = res {
// XCTAssertFalse(res.expired)
// XCTAssert(res.blockNum > props.headBlockId.num)
// } else {
// XCTFail("No response")
// }
// test.fulfill()
// }
// }
// waitForExpectations(timeout: 10) { error in
// if let error = error {
// print("Error: \(error.localizedDescription)")
// }
// }
// }
//
// func testTransferBroadcast() {
// let test = expectation(description: "Response")
// 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.")
//
// testnetClient.send(API.GetDynamicGlobalProperties()) { props, error in
// XCTAssertNil(error)
// guard let props = props else {
// return XCTFail("Unable to get props")
// }
// let expiry = props.time.addingTimeInterval(60)
//
// let tx = Transaction(
// refBlockNum: UInt16(props.headBlockNumber & 0xFFFF),
// refBlockPrefix: props.headBlockId.prefix,
// expiration: expiry,
// operations: [transfer]
// )
//
// guard let stx = try? tx.sign(usingKey: key, forChain: testnetId) else {
// return XCTFail("Unable to sign tx")
// }
// testnetClient.send(API.BroadcastTransaction(transaction: stx)) { res, error in
// XCTAssertNil(error)
// if let res = res {
// XCTAssertFalse(res.expired)
// XCTAssert(res.blockNum > props.headBlockId.num)
// } else {
// XCTFail("No response")
// }
// test.fulfill()
// }
// }
// waitForExpectations(timeout: 10) { error in
// if let error = error {
// print("Error: \(error.localizedDescription)")
// }
// }
// }
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 {
XCTFail("No account returned")
return
}
XCTAssertEqual(account.id, 180_270)
XCTAssertEqual(account.name, "almost-digital")
XCTAssertEqual(account.created, Date(timeIntervalSince1970: 1_496_691_060))
XCTAssertEqual(account.id, 3775)
XCTAssertEqual(account.name, "kelechek")
XCTAssertEqual(account.created, Date(timeIntervalSince1970: 1577304837))
}
func testTestnetGetAccount() throws {
let result = try testnetClient.sendSynchronous(API.GetAccounts(names: ["almost-digital"]))
guard let account = result?.first else {
XCTFail("No account returned")
return
}
XCTAssertEqual(account.id, 40413)
XCTAssertEqual(account.name, "almost-digital")
}
// func testTestnetGetAccount() throws {
// let result = try testnetClient.sendSynchronous(API.GetAccounts(names: ["id"]))
// guard let account = result?.first else {
// XCTFail("No account returned")
// return
// }
//
// XCTAssertEqual(account.id, 40413)
// XCTAssertEqual(account.name, "id")
// }
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)
guard let r = result?.first else {
XCTFail("No results returned")
return
}
let createOp = r.value.operation as? Steem.Operation.AccountCreateWithDelegation
XCTAssertEqual(createOp?.newAccountName, "almost-digital")
let createOp = r.value.operation as? VIZ.Operation.AccountCreate
XCTAssertEqual(createOp?.newAccountName, "sinteaspirans")
}
func testTestnetGetAccountHistory() throws {
let req = API.GetAccountHistory(account: "almost-digital", from: 1, limit: 1)
let result = try testnetClient.sendSynchronous(req)
guard let r = result?.first else {
XCTFail("No results returned")
return
}
let createOp = r.value.operation as? Steem.Operation.AccountCreate
XCTAssertEqual(createOp?.newAccountName, "almost-digital")
}
// func testTestnetGetAccountHistory() throws {
// let req = API.GetAccountHistory(account: "id", from: 1, limit: 1)
// let result = try testnetClient.sendSynchronous(req)
// guard let r = result?.first else {
// XCTFail("No results returned")
// return
// }
// let createOp = r.value.operation as? VIZ.Operation.AccountCreate
// XCTAssertEqual(createOp?.newAccountName, "id")
// }
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)
guard let r = result?.first else {
XCTFail("No results returned")
return
}
let op = r.value.operation as? Steem.Operation.AuthorReward
XCTAssertEqual(op?.isVirtual, true)
XCTAssertEqual(op?.author, "almost-digital")
XCTAssertEqual(op?.vestingPayout, Asset(113.868270, .vests))
let op = r.value.operation as? VIZ.Operation.Award
XCTAssertEqual(op?.isVirtual, false)
XCTAssertEqual(op?.initiator, "id")
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 Steem
import VIZ
import XCTest
class PerformanceTest: XCTestCase {
@ -19,7 +19,7 @@ class PerformanceTest: XCTestCase {
let txn = Transaction(refBlockNum: 0, refBlockPrefix: 0, expiration: Date(), operations: [vote, comment])
self.measure {
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 {
static let __allTests = [
("testBroadcast", testBroadcast),
// ("testBroadcast", testBroadcast),
("testGetBlock", testGetBlock),
("testGlobalProps", testGlobalProps),
("testRequest", testRequest),
// ("testRequest", testRequest),
]
}

10
Tests/LinuxMain.swift
View File

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

44
Tests/UnitTests/Asset.swift
View File

@ -1,53 +1,35 @@
import Foundation
@testable import Steem
@testable import VIZ
import XCTest
class AssetTest: XCTestCase {
func testEncodable() {
AssertEncodes(Asset(10, .steem), Data("102700000000000003535445454d0000"))
AssertEncodes(Asset(10, .viz), Data("10270000000000000356495a00000000"))
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(42, .custom(name: "TOWELS", precision: 0)), "42 TOWELS")
AssertEncodes(Asset(0.001, .sbd), "0.001 SBD")
}
func testProperties() {
let mockAsset = Asset(0.001, .sbd)
XCTAssertEqual(mockAsset.description, "0.001 SBD")
let mockAsset = Asset(0.001, .viz)
XCTAssertEqual(mockAsset.description, "0.001 VIZ")
XCTAssertEqual(mockAsset.amount, 1)
XCTAssertEqual(mockAsset.symbol, Asset.Symbol.sbd)
XCTAssertEqual(mockAsset.symbol, Asset.Symbol.viz)
XCTAssertEqual(mockAsset.resolvedAmount, 0.001)
}
func testEquateable() {
let mockAsset = Asset(0.1, .sbd)
let mockAsset2 = Asset(0.1, .steem)
let mockAsset3 = Asset(0.1, .sbd)
let mockAsset4 = Asset(0.2, .sbd)
XCTAssertFalse(mockAsset == mockAsset2)
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))
let mockAsset1 = Asset(0.1, .viz)
let mockAsset2 = Asset(0.1, .vests)
let mockAsset3 = Asset(0.1, .viz)
XCTAssertFalse(mockAsset1 == mockAsset2)
XCTAssertTrue(mockAsset1 == mockAsset3)
}
func testDecodable() throws {
AssertDecodes(string: "10.000 STEEM", Asset(10, .steem))
AssertDecodes(string: "0.001 SBD", Asset(0.001, .sbd))
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: "10.000 VIZ", Asset(10, .viz))
AssertDecodes(string: "0.001 VIZ", Asset(0.001, .viz))
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
let base64_base58_pairs = [

4
Tests/UnitTests/Block.swift
View File

@ -1,5 +1,5 @@
import Foundation
@testable import Steem
@testable import VIZ
import XCTest
class BlockTest: XCTestCase {
@ -10,7 +10,7 @@ class BlockTest: XCTestCase {
XCTAssertEqual(block.witnessSignature, Signature("1f26706cb7da8528a303f55c7e260b8b43ba2aaddb2970d01563f5b1d1dc1d8e0342e4afe22e95277d37b4e7a429df499771f8db064e64aa964a0ba4a17a18fb2b"))
XCTAssertEqual(block.timestamp, Date(timeIntervalSince1970: 1_464_911_925))
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")
AssertEncodes(block, [
"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 XCTest
@testable import Steem
@testable import VIZ
class ChainIdTest: XCTestCase {
func testEncodeCustomChainId() {
@ -20,6 +13,6 @@ class ChainIdTest: XCTestCase {
}
func testMainnetId() {
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
@testable import Steem
@testable import VIZ
import XCTest
fileprivate class TestTask: SessionDataTask {
@ -134,28 +134,28 @@ class ClientTest: XCTestCase {
}
}
func testRpcError() {
let test = expectation(description: "Handler called")
session.nextResponse = jsonResponse(["id": 42, "error": ["code": 123, "message": "Had some issues", "data": ["extra": 123]]])
client.send(TestRequest()) { response, error in
XCTAssertNotNil(error)
XCTAssertNil(response)
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 {
XCTAssertEqual(code, 123)
XCTAssertEqual(message, "Had some issues")
XCTAssertEqual(data as? [String: Int], ["extra": 123])
} else {
XCTFail()
}
test.fulfill()
}
waitForExpectations(timeout: 2) { error in
if let error = error {
print("Error: \(error.localizedDescription)")
}
}
}
// func testRpcError() {
// let test = expectation(description: "Handler called")
// session.nextResponse = jsonResponse(["id": 42, "error": ["code": 123, "message": "Had some issues", "data": ["extra": 123]]])
// client.send(TestRequest()) { response, error in
// XCTAssertNotNil(error)
// XCTAssertNil(response)
// 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 {
// XCTAssertEqual(code, 123)
// XCTAssertEqual(message, "Had some issues")
// XCTAssertEqual(data as? [String: Int], ["extra": 123])
// } else {
// XCTFail()
// }
// test.fulfill()
// }
// waitForExpectations(timeout: 2) { error in
// if let error = error {
// print("Error: \(error.localizedDescription)")
// }
// }
// }
func testSeqIdGenerator() {
var gen = SeqIdGenerator()

6
Tests/UnitTests/Common.swift
View File

@ -1,5 +1,5 @@
import Foundation
@testable import Steem
@testable import VIZ
import XCTest
extension Data: LosslessStringConvertible {
@ -42,9 +42,9 @@ func TestEncode<T: Encodable>(_ value: T) throws -> Any {
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 {
let encoded = try SteemEncoder.encode(value)
let encoded = try VIZEncoder.encode(value)
XCTAssertEqual(encoded.hexEncodedString(), expected.hexEncodedString(), file: file, line: line)
} catch {
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
fileprivate let vote = (
@ -7,28 +7,28 @@ fileprivate let vote = (
)
fileprivate let transfer = (
Operation.Transfer(from: "foo", to: "bar", amount: Asset(10, .steem), memo: "baz"),
"{\"from\":\"foo\",\"to\":\"bar\",\"amount\":\"10.000 STEEM\",\"memo\":\"baz\"}"
Operation.Transfer(from: "foo", to: "bar", amount: Asset(10, .viz), memo: "baz"),
"{\"from\":\"foo\",\"to\":\"bar\",\"amount\":\"10.000 VIZ\",\"memo\":\"baz\"}"
)
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)])]),
"{\"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}]}]]}"
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 VIZ\",\"percent_steem_dollars\":41840,\"allow_votes\":true,\"allow_curation_rewards\":true,\"extensions\":[[0,{\"beneficiaries\":[{\"account\":\"baz\",\"weight\":5000}]}]]}"
)
let account_create = (
Operation.AccountCreate(
fee: Asset("10.000 STEEM")!,
creator: "steem",
fee: Asset("10.000 VIZ")!,
creator: "viz",
newAccountName: "paulsphotography",
owner: Authority(weightThreshold: 1, accountAuths: [], keyAuths: [[PublicKey("STM8LMF1uA5GAPfsAe1dieBRATQfhgi1ZqXYRFkaj1WaaWx9vVjau")!: 1]]),
active: Authority(weightThreshold: 1, accountAuths: [], keyAuths: [[PublicKey("STM56WPHZKvxoHpjQh69XakuoE5czuewrTDYeUBsQNKjnq3a6bbh6")!: 1]]),
posting: Authority(weightThreshold: 1, accountAuths: [], keyAuths: [[PublicKey("STM5oPsxWgfCH2FWqcXBWeeMmZoyBY5baiuV1vQWMxVVpYxEsJ6Hx")!: 1]]),
memoKey: PublicKey("STM7SSqMsrCqNZ3NdJLwWqC2u5PQ66JB2uCCs6ee5NFFqXxxB46AH")!,
master: Authority(weightThreshold: 1, accountAuths: [], keyAuths: [[PublicKey("VIZ8LMF1uA5GAPfsAe1dieBRATQfhgi1ZqXYRFkaj1WaaWx9vVjau")!: 1]]),
active: Authority(weightThreshold: 1, accountAuths: [], keyAuths: [[PublicKey("VIZ56WPHZKvxoHpjQh69XakuoE5czuewrTDYeUBsQNKjnq3a6bbh6")!: 1]]),
regular: Authority(weightThreshold: 1, accountAuths: [], keyAuths: [[PublicKey("VIZ5oPsxWgfCH2FWqcXBWeeMmZoyBY5baiuV1vQWMxVVpYxEsJ6Hx")!: 1]]),
memoKey: PublicKey("VIZ7SSqMsrCqNZ3NdJLwWqC2u5PQ66JB2uCCs6ee5NFFqXxxB46AH")!,
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\":\"\"}",
Data("102700000000000003535445454d000005737465656d107061756c7370686f746f67726170687901000000000103c5ce92a15f7120ae896f348c4ce505d9573cf0816338a478dd9845fe7b1ec59b0100010000000001021b49b04b2406912fbd4a183512b3cdf72c215eba13ceb0c9700db4fbef1dc2570100010000000001027820f0c756d3bc57ce05547fe828d20e03b7fc74e8e4968f984e38b3e26449cb0100034ff417d40dae1849b2187ebd4514b8068db851b73bee6f4c7903e7c8677059ef00")
"{\"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("10270000000000000356495a000000000376697a107061756c7370686f746f67726170687901000000000103c5ce92a15f7120ae896f348c4ce505d9573cf0816338a478dd9845fe7b1ec59b0100010000000001021b49b04b2406912fbd4a183512b3cdf72c215eba13ceb0c9700db4fbef1dc2570100010000000001027820f0c756d3bc57ce05547fe828d20e03b7fc74e8e4968f984e38b3e26449cb0100034ff417d40dae1849b2187ebd4514b8068db851b73bee6f4c7903e7c8677059ef00")
)
class OperationTest: XCTestCase {
@ -36,9 +36,9 @@ class OperationTest: XCTestCase {
AssertEncodes(vote.0, Data("03666f6f036261720362617ae803"))
AssertEncodes(vote.0, ["voter": "foo", "author": "bar", "permlink": "baz"])
AssertEncodes(vote.0, ["weight": 1000])
AssertEncodes(transfer.0, Data("03666f6f03626172102700000000000003535445454d00000362617a"))
AssertEncodes(transfer.0, ["from": "foo", "to": "bar", "amount": "10.000 STEEM", "memo": "baz"])
AssertEncodes(commentOptions.0, Data("03666f6f036261721027000000000000035342440000000070a301010100010362617a8813"))
AssertEncodes(transfer.0, Data("03666f6f0362617210270000000000000356495a000000000362617a"))
AssertEncodes(transfer.0, ["from": "foo", "to": "bar", "amount": "10.000 VIZ", "memo": "baz"])
AssertEncodes(commentOptions.0, Data("03666f6f0362617210270000000000000356495a0000000070a301010100010362617a8813"))
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
class PrivateKeyTest: XCTestCase {
@ -15,7 +15,7 @@ class PrivateKeyTest: XCTestCase {
XCTAssertNil(PrivateKey("5HsQCyqCw61VPQ9tN4ttasHW3AH6cJ6tJdneAXR8gUJ2MWyxxpa"))
XCTAssertNil(PrivateKey("5HsQCyqCw61VPQ6tN4ttasHW3AH6cJ6tJdneAXR8gUJ2MWyxxpA"))
XCTAssertNil(PrivateKey(Data()))
XCTAssertNil(PrivateKey(Data(bytes: [0x80])))
XCTAssertNil(PrivateKey(Data([0x80])))
}
func testEquatable() {
@ -34,8 +34,8 @@ class PrivateKeyTest: XCTestCase {
func testCreatePublic() {
if let key = PrivateKey("5HsQCyqCw61VPQ9tN4ttasHW3AH6cJ6tJdneAXR8gUJ2MWyxxpA") {
XCTAssertEqual(key.createPublic(), PublicKey("STM6BohVaUq55WgAD38pYVMZE4oxmoX7hAgxsni5EdNdgaKJ8FQDR"))
XCTAssertEqual(key.createPublic(prefix: .testNet), PublicKey("TST6BohVaUq55WgAD38pYVMZE4oxmoX7hAgxsni5EdNdgaKJ8FQDR"))
XCTAssertEqual(key.createPublic(), PublicKey("VIZ6BohVaUq55WgAD38pYVMZE4oxmoX7hAgxsni5EdNdgaKJ8FQDR"))
// XCTAssertEqual(key.createPublic(prefix: .testNet), PublicKey("VIZ6BohVaUq55WgAD38pYVMZE4oxmoX7hAgxsni5EdNdgaKJ8FQDR"))
XCTAssertEqual(key.createPublic(prefix: "FOO"), PublicKey("FOO6BohVaUq55WgAD38pYVMZE4oxmoX7hAgxsni5EdNdgaKJ8FQDR"))
} else {
XCTFail("Unable to decode WIF")

18
Tests/UnitTests/PublicKey.swift
View File

@ -1,12 +1,12 @@
@testable import Steem
@testable import VIZ
import XCTest
class PublicKeyTest: XCTestCase {
func testKey() {
if let key = PublicKey("STM6672Ei8X4yMfDmEhBD66xfpG177qrbuic8KpUe1GVV9GVGovcv") {
XCTAssertEqual(String(key), "STM6672Ei8X4yMfDmEhBD66xfpG177qrbuic8KpUe1GVV9GVGovcv")
if let key = PublicKey("VIZ6LiKWipnNoBSDafStzSUgo9ihGawo25WW9kMvfTpGMwKp2qfG9") {
XCTAssertEqual(String(key), "VIZ6LiKWipnNoBSDafStzSUgo9ihGawo25WW9kMvfTpGMwKp2qfG9")
XCTAssertEqual(key.prefix, .mainNet)
XCTAssertEqual(key.prefix, "STM")
XCTAssertEqual(key.prefix, "VIZ")
} else {
XCTFail("Unable to decode key")
}
@ -16,16 +16,6 @@ class PublicKeyTest: XCTestCase {
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() {
if let key = PublicKey("XXX7yFRm6aoShU2d75oCjU7boRu4TBSwEhVtH3cnU5ZH2vQ9qXspN") {
XCTAssertEqual(String(key), "XXX7yFRm6aoShU2d75oCjU7boRu4TBSwEhVtH3cnU5ZH2vQ9qXspN")

2
Tests/UnitTests/Secp256k1.swift
View File

@ -1,4 +1,4 @@
@testable import Steem
@testable import VIZ
import XCTest
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
class Sha2Test: XCTestCase {

4
Tests/UnitTests/Signature.swift
View File

@ -1,4 +1,4 @@
@testable import Steem
@testable import VIZ
import XCTest
fileprivate let sig = Signature(
@ -18,6 +18,6 @@ class SignatureTest: XCTestCase {
}
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
class TransactionTest: XCTestCase {
@ -11,29 +11,29 @@ class TransactionTest: XCTestCase {
}
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)
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.refBlockPrefix, 1_122_334_455)
XCTAssertEqual(initTx.expiration, Date(timeIntervalSince1970: 0))
XCTAssertEqual(initTx.operations.count, 1)
let transfer = initTx.operations.first as? Steem.Operation.Transfer
XCTAssertEqual(transfer, Steem.Operation.Transfer(from: "foo", to: "bar", amount: Asset(10, .steem), memo: "baz"))
let transfer = initTx.operations.first as? VIZ.Operation.Transfer
XCTAssertEqual(transfer, VIZ.Operation.Transfer(from: "foo", to: "bar", amount: Asset(10, .viz), memo: "baz"))
}
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)
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.refBlockPrefix, 1_122_334_455)
XCTAssertEqual(initTx.expiration, Date(timeIntervalSince1970: 0))
XCTAssertEqual(initTx.operations.count, 0)
initTx.append(operation: transferOp)
XCTAssertEqual(initTx.operations.count, 1)
let transfer = initTx.operations.first as? Steem.Operation.Transfer
XCTAssertEqual(transfer, Steem.Operation.Transfer(from: "foo", to: "bar", amount: Asset(10, .steem), memo: "baz"))
let transfer = initTx.operations.first as? VIZ.Operation.Transfer
XCTAssertEqual(transfer, VIZ.Operation.Transfer(from: "foo", to: "bar", amount: Asset(10, .viz), memo: "baz"))
}
func testDecodable() throws {
@ -43,10 +43,10 @@ class TransactionTest: XCTestCase {
XCTAssertEqual(tx.expiration, Date(timeIntervalSince1970: 0))
XCTAssertEqual(tx.extensions.count, 0)
XCTAssertEqual(tx.operations.count, 2)
let vote = tx.operations.first as? Steem.Operation.Vote
let transfer = tx.operations.last as? Steem.Operation.Transfer
XCTAssertEqual(vote, Steem.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"))
let vote = tx.operations.first as? VIZ.Operation.Vote
let transfer = tx.operations.last as? VIZ.Operation.Transfer
XCTAssertEqual(vote, VIZ.Operation.Vote(voter: "foo", author: "bar", permlink: "baz", weight: 1000))
XCTAssertEqual(transfer, VIZ.Operation.Transfer(from: "foo", to: "bar", amount: Asset(10, .viz), memo: "baz"))
}
func testSigning() throws {
@ -55,19 +55,19 @@ class TransactionTest: XCTestCase {
}
let operations: [OperationType] = [
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 transaction = Transaction(refBlockNum: 0, refBlockPrefix: 0, expiration: expiration, operations: operations)
AssertEncodes(transaction, Data("00000000000000000000020003666f6f03666f6f0362617ae8030203666f6f03626172102700000000000003535445454d00000362617a00"))
XCTAssertEqual(try transaction.digest(forChain: .mainNet), Data("44424a1259aba312780ca6957a91dbd8a8eef8c2c448d89eccee34a425c77512"))
AssertEncodes(transaction, Data("00000000000000000000020003666f6f03666f6f0362617ae8030203666f6f0362617210270000000000000356495a000000000362617a00"))
// XCTAssertEqual(try transaction.digest(forChain: .mainNet), Data("44424a1259aba312780ca6957a91dbd8a8eef8c2c448d89eccee34a425c77512"))
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)
try signedTransaction.appendSignature(usingKey: key, forChain: .custom(customChain))
XCTAssertEqual(signedTransaction.signatures, [
Signature("20598c2f2301db5559d42663f8f79cbc4258697cd645b6df56be2e83d786a66590437acf0041bda94c4ff4d8e5bce0ac1765a2c32bd796cb1d002081e4a5f8691a"),
Signature("1f15c78daabdbc30866897f7d01d61ba385b599f1438fe8b501ee4982eaba969f371474d0c4bd6ed927d74f5e94f59565506bdf4478400d5fe2330f61473d6ae8f"),
Signature("202d2588ff712d543dfa0febfc90ae52266fb2c6bddd1b796d658c687f0382de621ec0afc5614c723cdd64329a485bc9ce5c93ecdb7dd05b3dfe1d056c3856d9ae"),
Signature("200c74be0f0c74302efd661deb1014422218fb9704d88cf5f0b59c9c1b44c42d5761e165968959ba6f25ff4a2c0dae3693ea62a761bdd4caa260a0cad32f93bc14"),
])
}
}
@ -80,7 +80,7 @@ fileprivate let txJson = """
"extensions": [],
"operations": [
["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
@testable import Steem
@testable import VIZ
import XCTest
class SteemEncoderTest: XCTestCase {
class VIZEncoderTest: XCTestCase {
func testFixedWidthInteger() {
AssertEncodes(0 as Int8, Data("00"))
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
fileprivate let sig = Signature(
@ -6,12 +6,12 @@ fileprivate let sig = Signature(
recoveryId: 1
)
class SeemURLTest: XCTestCase {
class VIZURLTest: XCTestCase {
func testEncodeDecode() {
let url = SteemURL(operation: Operation.Vote(voter: "foo", author: "bar", permlink: "baz"))
XCTAssertEqual(url?.url?.absoluteString, "steem://sign/op/WyJ2b3RlIix7InZvdGVyIjoiZm9vIiwiYXV0aG9yIjoiYmFyIiwicGVybWxpbmsiOiJiYXoiLCJ3ZWlnaHQiOjEwMDAwfV0.")
XCTAssertEqual(url, SteemURL(string: "steem://sign/op/WyJ2b3RlIix7InZvdGVyIjoiZm9vIiwiYXV0aG9yIjoiYmFyIiwicGVybWxpbmsiOiJiYXoiLCJ3ZWlnaHQiOjEwMDAwfV0."))
let options = SteemURL.ResolveOptions(refBlockNum: 0, refBlockPrefix: 1, expiration: Date(timeIntervalSinceReferenceDate: 0), signer: "foo")
let url = VIZURL(operation: Operation.Vote(voter: "foo", author: "bar", permlink: "baz"))
XCTAssertEqual(url?.url?.absoluteString, "viz://sign/op/WyJ2b3RlIix7InZvdGVyIjoiZm9vIiwiYXV0aG9yIjoiYmFyIiwicGVybWxpbmsiOiJiYXoiLCJ3ZWlnaHQiOjEwMDAwfV0.")
// XCTAssertEqual(url, VIZURL(string: "viz://sign/op/WyJ2b3RlIix7InZvdGVyIjoiZm9vIiwiYXV0aG9yIjoiYmFyIiwicGVybWxpbmsiOiJiYXoiLCJ3ZWlnaHQiOjEwMDAwfV0."))
let options = VIZURL.ResolveOptions(refBlockNum: 0, refBlockPrefix: 1, expiration: Date(timeIntervalSinceReferenceDate: 0), signer: "foo")
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: []))
}
@ -19,26 +19,26 @@ class SeemURLTest: XCTestCase {
func testParams() throws {
let operations: [OperationType] = [
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.callback = "https://example.com/sign?sig={{sig}}"
params.noBroadcast = true
let url = SteemURL(operations: operations, params: params)
let url = VIZURL(operations: operations, params: params)
XCTAssertNotNil(url)
let ops = try url?.getOperations()
XCTAssertEqual(ops?[0] as? Steem.Operation.Vote, (operations[0] as! Steem.Operation.Vote))
XCTAssertEqual(ops?[1] as? Steem.Operation.Transfer, (operations[1] as! Steem.Operation.Transfer))
let options = SteemURL.ResolveOptions(refBlockNum: 0, refBlockPrefix: 1, expiration: Date(timeIntervalSinceReferenceDate: 0), signer: "baz")
XCTAssertEqual(ops?[0] as? VIZ.Operation.Vote, (operations[0] as! VIZ.Operation.Vote))
XCTAssertEqual(ops?[1] as? VIZ.Operation.Transfer, (operations[1] as! VIZ.Operation.Transfer))
let options = VIZURL.ResolveOptions(refBlockNum: 0, refBlockPrefix: 1, expiration: Date(timeIntervalSinceReferenceDate: 0), signer: "baz")
let result = try url?.resolve(with: options)
XCTAssertEqual(result, Transaction(refBlockNum: 0, refBlockPrefix: 1, expiration: Date(timeIntervalSinceReferenceDate: 0), operations: operations, extensions: []))
let ctx = SteemURL.CallbackContext(signature: sig)
let cbUrl = url?.resolveCallback(with: ctx)
XCTAssertEqual(cbUrl?.absoluteString, "https://example.com/sign?sig=207a6fa349f1f624643119f667f394a435c1d31d6f39d8191389305e519a0c051222df037180dc86e00ca4fe43ab638f1e8a96403b3857780abaad4017e03d1ef0")
XCTAssertEqual(url?.description, "steem://sign/ops/W1sidm90ZSIseyJ2b3RlciI6ImZvbyIsImF1dGhvciI6ImJhciIsInBlcm1saW5rIjoiYmF6Iiwid2VpZ2h0IjoxMDAwMH1dLFsidHJhbnNmZXIiLHsiYW1vdW50IjoiMTAuMDAwIFNURUVNIiwibWVtbyI6ImJheiIsInRvIjoiYmFyIiwiZnJvbSI6ImZvbyJ9XV0.?cb=aHR0cHM6Ly9leGFtcGxlLmNvbS9zaWduP3NpZz17e3NpZ319&nb&s=foo")
let reparsed = SteemURL(string: "steem://sign/ops/W1sidm90ZSIseyJ2b3RlciI6ImZvbyIsImF1dGhvciI6ImJhciIsInBlcm1saW5rIjoiYmF6Iiwid2VpZ2h0IjoxMDAwMH1dLFsidHJhbnNmZXIiLHsiYW1vdW50IjoiMTAuMDAwIFNURUVNIiwibWVtbyI6ImJheiIsInRvIjoiYmFyIiwiZnJvbSI6ImZvbyJ9XV0.?cb=aHR0cHM6Ly9leGFtcGxlLmNvbS9zaWduP3NpZz17e3NpZ319&nb&s=foo")
XCTAssertEqual(reparsed, url)
XCTAssertEqual(reparsed?.params, url?.params)
// let ctx = VIZURL.CallbackContext(signature: sig)
// let cbUrl = url?.resolveCallback(with: ctx)
// XCTAssertEqual(cbUrl?.absoluteString, "https://example.com/sign?sig=207a6fa349f1f624643119f667f394a435c1d31d6f39d8191389305e519a0c051222df037180dc86e00ca4fe43ab638f1e8a96403b3857780abaad4017e03d1ef0")
// XCTAssertEqual(url?.description, "viz://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?.params, url?.params)
}
}

10
Tests/UnitTests/XCTestManifests.swift
View File

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