For AI agents: a documentation index is available at /llms.txt. A markdown version of this page is available at the same URL with .md appended (or via Accept: text/markdown).
Skip to main content

Integrate Embedded Wallets with the Bitkub Blockchain in iOS/Swift Applications

While using the Embedded Wallets iOS SDK, you get the private key within the user scope after successful authorization. This private key can be used to retrieve the user's address, and interact with Bitkub to make any blockchain calls..

Chain details for Bitkub​

  • Chain ID: 0x60
  • Public RPC URL: https://rpc.bitkubchain.io
  • Display Name: Bitkub Chain Mainnet
  • Block Explorer Link: https://www.bkcscan.com
  • Ticker: KUB
  • Ticker Name: Bitkub Coin

Prerequisites​

Installation​

To interact with the Ethereum compatible blockchains in Swift, you can use any EIP1193 compatible package. Here, we're using web3swift to demonstrate how to make blockchain calls using it with Web3Auth.

To install the web3swift package, you have two options. You can either use Swift Package Manager or CocoaPods.

  1. In Xcode, with your app project open, navigate to File > Add Packages.

  2. When prompted, add the single-factor-auth-swift iOS SDK repository:

    https://github.com/argentlabs/web3.swift

  3. When finished, Xcode will automatically begin resolving and downloading your dependencies in the background.

Initialize​

Initialize the EthereumHttpClient with the RPC URL and chain id of the network you want to connect to, to interact with the blockchain. To get the public RPC URL, and other details as chain id, see ChainList.

import web3

let client = EthereumHttpClient(
    // Please avoid using public RPC URL in production, use services
    // like Infura.
    url: URL.init(string: rpcUrl)!,
    // Replace with the chain id of the network you want to connect to
    network: .custom(chainId)
)

Get account​

Use the EthereumAccount class to retrieve the user's Ethereum address. This account can also be used to sign transactions and messages.

The package doesn't provides any direct way to consume the the private key and create an account. Hence, we'll create an extension for the Web3AuthState extending the EthereumSingleKeyStorageProtocol to retrieve the private key and create an account.

import web3
import Web3Auth

extension Web3AuthState: EthereumSingleKeyStorageProtocol {
    public func storePrivateKey(key: Data) throws {

    }

    public func loadPrivateKey() throws -> Data {
        guard let data = self.privKey?.web3.hexData else {
            throw PlaygroundError.decodingError
        }

        return data
    }
}

Once we have created the extension, we can use the Web3AuthState to create an EthereumAccount. Please note, that this assumes that the user has already logged in and the state is available.

import web3

// Use your existing Web3Auth instance
let web3authState = web3Auth.state!

let account = try EthereumAccount(keyStorage: web3authState)
let address = account.address

Get balance​

Use the EthereumClient.eth_getBalance method to retrieve the balance of an Ethereum address.

The result we get from Web3Client is in wei, the smallest unit of ether. To convert wei to ether, divide by 10^18, where 18 denotes the decimals for wei.

import web3

let etherInWei = pow(Double(10), 18)

/// Convert Wei(BInt) unit to Ether(Decimal) unit
public func toEther(wei: Wei) -> Ether {
    guard let decimalWei = Double(wei.description) else {
        return 0
    }
    return decimalWei / etherInWei
}

let balanceResponse = try await client.eth_getBalance(
    // Use the address from previous step
    address: address,
    block: .Latest
)

let balance = toEther(wei: balanceResponse)

Sign a message​

To sign the message, you can use the EthereumAccount.sign method. The sign method takes in the data of the message, and returns the signature.

import web3

let message = "Hello World"
// Use the account from previous step
guard let data = message.data(using: .ascii) else {
    // throw error
}

let signature = try ethereumAccount.signMessage(message: data)

Send transaction​

For signing and sending the transaction, we'll create helper methods to get the nonce, gas price, estimate the gas and send the transaction:

  • nonce is the number of transactions sent from the sender's address
  • gas price is the unit of account for the transaction
  • gas limit is the maximum amount of gas that the sender is willing to pay for the transaction

The gas values are in ether. We'll also create a helper method to convert the amount to wei.

Once the transaction object is created, we'll estimate the gas and create a new transaction object with the gas limit. Finally, we'll send the transaction using EthereumHttpClient.eth_sendRawTransaction method and get the hash.

import web3

private let etherInWei = pow(Double(10), 18)

private func getNonce() async throws -> Int {
    let nonce = try await client.eth_getTransactionCount(address: account.address, block: .Latest)
    return nonce
}

private func getGasPrice() async throws -> BigUInt {
    return try await client.eth_gasPrice()
}

private func estimateGas(ethereumTransaction: EthereumTransaction) async throws -> BigUInt {
    return try await client.eth_estimateGas(ethereumTransaction)
}

public func toWei(ether: Ether) -> Wei {
    let wei = Wei(ether * etherInWei)
    return wei
}

let nonce = try await getNonce()
let gasPrice = try await getGasPrice()

// Convert the amount to Wei
let value = toWei(ether: Ether(floatLiteral: 0.001))

let ethereumTransaction = EthereumTransaction(
    // Use the account from previous step
    from: account.address,
    to: EthereumAddress.init(stringLiteral: "RECIPIENT_ADDRESS_IN_HEX_FORMAT"),
    value: value,
    // Empty data, 0x
    data: Data(),
    nonce: nonce,
    gasPrice: gasPrice,
    gasLimit: nil,
    // Use the chain id from previous step
    chainId: CHAIN_ID_IN_INTEGER
)

// Estimate the gas
let gasLimit = try await estimateGas(ethereumTransaction: ethereumTransaction)

let transaction = EthereumTransaction(
    // Use the account from previous step
    from: account.address,
    to: EthereumAddress.init(stringLiteral: "RECIPIENT_ADDRESS_IN_HEX_FORMAT"),
    value: value,
    // Empty data, 0x
    data: Data(),
    nonce: nonce,
    gasPrice: gasPrice,
    gasLimit: gasLimit,
    // Use the chain id from previous step
    chainId: CHAIN_ID_IN_INTEGER
)

// Use the account from previous step
let hash = try await client.eth_sendRawTransaction(transaction, withAccount: account)
On this page