Swift SDK

public func execute() -> Result<T, ICError>

// Synchronized request execution
let response = iconService.getLastBlock().execute()
 
switch response {
case .success(let block):
    print(block)
case .failure(let error):
    print(error.errorDescription)
}

public func async(_ completion: @escaping (Result<T, ICError>) -> Void)

// Asynchronized request execution
iconService.getLastBlock().async { (result) in
    switch result {
    case .success(let block):
      print(block)
    case .failure(let error):
      print(err.errorDescription)
    }
}

// Synchronized request
let response = iconService.sendTransaction(signedTransaction: signed).execute()
 
switch response {
case .success(let result): // result == String
    print(result)
case .error(let error):
    print(error)
}
 
// Asynchronized request
let request = iconService.sendTransaction(signedTransaction: signed)
request.async { (result) in
    switch result {
    case .success(let result): // result == String
        print(result)
    case .failure(let error):
        print(error)
    }
}

init(provider: String, nid: String)

// ICON Mainnet
let iconService = ICONService(provider: "https://ctz.solidwallet.io/api/v3", nid: "0x1")

func getLastBlock() -> Request<Response.Block>

// Returns last block
let response = iconService.getLastBlock().execute()
 
switch response {
case .success(let result): // result == Response.Block
    print(result)
case .error(let error):
    print(error)
}

// Get block information by height.
func getBlock(height: UInt64) -> Request<Response.Block>
 
// Get block information by hash.
func getBlock(hash: String) -> Request<Response.Block>

// Returns block information by block height
let heightBlock = iconService.getBlock(height: 10532).execute()
 
// Returns block information by block hash
let hashBlock = iconService.getBlock(hash: "0xdb310dd653b2573fd673ccc7489477a0b697333f77b3cb34a940db67b994fd95").execute()
 
switch heightBlock {
case .success(let block): // result == Response.Block
    print(block)
case .error(let error):
    print(error)
}

func call<T>(_ call: Call<T>) -> Request<T>

// Create Call instance
let call = Call<String>(from: wallet.address, to: "cxf9148db4f8ec78823a50cb06c4fed83660af38d0", method: "tokenOwner", params: nil)
 
let request: Request<String> = iconService.call(call)
let response: Result<String, ICError> = request.execute()
 
switch response {
case .success(let owner):
     print(owner) // hx70b591822468415e86fb9ba1354214902ea76196
case .failure(let error):
    print(error)
}

let ownerAddress: String = "hx07abc7a5b8a4941fc0b6930c88b462995acf929b"
let scoreAddress: String = "cxf9148db4f8ec78823a50cb06c4fed83660af38d0"
 
// Using `String`. Return hex String.
let call = Call<String>(from: ownerAddress, to: scoreAddress, method: "balanceOf", params: ["_owner": ownerAddress])
let request: Request<String> = iconService.call(call)
let response: Result<String, ICError> = request.execute()
 
switch response {
case .success(let balance):
     print("balance: \(balance)") // "balance: 0x11e468ef422cc60031ef"
case .failure(let error):
    print(error)
}
 
 
// Using `BigUInt`. Return BigUInt.
let call = Call<BigUInt>(from: ownerAddress, to: scoreAddress, method: "balanceOf", params: ["_owner": ownerAddress])
let request: Request<BigUInt> = iconService.call(call)
let response: Result<BigUInt, ICError> = request.execute()
 
switch response {
case .success(let balance):
     print("balance: \(balance)") // "balance: 84493649192649192649199"
case .failure(let error):
    print(error)
}

func getBalance(address: String) -> Request<BigUInt>

// Returns the balance of specific address
let response = iconService.getBalance(address: "hx9d8a8376e7db9f00478feb9a46f44f0d051aab57").execute()
 
switch response {
case .success(let result): // result == BigUInt
    print(result)
case .error(let error):
    print(error)
}

func getScoreAPI(scoreAddress: String) -> Request<[Response.ScoreAPI]>

// Returns the SCORE API list
let response = iconService.getScoreAPI(scoreAddress: "cx0000000000000000000000000000000000000001").execute()
 
switch response {
case .success(let result): // result == [Response.ScoreAPI]
    print(result)
case .error(let error):
    print(error)
}

func getTotalSupply() -> Request<BigUInt>

// Returns total value of issued coins
let response = iconService.getTotalSupply().execute()
 
switch response {
case .success(let result): // result == BigUInt
    print(result)
case .error(let error):
    print(error)
}

func getTransaction(hash: String) -> Request<Response.TransactionByHashResult>

// Returns transaction information
let response = iconService.getTransaction(hash: "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238").execute()
 
switch response {
case .success(let result): // result == Response.TransactionByHashResult
    print(result)
case .error(let error):
    print(error)
}

func getTransactionResult(hash: String) -> Request<Response.TransactionResult>

// Returns transaction result information
let response = iconService.getTransactionResult(hash: "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238").execute()
 
switch response {
case .success(let result): // result == Response.TransactionResult
    print(result)
case .error(let error):
    print(error)
}

func sendTransaction(signedTransaction: SignedTransaction) -> Request<String>

// Synchronized request
let response = iconService.sendTransaction(signedTransaction: signed).execute()
 
switch response {
case .success(let result): // result == String
    print(result)
case .error(let error):
    print(error)
}
 
// Asynchronized request
let request = iconService.sendTransaction(signedTransaction: signed)
request.async { (result) in
    switch result {
    case .success(let result): // result == String
        print(result)
    case .failure(let error):
        print(error)
    }
}

class Wallet

init(privateKey: PrivateKey?)

// Create new wallet
let wallet = Wallet(prviateKey: nil)    // will generate private key
 
// Imports from exist private key
let privateKey = PrivateKey(hexData: privateKeyData)
let wallet = Wallet(privateKey: privateKey)

// Loading wallets and storing the Keystore
 
// Save wallet keystore.
let wallet = Wallet(privateKey: nil)
do {
    try wallet.generateKeystore(password: "YOUR_WALLET_PASSWORD")
    try wallet.save(filepath: "YOUR_STORAGE_PATH")
} catch {
    // handle errors
}
 
// Load a wallet from the keystore.
do {
    let jsonData: Data = try Data(contentsOf: "YOUR_KEYSTORE_PATH")
    let decoder = JSONDecoder()
    let keystore = try decoder.decoder(Keystore.self, from: jsonData)
    let wallet = Wallet(keystore: keystore, password: "YOUR_WALLET_PASSWORD")
} catch {
    // handle errors
}

func getSignature(data: Data) throws -> String

let wallet = Wallet(privateKey: nil)
do {
    let signature = try wallet.getSignature(data: toBeSigned)
    print("signature - \(signature)")
} catch {
    // handle error
}

class Transaction

// Create empty transaction object
init()
// Create transaction with data
convenience init(from: String, to: String, stepLimit: BigUInt, nid: String, value: BigUInt, nonce: String, dataType: String? = nil, data: Any? = nil)

func from(_ from: String) -> Self

// Set from property
let transaction = Transaction()
        .from("hx9043346dbaa72bca42ecec6b6e22845a4047426d")

func to(_ to: String) -> Self

let transaction = Transaction()
        .to("hx2e26d96bd7f1f46aac030725d1e302cf91420458")

func stepLimit(_ limit: BigUInt) -> Self

let transaction = Transaction()
        .stepLimit(BigUInt(1000000))

func nid(_ nid: String) -> Self

let transaction = Transaction()
        .nid("0x1")

func value(_ value: BigUInt) -> Self

let transaction = Transaction()
    .value(BigUInt(15000000))

func nonce(_ nonce: String) -> Self

let transaction = Transaction()
    .nonce("0x1")

// Creating transaction instance for Sending ICX.
let transaction = Transaction()
    .from("hx9043346dbaa72bca42ecec6b6e22845a4047426d")
    .to("hx2e26d96bd7f1f46aac030725d1e302cf91420458")
    .value(BigUInt(15000000))
    .stepLimit(BigUInt(1000000))
    .nid("0x1")
    .nonce("0x1")

class CallTransaction: Transaction

func method(_ method: String) -> Self

func params(_ params: [String: Any]) -> Self

// Creating transaction instance for SCORE function call
let call = CallTransaction()
    .from(wallet.address)
    .to("cx000...001")
    .stepLimit(BigUInt(1000000))
    .nid(self.iconService.nid)
    .nonce("0x1")
    .method("transfer")
    .params(["_to": to, "_value": "0x1234"])

class MessageTransaction: Transaction

func message(_ message: String) -> Self

// Creating transaction instance for transfering message.
let messageTransaction = MessageTransaction()
    .from("hx9043346dbaa72bca42ecec6b6e22845a4047426d")
    .to("hx2e26d96bd7f1f46aac030725d1e302cf91420458")
    .value(BigUInt(15000000))
    .stepLimit(BigUInt(1000000))
    .nonce("0x1")
    .nid("0x1")
    .message("Hello, ICON!")

init(transaction: Transaction, privateKey: PrivateKey)

let signed = try SignedTransaction(transaction: transaction, privateKey: yourPrivateKey)

let balance: BigUInt = 100
 
// Convert ICX to loop.
let ICXToLoop: BigUInt = balance.convert() // 100000000000000000000
 
// Convert gLoop to loop
let gLoopToLoop: BigUInt = balance.convert(unit: .gLoop) // 100000000000

public func toHexString(unit: Unit = .loop) -> String

// Convert `BigUInt` value to hex `String`.
let ICXToLoop: BigUInt = 100000000000000000000
let hexString: String = ICXToLoop.toHexString() // 0x56bc75e2d63100000

public func hexToBigUInt(unit: Unit = .loop) -> BigUInt?

// Convert hex `String` to `BigUInt`.
let hexString: String = "0x56bc75e2d63100000"
let hexBigUInt: BigUInt = hexString.hexToBigUInt()! // 100000000000000000000