@airgap/tezos 0.13.16-beta.2 → 0.13.16-beta.4

package/v1/protocol/TezosProtocol.d.ts

@@ -1,8 +1,11 @@
-import { Address, AirGapProtocol, AirGapTransaction, AirGapTransactionsWithCursor, Amount, Balance, CryptoDerivative, FeeDefaults, KeyPair, ProtocolAccountMetadata, ProtocolMetadata, ProtocolUnitsMetadata, PublicKey, RecursivePartial, SecretKey, Signature, TransactionConfiguration, TransactionDetails } from '@airgap/module-kit';
+import { DelegateeDetails, DelegationDetails, DelegatorDetails } from '@airgap/coinlib-core';
+import { Address, AirGapProtocol, AirGapTransaction, AirGapTransactionsWithCursor, Amount, Balance, CryptoDerivative, FeeDefaults, KeyPair, ProtocolAccountMetadata, ProtocolMetadata, ProtocolUnitsMetadata, PublicKey, RecursivePartial, SecretKey, Signature, TransactionFullConfiguration, TransactionDetails, TransactionSimpleConfiguration } from '@airgap/module-kit';
+import { AirGapDelegateProtocol } from '@airgap/module-kit/internal';
 import { TezosCryptoConfiguration } from '../types/crypto';
 import { TezosOperation } from '../types/operations/kinds/TezosOperation';
 import { TezosWrappedOperation } from '../types/operations/TezosWrappedOperation';
 import { TezosProtocolNetwork, TezosProtocolOptions, TezosUnits } from '../types/protocol';
+import { BakerDetails } from '../types/staking/BakerDetails';
 import { TezosSignedTransaction, TezosTransactionCursor, TezosUnsignedTransaction } from '../types/transaction';
 export interface TezosProtocol extends AirGapProtocol<{
     AddressResult: Address;
@@ -13,19 +16,24 @@ export interface TezosProtocol extends AirGapProtocol<{
     UnsignedTransaction: TezosUnsignedTransaction;
     SignedTransaction: TezosSignedTransaction;
     TransactionCursor: TezosTransactionCursor;
-}, 'Crypto', 'FetchDataForAddress'> {
+}, 'Crypto', 'FetchDataForAddress'>, AirGapDelegateProtocol {
+    isTezosProtocol: true;
+    getMinCycleDuration(): Promise<number>;
+    getDetailsFromWrappedOperation(wrappedOperation: TezosWrappedOperation): Promise<AirGapTransaction<TezosUnits, TezosUnits>[]>;
     forgeOperation(wrappedOperation: TezosWrappedOperation): Promise<string>;
     unforgeOperation(forged: string, type?: (TezosSignedTransaction | TezosUnsignedTransaction)['type']): Promise<TezosWrappedOperation>;
     getOperationFeeDefaults(publicKey: PublicKey, operations: TezosOperation[]): Promise<FeeDefaults<TezosUnits>>;
     prepareOperations(publicKey: PublicKey, operationRequests: TezosOperation[], overrideParameters?: boolean): Promise<TezosWrappedOperation>;
-    prepareTransactionsWithPublicKey(publicKey: PublicKey, details: TransactionDetails<TezosUnits>[], configuration?: TransactionConfiguration<TezosUnits> & {
+    prepareTransactionsWithPublicKey(publicKey: PublicKey, details: TransactionDetails<TezosUnits>[], configuration?: TransactionFullConfiguration<TezosUnits> & {
         operationsPerGroup?: number;
     }): Promise<TezosUnsignedTransaction[]>;
+    bakerDetails(address: string | undefined): Promise<BakerDetails>;
 }
 export declare const TEZOS_UNITS: ProtocolUnitsMetadata<TezosUnits>;
 export declare const TEZOS_DERIVATION_PATH: string;
 export declare const TEZOS_ACCOUNT_METADATA: ProtocolAccountMetadata;
 export declare class TezosProtocolImpl implements TezosProtocol {
+    readonly isTezosProtocol: true;
     private readonly options;
     private readonly forger;
     private readonly accountant;
@@ -53,20 +61,37 @@ export declare class TezosProtocolImpl implements TezosProtocol {
     getTransactionsForAddress(address: string, limit: number, cursor?: TezosTransactionCursor): Promise<AirGapTransactionsWithCursor<TezosTransactionCursor, TezosUnits, TezosUnits>>;
     getBalanceOfPublicKey(publicKey: PublicKey): Promise<Balance<TezosUnits>>;
     getBalanceOfAddress(address: string): Promise<Balance<TezosUnits>>;
-    getTransactionMaxAmountWithPublicKey(publicKey: PublicKey, to: string[], configuration?: TransactionConfiguration<TezosUnits>): Promise<Amount<TezosUnits>>;
+    getTransactionMaxAmountWithPublicKey(publicKey: PublicKey, to: string[], configuration?: TransactionFullConfiguration<TezosUnits>): Promise<Amount<TezosUnits>>;
     private getTansactionMaxAmountWithBalance;
-    getTransactionFeeWithPublicKey(publicKey: PublicKey, details: TransactionDetails<TezosUnits>[]): Promise<FeeDefaults<TezosUnits>>;
+    getTransactionFeeWithPublicKey(publicKey: PublicKey, details: TransactionDetails<TezosUnits>[], _configuration?: TransactionSimpleConfiguration): Promise<FeeDefaults<TezosUnits>>;
     getOperationFeeDefaults(publicKey: PublicKey, operations: TezosOperation[]): Promise<FeeDefaults<TezosUnits>>;
-    prepareTransactionWithPublicKey(publicKey: PublicKey, details: TransactionDetails<TezosUnits>[], configuration?: TransactionConfiguration<TezosUnits>): Promise<TezosUnsignedTransaction>;
+    prepareTransactionWithPublicKey(publicKey: PublicKey, details: TransactionDetails<TezosUnits>[], configuration?: TransactionFullConfiguration<TezosUnits>): Promise<TezosUnsignedTransaction>;
     broadcastTransaction(transaction: TezosSignedTransaction): Promise<string>;
+    getDefaultDelegatee(): Promise<string>;
+    getCurrentDelegateesForPublicKey(publicKey: PublicKey): Promise<string[]>;
+    getCurrentDelegateesForAddress(address: string): Promise<string[]>;
+    getDelegateeDetails(address: string): Promise<DelegateeDetails>;
+    isPublicKeyDelegating(publicKey: PublicKey): Promise<boolean>;
+    isAddressDelegating(address: string): Promise<boolean>;
+    getDelegatorDetailsFromPublicKey(publicKey: PublicKey): Promise<DelegatorDetails>;
+    getDelegatorDetailsFromAddress(address: string): Promise<DelegatorDetails>;
+    getDelegationDetailsFromPublicKey(publicKey: PublicKey, delegatees: string[]): Promise<DelegationDetails>;
+    getDelegationDetailsFromAddress(address: string, delegatees: string[]): Promise<DelegationDetails>;
+    private getDelegatorDetails;
+    prepareDelegatorActionFromPublicKey(publicKey: PublicKey, type: any, data?: any): Promise<any[]>;
+    undelegate(publicKey: PublicKey): Promise<TezosUnsignedTransaction>;
+    delegate(publicKey: PublicKey, delegate?: string | string[]): Promise<TezosUnsignedTransaction>;
+    getMinCycleDuration(): Promise<number>;
+    getDetailsFromWrappedOperation(wrappedOperation: TezosWrappedOperation): Promise<AirGapTransaction<TezosUnits, TezosUnits>[]>;
     forgeOperation(wrappedOperation: TezosWrappedOperation): Promise<string>;
     unforgeOperation(forged: string, type?: (TezosSignedTransaction | TezosUnsignedTransaction)['type']): Promise<TezosWrappedOperation>;
-    prepareTransactionsWithPublicKey(publicKey: PublicKey, details: TransactionDetails<TezosUnits>[], configuration?: TransactionConfiguration<TezosUnits> & {
+    prepareTransactionsWithPublicKey(publicKey: PublicKey, details: TransactionDetails<TezosUnits>[], configuration?: TransactionFullConfiguration<TezosUnits> & {
         operationsPerGroup?: number;
     }): Promise<TezosUnsignedTransaction[]>;
     prepareOperations(publicKey: PublicKey, operationRequests: TezosOperation[], overrideParameters?: boolean): Promise<TezosWrappedOperation>;
     private estimateAndReplaceLimitsAndFee;
     private createTransactionOperations;
+    bakerDetails(address: string | undefined): Promise<BakerDetails>;
 }
 export declare function createTezosProtocol(options?: RecursivePartial<TezosProtocolOptions>): TezosProtocol;
 export declare const TEZOS_MAINNET_PROTOCOL_NETWORK: TezosProtocolNetwork;

package/v1/protocol/TezosProtocol.js

@@ -61,6 +61,7 @@ var TezosAddress_1 = require("../data/TezosAddress");
 var factory_1 = require("../indexer/factory");
 var network_1 = require("../types/network");
 var TezosOperationType_1 = require("../types/operations/TezosOperationType");
+var TezosDelegatorAction_1 = require("../types/staking/TezosDelegatorAction");
 var key_1 = require("../utils/key");
 var operations_1 = require("../utils/operations");
 var TezosAccountant_1 = require("../utils/protocol/tezos/TezosAccountant");
@@ -69,12 +70,14 @@ var signature_1 = require("../utils/signature");
 // Implementation
 var MAX_OPERATIONS_PER_GROUP = 200;
 var MAX_GAS_PER_BLOCK = 5200000;
+var MIN_CYCLE_DURATION = 4096 * 60 * 1000; // ms
 var GAS_LIMIT_PLACEHOLDER = '1040000';
 var STORAGE_LIMIT_PLACEHOLDER = '60000';
 var FEE_PLACEHOLDER = '0';
 var MINIMAL_FEE = 100;
 var MINIMAL_FEE_PER_GAS_UNIT = 0.1;
 var MINIMAL_FEE_PER_BYTE = 1;
+var SELF_BOND_REQUIREMENT = 0.0825; // 8.25%
 exports.TEZOS_UNITS = {
     tez: {
         symbol: { value: 'XTZ', market: 'xtz' },
@@ -100,6 +103,7 @@ exports.TEZOS_ACCOUNT_METADATA = {
 };
 var TezosProtocolImpl = /** @class */ (function () {
     function TezosProtocolImpl(options) {
+        this.isTezosProtocol = true;
         // Common
         this.units = exports.TEZOS_UNITS;
         this.feeDefaults = {
@@ -124,7 +128,7 @@ var TezosProtocolImpl = /** @class */ (function () {
         this.options = createTezosProtocolOptions(options.network);
         this.forger = new TezosForger_1.TezosForger();
         this.accountant = new TezosAccountant_1.TezosAccountant(this.forger, this.options.network);
-        this.indexerClient = (0, factory_1.createTezosIndexerClient)(this.options.network.indexer);
+        this.indexerClient = (0, factory_1.createTezosIndexerClient)(this.options.network.indexerType, this.options.network.indexerApi);
         this.cryptoClient = new TezosCryptoClient_1.TezosCryptoClient();
     }
     TezosProtocolImpl.prototype.getMetadata = function () {
@@ -384,7 +388,7 @@ var TezosProtocolImpl = /** @class */ (function () {
             });
         });
     };
-    TezosProtocolImpl.prototype.getTransactionFeeWithPublicKey = function (publicKey, details) {
+    TezosProtocolImpl.prototype.getTransactionFeeWithPublicKey = function (publicKey, details, _configuration) {
         return __awaiter(this, void 0, void 0, function () {
             var operations, i, recipient, transaction;
             return __generator(this, function (_a) {
@@ -482,7 +486,298 @@ var TezosProtocolImpl = /** @class */ (function () {
             });
         });
     };
+    // Staking
+    TezosProtocolImpl.prototype.getDefaultDelegatee = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var activeBakers;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/delegates?active"))];
+                    case 1:
+                        activeBakers = (_a.sent()).data;
+                        return [2 /*return*/, activeBakers[0] || ''];
+                }
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.getCurrentDelegateesForPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _a.sent();
+                        return [2 /*return*/, this.getCurrentDelegateesForAddress(address)];
+                }
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.getCurrentDelegateesForAddress = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(address))];
+                    case 1:
+                        data = (_a.sent()).data;
+                        return [2 /*return*/, data.delegate ? [data.delegate] : []];
+                }
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.getDelegateeDetails = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, isBakingActive;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/delegates/").concat(address, "/deactivated"))];
+                    case 1:
+                        response = _a.sent();
+                        isBakingActive = !response.data;
+                        return [2 /*return*/, {
+                                status: isBakingActive ? 'Active' : 'Inactive',
+                                address: address
+                            }];
+                }
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.isPublicKeyDelegating = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _a.sent();
+                        return [2 /*return*/, this.isAddressDelegating(address)];
+                }
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.isAddressDelegating = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(address))];
+                    case 1:
+                        data = (_a.sent()).data;
+                        return [2 /*return*/, !!data.delegate];
+                }
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.getDelegatorDetailsFromPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _a.sent();
+                        return [2 /*return*/, this.getDelegatorDetailsFromAddress(address)];
+                }
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.getDelegatorDetailsFromAddress = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getDelegatorDetails(address)];
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.getDelegationDetailsFromPublicKey = function (publicKey, delegatees) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _a.sent();
+                        return [2 /*return*/, this.getDelegationDetailsFromAddress(address, delegatees)];
+                }
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.getDelegationDetailsFromAddress = function (address, delegatees) {
+        return __awaiter(this, void 0, void 0, function () {
+            var bakerAddress, results, delegatorDetails, bakerDetails;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (delegatees.length > 1) {
+                            return [2 /*return*/, Promise.reject('Multiple delegation is not supported.')];
+                        }
+                        bakerAddress = delegatees[0];
+                        return [4 /*yield*/, Promise.all([this.getDelegatorDetails(address, bakerAddress), this.getDelegateeDetails(bakerAddress)])];
+                    case 1:
+                        results = _a.sent();
+                        delegatorDetails = results[0];
+                        bakerDetails = results[1];
+                        return [2 /*return*/, {
+                                delegator: delegatorDetails,
+                                delegatees: [bakerDetails]
+                            }];
+                }
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.getDelegatorDetails = function (address, bakerAddress) {
+        return __awaiter(this, void 0, void 0, function () {
+            var results, accountDetails, balance, isDelegating, availableActions;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all([index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(address))])];
+                    case 1:
+                        results = _a.sent();
+                        accountDetails = results[0].data;
+                        balance = accountDetails.balance;
+                        isDelegating = !!accountDetails.delegate;
+                        availableActions = [];
+                        if (!isDelegating) {
+                            availableActions.push({
+                                type: TezosDelegatorAction_1.TezosDelegatorAction.DELEGATE,
+                                args: ['delegate']
+                            });
+                        }
+                        else if (!bakerAddress || accountDetails.delegate === bakerAddress) {
+                            availableActions.push({
+                                type: TezosDelegatorAction_1.TezosDelegatorAction.UNDELEGATE
+                            });
+                        }
+                        else {
+                            availableActions.push({
+                                type: TezosDelegatorAction_1.TezosDelegatorAction.CHANGE_BAKER,
+                                args: ['delegate']
+                            });
+                        }
+                        return [2 /*return*/, {
+                                address: address,
+                                balance: balance,
+                                delegatees: [accountDetails.delegate],
+                                availableActions: availableActions
+                            }];
+                }
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.prepareDelegatorActionFromPublicKey = function (publicKey, type, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = type;
+                        switch (_a) {
+                            case TezosDelegatorAction_1.TezosDelegatorAction.DELEGATE: return [3 /*break*/, 1];
+                            case TezosDelegatorAction_1.TezosDelegatorAction.CHANGE_BAKER: return [3 /*break*/, 1];
+                            case TezosDelegatorAction_1.TezosDelegatorAction.UNDELEGATE: return [3 /*break*/, 3];
+                        }
+                        return [3 /*break*/, 5];
+                    case 1:
+                        if (!data || !data.delegate) {
+                            return [2 /*return*/, Promise.reject("Invalid arguments passed for ".concat(type, " action, delegate is missing."))];
+                        }
+                        return [4 /*yield*/, this.delegate(publicKey, data.delegate)];
+                    case 2: return [2 /*return*/, [_b.sent()]];
+                    case 3: return [4 /*yield*/, this.undelegate(publicKey)];
+                    case 4: return [2 /*return*/, [_b.sent()]];
+                    case 5: return [2 /*return*/, Promise.reject('Unsupported delegator action.')];
+                }
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.undelegate = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.delegate(publicKey)];
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.delegate = function (publicKey, delegate) {
+        return __awaiter(this, void 0, void 0, function () {
+            var counter, branch, operations, tzAddress, results, accountManager, balance, totalBalance, fee, delegationOperation, tezosWrappedOperation, binary, error_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        counter = new bignumber_1.default(1);
+                        branch = '';
+                        operations = [];
+                        return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        tzAddress = _a.sent();
+                        return [4 /*yield*/, Promise.all([
+                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(tzAddress, "/counter")),
+                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head~2/hash")),
+                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(tzAddress, "/manager_key"))
+                            ]).catch(function (error) {
+                                throw new errors_1.NetworkError(coinlib_core_1.Domain.TEZOS, error);
+                            })];
+                    case 2:
+                        results = _a.sent();
+                        counter = new bignumber_1.default(results[0].data).plus(1);
+                        branch = results[1].data;
+                        accountManager = results[2].data;
+                        // check if we have revealed the address already
+                        if (!accountManager) {
+                            operations.push((0, operations_1.createRevealOperation)(counter, publicKey, tzAddress));
+                            counter = counter.plus(1);
+                        }
+                        return [4 /*yield*/, this.getBalanceOfAddress(tzAddress)];
+                    case 3:
+                        balance = _a.sent();
+                        totalBalance = new bignumber_1.default((0, module_kit_1.newAmount)(balance.total).blockchain(this.units).value);
+                        fee = new bignumber_1.default(1420);
+                        if (totalBalance.isLessThan(fee)) {
+                            throw new errors_1.BalanceError(coinlib_core_1.Domain.TEZOS, 'not enough balance');
+                        }
+                        delegationOperation = {
+                            kind: TezosOperationType_1.TezosOperationType.DELEGATION,
+                            source: tzAddress,
+                            fee: fee.toFixed(),
+                            counter: counter.toFixed(),
+                            gas_limit: '10000',
+                            storage_limit: '0',
+                            delegate: Array.isArray(delegate) ? delegate[0] : delegate
+                        };
+                        operations.push(delegationOperation);
+                        _a.label = 4;
+                    case 4:
+                        _a.trys.push([4, 6, , 7]);
+                        tezosWrappedOperation = {
+                            branch: branch,
+                            contents: operations
+                        };
+                        return [4 /*yield*/, this.forgeOperation(tezosWrappedOperation)];
+                    case 5:
+                        binary = _a.sent();
+                        return [2 /*return*/, (0, module_kit_1.newUnsignedTransaction)({ binary: binary })];
+                    case 6:
+                        error_3 = _a.sent();
+                        throw new errors_1.OperationFailedError(coinlib_core_1.Domain.TEZOS, "Forging Tezos TX failed with ".concat(JSON.stringify(error_3.message)));
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
     // Custom
+    TezosProtocolImpl.prototype.getMinCycleDuration = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, MIN_CYCLE_DURATION];
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.getDetailsFromWrappedOperation = function (wrappedOperation) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.accountant.getDetailsFromWrappedOperation(wrappedOperation)];
+            });
+        });
+    };
     TezosProtocolImpl.prototype.forgeOperation = function (wrappedOperation) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
@@ -900,6 +1195,50 @@ var TezosProtocolImpl = /** @class */ (function () {
             });
         });
     };
+    TezosProtocolImpl.prototype.bakerDetails = function (address) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function () {
+            var results, tzBalance, delegatedBalance, stakingBalance, selfBond, stakingCapacity, bakerDetails;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        if (!address ||
+                            !(address.toLowerCase().startsWith('tz1') ||
+                                address.toLowerCase().startsWith('tz2') ||
+                                address.toLowerCase().startsWith('tz3') ||
+                                address.toLowerCase().startsWith('tz4'))) {
+                            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.TEZOS, 'non tz-address supplied');
+                        }
+                        return [4 /*yield*/, Promise.all([
+                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/delegates/").concat(address, "/balance")).catch(function (_error) { return undefined; }),
+                                index_1.default
+                                    .get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/delegates/").concat(address, "/full_balance"))
+                                    .catch(function (_error) { return undefined; }),
+                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/delegates/").concat(address, "/delegated_balance")),
+                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/delegates/").concat(address, "/staking_balance"))
+                            ]).catch(function (error) {
+                                throw new errors_1.NetworkError(coinlib_core_1.Domain.TEZOS, error);
+                            })];
+                    case 1:
+                        results = _e.sent();
+                        tzBalance = new bignumber_1.default((_b = ((_a = results[0]) !== null && _a !== void 0 ? _a : results[1])) === null || _b === void 0 ? void 0 : _b.data);
+                        delegatedBalance = new bignumber_1.default((_c = results[2]) === null || _c === void 0 ? void 0 : _c.data);
+                        stakingBalance = new bignumber_1.default((_d = results[3]) === null || _d === void 0 ? void 0 : _d.data);
+                        selfBond = stakingBalance.minus(delegatedBalance);
+                        stakingCapacity = stakingBalance.div(selfBond.div(SELF_BOND_REQUIREMENT));
+                        bakerDetails = {
+                            balance: (0, module_kit_1.newAmount)(tzBalance, 'blockchain'),
+                            delegatedBalance: (0, module_kit_1.newAmount)(delegatedBalance, 'blockchain'),
+                            stakingBalance: (0, module_kit_1.newAmount)(stakingBalance, 'blockchain'),
+                            selfBond: (0, module_kit_1.newAmount)(selfBond, 'blockchain'),
+                            bakerCapacity: stakingBalance.div(stakingCapacity).toString(),
+                            bakerUsage: stakingCapacity.toString()
+                        };
+                        return [2 /*return*/, bakerDetails];
+                }
+            });
+        });
+    };
     return TezosProtocolImpl;
 }());
 exports.TezosProtocolImpl = TezosProtocolImpl;
@@ -914,34 +1253,26 @@ exports.TEZOS_MAINNET_PROTOCOL_NETWORK = {
     type: 'mainnet',
     rpcUrl: 'https://tezos-node.prod.gke.papers.tech',
     network: network_1.TezosNetwork.MAINNET,
-    blockExplorer: {
-        type: 'tzkt',
-        url: 'https://tzkt.io'
-    },
-    indexer: {
-        type: 'tzkt',
-        apiUrl: 'https://tezos-mainnet-indexer.prod.gke.papers.tech'
-    }
+    blockExplorerUrl: 'https://tzkt.io',
+    blockExplorerType: 'tzkt',
+    indexerApi: 'https://tezos-mainnet-indexer.prod.gke.papers.tech',
+    indexerType: 'tzkt'
 };
 exports.TEZOS_GHOSTNET_PROTOCOL_NETWORK = {
     name: 'Ghostnet',
     type: 'testnet',
     rpcUrl: 'https://tezos-ghostnet-node.prod.gke.papers.tech',
     network: network_1.TezosNetwork.GHOSTNET,
-    blockExplorer: {
-        type: 'tzkt',
-        url: 'https://ghostnet.tzkt.io'
-    },
-    indexer: {
-        type: 'tzkt',
-        apiUrl: 'https://tezos-ghostnet-indexer.prod.gke.papers.tech'
-    }
+    blockExplorerUrl: 'https://ghostnet.tzkt.io',
+    blockExplorerType: 'tzkt',
+    indexerApi: 'https://tezos-ghostnet-indexer.prod.gke.papers.tech',
+    indexerType: 'tzkt'
 };
 var DEFAULT_TEZOS_PROTOCOL_NETWORK = exports.TEZOS_MAINNET_PROTOCOL_NETWORK;
 function createTezosProtocolOptions(network) {
     if (network === void 0) { network = {}; }
     return {
-        network: __assign(__assign(__assign({}, DEFAULT_TEZOS_PROTOCOL_NETWORK), network), { blockExplorer: __assign(__assign({}, DEFAULT_TEZOS_PROTOCOL_NETWORK.blockExplorer), network.blockExplorer), indexer: __assign(__assign({}, DEFAULT_TEZOS_PROTOCOL_NETWORK.indexer), network.indexer) })
+        network: __assign(__assign({}, DEFAULT_TEZOS_PROTOCOL_NETWORK), network)
     };
 }
 exports.createTezosProtocolOptions = createTezosProtocolOptions;