TzKTClient Class Reference

TzKTServiceError
Unique Errors that TzKTClient can throw
See more
Declaration
Swift

public enum TzKTServiceError : Error
Constants
Constants needed for interacting with the API
See more
Declaration
Swift

public struct Constants
isListening
Is currently monitoring an address for update notifications
Declaration
Swift

public var isListening: Bool
accountDidChange
Notifications of monitored addresses that have changed
Declaration
Swift

@Published public var accountDidChange: [String] { get set }

Init


                    
                    
                    init(networkService:config:dipDupClient:)

Init a TzKTClient with a NetworkService and a TezosNodeClientConfig.

Declaration

Swift

public init(networkService: NetworkService, config: TezosNodeClientConfig, dipDupClient: DipDupClient)

Parameters

`networkService`	`NetworkService` used to manage network communication.
`config`	`TezosNodeClientConfig` used to apss in settings.
`dipDupClient`	`DipDupClient` used to fetch additional information about the tokens owned.

Storage


                    
                    
                    getStorage(forContract:ofType:completion:)

Get the storage of a given contract and parse it to a supplied model type

Declaration

Swift

public func getStorage<T>(forContract contract: String, ofType: T.Type, completion: @escaping ((Result<T, KukaiError>) -> Void)) where T : Decodable, T : Encodable

Parameters

`forContract`	The KT1 contract address to query
`ofType`	The Codable compliant model to parse the response as
`completion`	A completion block called, returning a Swift Result type


                    
                    
                    getBigMap(forId:ofType:completion:)

Get the keys of a big map, by ID and parse it to a model

Declaration

Swift

public func getBigMap<T>(forId id: String, ofType: T.Type, completion: @escaping ((Result<T, KukaiError>) -> Void)) where T : Decodable, T : Encodable

Parameters

`forId`	The numeric ID of the big map
`ofType`	The Codable compliant model to parse the response as
`completion`	A completion block called, returning a Swift Result type


                    
                    
                    getBigMapKey(forId:key:ofType:completion:)

Get the keys of a big map, but filtered to only one specific key. Parse the response as the supplied model

Declaration

Swift

public func getBigMapKey<T>(forId id: String, key: String, ofType: T.Type, completion: @escaping ((Result<T, KukaiError>) -> Void)) where T : Decodable, T : Encodable

Parameters

`forId`	The numeric ID of the big map
`key`	The key to filter by
`ofType`	The Codable compliant model to parse the response as
`completion`	A completion block called, returning a Swift Result type

Search

suggestAccount(forString:completion:)
Call https://api.tzkt.io/v1/suggest/accounts/… appending the supplied string, in an attempt to search for an account with a known alias
Declaration
Swift

public func suggestAccount(forString: String, completion: @escaping ((Result<TzKTAddress?, KukaiError>) -> Void))

Voting


                    
                    
                    votingPeriods(limit:completion:)

Get the last N voting periods

Declaration

Swift

public func votingPeriods(limit: Int = 15, completion: @escaping ((Result<[TzKTVotingPeriod], KukaiError>) -> Void))

bakerVotes(forAddress:limit:completion:)
Get the last N transactions a given baker has performed related to voting (e.g. casting ballot or upvoting a proposal)
Declaration
Swift

public func bakerVotes(forAddress: String, limit: Int = 15, completion: @escaping ((Result<[TzKTTransaction], KukaiError>) -> Void))
checkBakerVoteParticipation(forAddress:limit:completion:)
Check how many of the last N voting periods that a given baker has particiapted in. This does not track what way the baker voted, merely that they cast a ballot one way or the other, or upvoted a proposal
Declaration
Swift

public func checkBakerVoteParticipation(forAddress: String, limit: Int = 20, completion: @escaping ((Result<[Bool], KukaiError>) -> Void))

Baking and Rewards

bakers(completion:)
Call https://api.baking-bad.org/v3/bakers/ for a list of public bakers if on mainnet, else search for all accounts self delegating on testnet
Declaration
Swift

public func bakers(completion: @escaping ((Result<[TzKTBaker], KukaiError>) -> Void))
bakerConfig(forAddress:forceMainnet:completion:)
Call https://api.baking-bad.org/v2/bakers/…?configs=true to get the config settings for the given baker Then call tzkt api: v1/operations/set_delegate_parameters… to fetch details on staking config (limitOfStakingOverBaking, edgeOfBakingOverStaking)
Declaration
Swift

public func bakerConfig(forAddress: String, forceMainnet: Bool = false, completion: @escaping ((Result<TzKTBaker, KukaiError>) -> Void))
delegatorRewards(forAddress:limit:completion:)
Call https://api.tzkt.io/v1/rewards/delegators/…?limit=… to get the config settings for the given baker
Declaration
Swift

public func delegatorRewards(forAddress: String, limit: Int = 25, completion: @escaping ((Result<[TzKTDelegatorReward], KukaiError>) -> Void))
estimateLastAndNextReward(forAddress:delegate:forceMainnet:completion:)
Make many different calls to attempt to figure out the previous reward the user should have received, and the next potential reward
Declaration
Swift

public func estimateLastAndNextReward(forAddress: String, delegate: TzKTAccountDelegate, forceMainnet: Bool = false, completion: @escaping ((Result<AggregateRewardInformation, KukaiError>) -> Void))


                    
                    
                    getLastReward(forAddress:uniqueBakers:payoutAddresses:completion:)

Take all the baker addresses and payout addresses and find the last transaction (if any) received from any of them

Declaration

Swift

public func getLastReward(forAddress: String, uniqueBakers: [TzKTAddress], payoutAddresses: [String : TzKTAddress], completion: @escaping ((Result<[TzKTTransaction], KukaiError>) -> Void))

pendingStakingUpdates(forAddress:ofType:completion:)
Fetch staking update operations for a given user, optionally filter by a specific type, that haven’t completed yet (currentCycle - 4)
Declaration
Swift

public func pendingStakingUpdates(forAddress: String, ofType: String?, completion: @escaping ((Result<[TzKTStakingUpdate], KukaiError>) -> Void))

Network


                    
                    
                    head(completion:)

Fetch the head from TzKT from .../v1/head

Declaration

Swift

public func head(completion: @escaping ((Result<TzKTHead, KukaiError>) -> Void))

cycles(limit:completion:)
Call https://api.tzkt.io/v1/cycles?limit=… to get the 10 most recent cycles
Declaration
Swift

public func cycles(limit: Int = 25, completion: @escaping ((Result<[TzKTCycle], KukaiError>) -> Void))
cycleForLevel(cycles:level:)
Given a list of cycles, search through them to find what cycle a given block level appeared in If leveled supplied is less than the firstLevel of the last cycle, return the last
Declaration
Swift

public static func cycleForLevel(cycles: [TzKTCycle], level: Decimal) -> TzKTCycle?
cycleForIndex(cycles:index:)
Given a list of cycles, find the object with the matching index
Declaration
Swift

public static func cycleForIndex(cycles: [TzKTCycle], index: Int) -> TzKTCycle?

Block checker


                    
                    
                    getOperation(byHash:completion:)

Query details about the given operation

Declaration

Swift

public func getOperation(byHash hash: String, completion: @escaping (([TzKTOperation]?, KukaiError?) -> Void))

Parameters

`byHash`	The operation hash to query.
`completion`	A completion colsure called when the request is done.

Account monitoring


                    
                    
                    listenForAccountChanges(addresses:withDebugging:)

Open a websocket connection to request a notification for any changes to the given account. The @Published var accountDidChange will be notified if something occurs

Declaration

Swift

public func listenForAccountChanges(addresses: [String], withDebugging: Bool = false)

Parameters


                                address

The Tz address of the account to monitor

stopListeningForAccountChanges()
Close the websocket from listenForAccountChanges
Declaration
Swift

public func stopListeningForAccountChanges()
changeAddressToListenForChanges(addresses:)
Close the current connection and open another
Declaration
Swift

public func changeAddressToListenForChanges(addresses: [String])

Balances


                    
                    
                    getBalanceCount(forAddress:completion:)

Get the count of tokens the given address has balances for (excluding zero balances)

Declaration

Swift

public func getBalanceCount(forAddress: String, completion: @escaping (Result<Int, KukaiError>) -> Void)

Parameters

`forAddress`	The tz address to search for
`completion`	The completion block called with a `Result` containing the number or an error


                    
                    
                    getBalancePage(forAddress:offset:completion:)

Tokens balances and metadata need to be fetch from a paginated API. THis function calls a sinlerequest or 1 page of balances / metadata

Declaration

Swift

public func getBalancePage(forAddress: String, offset: Int = 0, completion: @escaping ((Result<[TzKTBalance], KukaiError>) -> Void))

Parameters

`forAddress`	The tz address to search for
`offset`	The starting position
`completion`	The completion block called with a `Result` containing an array of balances or an error


                    
                    
                    getAccount(forAddress:fromURL:completion:)

Get the account object from TzKT caontaining information about the address, its balance and baker

Declaration

Swift

public func getAccount(forAddress: String, fromURL: URL? = nil, completion: @escaping ((Result<TzKTAccount, KukaiError>) -> Void))

Parameters

`forAddress`	The tz address to search for
`completion`	The completion block called with a `Result` containing an object or an error


                    
                    
                    getAllBalances(forAddress:completion:)

Get all balances from one function call, by fetching the result from getBalanceCount and using that to decide how many pages should be called

Declaration

Swift

public func getAllBalances(forAddress address: String, completion: @escaping ((Result<Account, KukaiError>) -> Void))

Parameters

`forAddress`	The tz address to search for
`completion`	The completion block called with a `Result` containing an object or an error


                    
                    
                    avatarURL(forToken:)

In order to access the cached images, you need the URL it was downloaded from. This can either be found inside the Token objects returned as part of Account from the fetchAccountInfo func. Or, if you need to use it seperately, given the token address you can use this function

Declaration

Swift

public static func avatarURL(forToken token: String) -> URL?

Parameters


                                forToken

The token address who’s image you are looking for.

Transaction History

fetchTransactions(forAddress:limit:completion:)
Fetch all transactions, both account operations, and token transfers, and combine them into 1 response
Declaration
Swift

public func fetchTransactions(forAddress address: String, limit: Int = 50, completion: @escaping (([TzKTTransaction]) -> Void))
groupTransactions(transactions:currentWalletAddress:)
Group transactions into logical groups, so user doesn’t see N enteries for 1 contract call resulting in many internal operations
Declaration
Swift

public func groupTransactions(transactions: [TzKTTransaction], currentWalletAddress: String) -> [TzKTTransactionGroup]


                    
                    
                    connectionDidOpen(hubConnection:)

Declaration

Swift

public func connectionDidOpen(hubConnection: HubConnection)


                    
                    
                    connectionDidClose(error:)

Declaration

Swift

public func connectionDidClose(error: Error?)


                    
                    
                    connectionDidFailToOpen(error:)

Declaration

Swift

public func connectionDidFailToOpen(error: Error)