@airgap/coinlib-core 0.13.6 → 0.13.7-beta.1

package/interfaces/IAirGapAddress.d.ts

@@ -0,0 +1,19 @@
+import { AeternityAddressCursor } from '../protocols/aeternity/AeternityTypes';
+import { BitcoinAddressCursor } from '../protocols/bitcoin/BitcoinTypes';
+import { CosmosAddressCursor } from '../protocols/cosmos/CosmosTypes';
+import { EthereumAddressCursor } from '../protocols/ethereum/EthereumTypes';
+import { SubstrateAddressCursor } from '../protocols/substrate/SubstrateTypes';
+import { TezosKtAddressCursor } from '../protocols/tezos/types/kt/TezosKtAddressCursor';
+import { TezosSaplingAddressCursor } from '../protocols/tezos/types/sapling/TezosSaplingAddressCursor';
+import { TezosAddressCursor } from '../protocols/tezos/types/TezosAddressCursor';
+export interface IAirGapAddress {
+    getValue(): string;
+}
+export interface IBaseProtocolAddressCursor {
+    hasNext: boolean;
+}
+export declare type IProtocolAddressCursor = AeternityAddressCursor | BitcoinAddressCursor | CosmosAddressCursor | EthereumAddressCursor | SubstrateAddressCursor | TezosAddressCursor | TezosKtAddressCursor | TezosSaplingAddressCursor;
+export interface IAirGapAddressResult<T extends IBaseProtocolAddressCursor = IProtocolAddressCursor> {
+    address: string;
+    cursor: T;
+}

package/interfaces/IAirGapAddress.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IAirGapAddress.js.map

package/interfaces/IAirGapAddress.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAirGapAddress.js","sourceRoot":"","sources":["../../src/interfaces/IAirGapAddress.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@airgap/coinlib-core",
-  "version": "0.13.6",
+  "version": "0.13.7-beta.1",
   "description": "The @airgap/coinlib-core is a protocol agnostic library to prepare, sign and broadcast cryptocurrency transactions.",
   "keywords": [
     "airgap",

package/protocols/CryptoClient.d.ts

@@ -1,16 +1,15 @@
-/// <reference types="node" />
 export declare abstract class CryptoClient {
     abstract signMessage(message: string, keypair: {
         publicKey?: string;
-        privateKey: Buffer;
+        privateKey: string;
     }): Promise<string>;
     abstract verifyMessage(message: string, signature: string, publicKey: string): Promise<boolean>;
-    encryptAES(payload: string, privateKey: Buffer): Promise<string>;
-    decryptAES(encryptedPayload: string, privateKey: Buffer): Promise<string>;
+    encryptAES(payload: string, privateKey: string): Promise<string>;
+    decryptAES(encryptedPayload: string, privateKey: string): Promise<string>;
     encryptAsymmetric(payload: string, publicKey: string): Promise<string>;
     decryptAsymmetric(encryptedPayload: string, keypair: {
         publicKey?: string;
-        privateKey: Buffer;
+        privateKey: string;
     }): Promise<string>;
     recoverPublicKeyFromSignature(): Promise<void>;
 }

package/protocols/Ed25519CryptoClient.d.ts

@@ -1,9 +1,8 @@
-/// <reference types="node" />
 import { CryptoClient } from './CryptoClient';
 export declare abstract class Ed25519CryptoClient extends CryptoClient {
     encryptAsymmetric(payload: string, publicKey: string): Promise<string>;
     decryptAsymmetric(encryptedPayload: string, keypair: {
         publicKey: string;
-        privateKey: Buffer;
+        privateKey: string;
     }): Promise<string>;
 }

package/protocols/Ed25519CryptoClient.js

@@ -80,7 +80,7 @@ var Ed25519CryptoClient = /** @class */ (function (_super) {
         return __awaiter(this, void 0, void 0, function () {
             var kxSelfPrivateKey, kxSelfPublicKey, decryptedMessage;
             return __generator(this, function (_a) {
-                kxSelfPrivateKey = sodium.crypto_sign_ed25519_sk_to_curve25519(Buffer.from(keypair.privateKey)) // Secret bytes to scalar bytes
+                kxSelfPrivateKey = sodium.crypto_sign_ed25519_sk_to_curve25519(Buffer.from(keypair.privateKey, 'hex')) // Secret bytes to scalar bytes
                 ;
                 kxSelfPublicKey = sodium.crypto_sign_ed25519_pk_to_curve25519(Buffer.from(keypair.publicKey, 'hex')) // Secret bytes to scalar bytes
                 ;

package/protocols/Ed25519CryptoClient.js.map

@@ -1 +1 @@
-{"version":3,"file":"Ed25519CryptoClient.js","sourceRoot":"","sources":["../../src/protocols/Ed25519CryptoClient.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2CAA6C;AAE7C,+CAA6C;AAE7C,SAAS,KAAK,CAAC,KAAU;IACvB,OAAO,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAA;AAC3C,CAAC;AAED;IAAkD,uCAAY;IAA9D;;IAsBA,CAAC;IArBc,+CAAiB,GAA9B,UAA+B,OAAe,EAAE,SAAiB;;;;;4BAC/D,qBAAM,MAAM,CAAC,KAAK,EAAA;;wBAAlB,SAAkB,CAAA;wBAEZ,eAAe,GAAe,MAAM,CAAC,oCAAoC,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC,+BAA+B;wBAAhC,CAAA;wBACxG,gBAAgB,GAAe,MAAM,CAAC,eAAe,CAAC,OAAO,EAAE,eAAe,CAAC,CAAA;wBAErF,sBAAO,KAAK,CAAC,gBAAgB,CAAC,EAAA;;;;KAC/B;IAEY,+CAAiB,GAA9B,UAA+B,gBAAwB,EAAE,OAAkD;;;;gBACnG,gBAAgB,GAAe,MAAM,CAAC,oCAAoC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,+BAA+B;gBAAhC,CAAA;gBAC3G,eAAe,GAAe,MAAM,CAAC,oCAAoC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC,+BAA+B;gBAAhC,CAAA;gBAEhH,gBAAgB,GAAe,MAAM,CAAC,oBAAoB,CAC9D,MAAM,CAAC,IAAI,CAAC,gBAAgB,EAAE,KAAK,CAAC,EACpC,eAAe,EACf,gBAAgB,CACjB,CAAA;gBAED,sBAAO,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,QAAQ,EAAE,EAAA;;;KAChD;IACH,0BAAC;AAAD,CAAC,AAtBD,CAAkD,2BAAY,GAsB7D;AAtBqB,kDAAmB"}
+{"version":3,"file":"Ed25519CryptoClient.js","sourceRoot":"","sources":["../../src/protocols/Ed25519CryptoClient.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2CAA6C;AAE7C,+CAA6C;AAE7C,SAAS,KAAK,CAAC,KAAU;IACvB,OAAO,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAA;AAC3C,CAAC;AAED;IAAkD,uCAAY;IAA9D;;IAsBA,CAAC;IArBc,+CAAiB,GAA9B,UAA+B,OAAe,EAAE,SAAiB;;;;;4BAC/D,qBAAM,MAAM,CAAC,KAAK,EAAA;;wBAAlB,SAAkB,CAAA;wBAEZ,eAAe,GAAe,MAAM,CAAC,oCAAoC,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC,+BAA+B;wBAAhC,CAAA;wBACxG,gBAAgB,GAAe,MAAM,CAAC,eAAe,CAAC,OAAO,EAAE,eAAe,CAAC,CAAA;wBAErF,sBAAO,KAAK,CAAC,gBAAgB,CAAC,EAAA;;;;KAC/B;IAEY,+CAAiB,GAA9B,UAA+B,gBAAwB,EAAE,OAAkD;;;;gBACnG,gBAAgB,GAAe,MAAM,CAAC,oCAAoC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC,CAAC,+BAA+B;gBAAhC,CAAA;gBAClH,eAAe,GAAe,MAAM,CAAC,oCAAoC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC,+BAA+B;gBAAhC,CAAA;gBAEhH,gBAAgB,GAAe,MAAM,CAAC,oBAAoB,CAC9D,MAAM,CAAC,IAAI,CAAC,gBAAgB,EAAE,KAAK,CAAC,EACpC,eAAe,EACf,gBAAgB,CACjB,CAAA;gBAED,sBAAO,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,QAAQ,EAAE,EAAA;;;KAChD;IACH,0BAAC;AAAD,CAAC,AAtBD,CAAkD,2BAAY,GAsB7D;AAtBqB,kDAAmB"}

package/protocols/ICoinBaseProtocol.d.ts

@@ -0,0 +1,47 @@
+import { CryptoClient, IAirGapTransaction } from '..';
+import { IAirGapAddressResult, IProtocolAddressCursor } from '../interfaces/IAirGapAddress';
+import { SignedTransaction } from '../serializer/schemas/definitions/signed-transaction';
+import { UnsignedTransaction } from '../serializer/schemas/definitions/unsigned-transaction';
+import { ProtocolOptions } from '../utils/ProtocolOptions';
+import { ProtocolSymbols } from '../utils/ProtocolSymbols';
+export interface FeeDefaults {
+    low: string;
+    medium: string;
+    high: string;
+}
+export interface CoinAddress {
+    asString(): string;
+}
+export interface ICoinBaseProtocol {
+    symbol: string;
+    name: string;
+    marketSymbol: string;
+    feeSymbol: string;
+    feeDefaults: FeeDefaults;
+    decimals: number;
+    feeDecimals: number;
+    identifier: ProtocolSymbols;
+    units: {
+        unitSymbol: string;
+        factor: string;
+    }[];
+    supportsHD: boolean;
+    standardDerivationPath: string;
+    addressIsCaseSensitive: boolean;
+    addressValidationPattern: string;
+    addressPlaceholder: string;
+    options: ProtocolOptions;
+    cryptoClient: CryptoClient;
+    getAddressFromPublicKey(publicKey: string, cursor?: IProtocolAddressCursor): Promise<IAirGapAddressResult>;
+    getAddressesFromPublicKey(publicKey: string, cursor?: IProtocolAddressCursor): Promise<IAirGapAddressResult[]>;
+    getAddressFromExtendedPublicKey(extendedPublicKey: string, visibilityDerivationIndex: number, addressDerivationIndex: number): Promise<IAirGapAddressResult>;
+    getAddressesFromExtendedPublicKey(extendedPublicKey: string, visibilityDerivationIndex: number, addressCount: number, offset: number): Promise<IAirGapAddressResult[]>;
+    getTransactionDetails(transaction: UnsignedTransaction, data?: {
+        [key: string]: unknown;
+    }): Promise<IAirGapTransaction[]>;
+    getTransactionDetailsFromSigned(transaction: SignedTransaction, data?: {
+        [key: string]: unknown;
+    }): Promise<IAirGapTransaction[]>;
+    verifyMessage(message: string, signature: string, publicKey: string): Promise<boolean>;
+    encryptAsymmetric(payload: string, publicKey: string): Promise<string>;
+}

package/protocols/ICoinBaseProtocol.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ICoinBaseProtocol.js.map

package/protocols/ICoinBaseProtocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ICoinBaseProtocol.js","sourceRoot":"","sources":["../../src/protocols/ICoinBaseProtocol.ts"],"names":[],"mappings":""}

package/protocols/ICoinOfflineProtocol.d.ts

@@ -0,0 +1,22 @@
+import { IAirGapSignedTransaction } from '../interfaces/IAirGapSignedTransaction';
+import { ICoinBaseProtocol } from './ICoinBaseProtocol';
+export interface ICoinOfflineProtocol extends ICoinBaseProtocol {
+    getPublicKeyFromMnemonic(mnemonic: string, derivationPath: string, password?: string): Promise<string>;
+    getPrivateKeyFromMnemonic(mnemonic: string, derivationPath: string, password?: string): Promise<string>;
+    getExtendedPrivateKeyFromMnemonic(mnemonic: string, derivationPath: string, password?: string): Promise<string>;
+    getPublicKeyFromHexSecret(secret: string, derivationPath: string): Promise<string>;
+    getPrivateKeyFromHexSecret(secret: string, derivationPath: string): Promise<string>;
+    signWithExtendedPrivateKey(extendedPrivateKey: string, transaction: any, childDerivationPath?: string): Promise<IAirGapSignedTransaction>;
+    signWithPrivateKey(privateKey: string, transaction: any): Promise<IAirGapSignedTransaction>;
+    getExtendedPrivateKeyFromHexSecret(secret: string, derivationPath: string): Promise<string>;
+    signMessage(message: string, keypair: {
+        publicKey?: string;
+        privateKey: string;
+    }): Promise<string>;
+    decryptAsymmetric(encryptedPayload: string, keypair: {
+        publicKey?: string;
+        privateKey: string;
+    }): Promise<string>;
+    encryptAES(payload: string, privateKey: string): Promise<string>;
+    decryptAES(encryptedPayload: string, privateKey: string): Promise<string>;
+}

package/protocols/ICoinOfflineProtocol.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ICoinOfflineProtocol.js.map

package/protocols/ICoinOfflineProtocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ICoinOfflineProtocol.js","sourceRoot":"","sources":["../../src/protocols/ICoinOfflineProtocol.ts"],"names":[],"mappings":""}

package/protocols/ICoinOnlineProtocol.d.ts

@@ -0,0 +1,46 @@
+import { AirGapTransactionStatus, IAirGapTransactionResult } from '../interfaces/IAirGapTransaction';
+import { IProtocolTransactionCursor } from './../interfaces/IAirGapTransaction';
+import { FeeDefaults, ICoinBaseProtocol } from './ICoinBaseProtocol';
+import { ICoinSubProtocol } from './ICoinSubProtocol';
+export interface ICoinOnlineProtocol extends ICoinBaseProtocol {
+    getBlockExplorerLinkForAddress(address: string): Promise<string>;
+    getBlockExplorerLinkForTxId(txId: string): Promise<string>;
+    getTransactionsFromPublicKey(publicKey: string, limit: number, cursor?: IProtocolTransactionCursor): Promise<IAirGapTransactionResult>;
+    getTransactionsFromExtendedPublicKey(extendedPublicKey: string, limit: number, cursor?: IProtocolTransactionCursor): Promise<IAirGapTransactionResult>;
+    getTransactionsFromAddresses(addresses: string[], limit: number, cursor?: IProtocolTransactionCursor): Promise<IAirGapTransactionResult>;
+    getBalanceOfAddresses(addresses: string[], data?: {
+        [key: string]: unknown;
+    }): Promise<string>;
+    getBalanceOfPublicKey(publicKey: string, data?: {
+        addressIndex?: number;
+        [key: string]: unknown;
+    }): Promise<string>;
+    getBalanceOfExtendedPublicKey(extendedPublicKey: string, offset: number, data?: {
+        [key: string]: unknown;
+    }): Promise<string>;
+    getAvailableBalanceOfAddresses(addresses: string[], data?: {
+        [key: string]: unknown;
+    }): Promise<string>;
+    getTransactionStatuses(transactionHash: string[]): Promise<AirGapTransactionStatus[]>;
+    getBalanceOfPublicKeyForSubProtocols(publicKey: string, subProtocols: ICoinSubProtocol[]): Promise<string[]>;
+    estimateMaxTransactionValueFromExtendedPublicKey(extendedPublicKey: string, recipients: string[], fee?: string, data?: {
+        [key: string]: unknown;
+    }): Promise<string>;
+    estimateMaxTransactionValueFromPublicKey(publicKey: string, recipients: string[], fee?: string, data?: {
+        addressIndex?: number;
+        [key: string]: unknown;
+    }): Promise<string>;
+    estimateFeeDefaultsFromExtendedPublicKey(publicKey: string, recipients: string[], values: string[], data?: {
+        [key: string]: unknown;
+    }): Promise<FeeDefaults>;
+    estimateFeeDefaultsFromPublicKey(publicKey: string, recipients: string[], values: string[], data?: {
+        [key: string]: unknown;
+    }): Promise<FeeDefaults>;
+    prepareTransactionFromExtendedPublicKey(extendedPublicKey: string, offset: number, recipients: string[], values: string[], fee: string, extras?: {
+        [key: string]: unknown;
+    }): Promise<any>;
+    prepareTransactionFromPublicKey(publicKey: string, recipients: string[], values: string[], fee: string, extras?: {
+        [key: string]: unknown;
+    }): Promise<any>;
+    broadcastTransaction(rawTransaction: any): Promise<string>;
+}

package/protocols/ICoinOnlineProtocol.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ICoinOnlineProtocol.js.map

package/protocols/ICoinOnlineProtocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ICoinOnlineProtocol.js","sourceRoot":"","sources":["../../src/protocols/ICoinOnlineProtocol.ts"],"names":[],"mappings":""}

package/protocols/ICoinProtocol.d.ts

@@ -1,115 +1,9 @@
-/// <reference types="node" />
-import { CryptoClient } from '..';
-import { IAirGapSignedTransaction } from '../interfaces/IAirGapSignedTransaction';
-import { AirGapTransactionStatus, IAirGapTransaction, IAirGapTransactionResult } from '../interfaces/IAirGapTransaction';
-import { SignedTransaction } from '../serializer/schemas/definitions/signed-transaction';
-import { UnsignedTransaction } from '../serializer/schemas/definitions/unsigned-transaction';
-import { ProtocolOptions } from '../utils/ProtocolOptions';
-import { ProtocolSymbols } from '../utils/ProtocolSymbols';
-import { IProtocolTransactionCursor } from './../interfaces/IAirGapTransaction';
-import { ICoinSubProtocol } from './ICoinSubProtocol';
-export interface FeeDefaults {
-    low: string;
-    medium: string;
-    high: string;
-}
+import { ICoinOfflineProtocol } from './ICoinOfflineProtocol';
+import { ICoinOnlineProtocol } from './ICoinOnlineProtocol';
+export { CoinAddress, FeeDefaults } from './ICoinBaseProtocol';
 export interface CurrencyUnit {
     unitSymbol: string;
     factor: string;
 }
-export interface CoinAddress {
-    getValue(): string;
-}
-export interface ICoinProtocol {
-    symbol: string;
-    name: string;
-    marketSymbol: string;
-    feeSymbol: string;
-    feeDefaults: FeeDefaults;
-    decimals: number;
-    feeDecimals: number;
-    identifier: ProtocolSymbols;
-    units: {
-        unitSymbol: string;
-        factor: string;
-    }[];
-    supportsHD: boolean;
-    standardDerivationPath: string;
-    addressIsCaseSensitive: boolean;
-    addressValidationPattern: string;
-    addressPlaceholder: string;
-    subProtocols?: ICoinSubProtocol[];
-    options: ProtocolOptions;
-    cryptoClient: CryptoClient;
-    getBlockExplorerLinkForAddress(address: string): Promise<string>;
-    getBlockExplorerLinkForTxId(txId: string): Promise<string>;
-    getPublicKeyFromMnemonic(mnemonic: string, derivationPath: string, password?: string): Promise<string>;
-    getPrivateKeyFromMnemonic(mnemonic: string, derivationPath: string, password?: string): Promise<Buffer>;
-    getExtendedPrivateKeyFromMnemonic(mnemonic: string, derivationPath: string, password?: string): Promise<string>;
-    getPublicKeyFromHexSecret(secret: string, derivationPath: string): Promise<string>;
-    getPrivateKeyFromHexSecret(secret: string, derivationPath: string): Promise<Buffer>;
-    getExtendedPrivateKeyFromHexSecret(secret: string, derivationPath: string): Promise<string>;
-    getAddressFromPublicKey(publicKey: string): Promise<CoinAddress>;
-    getAddressesFromPublicKey(publicKey: string): Promise<CoinAddress[]>;
-    getAddressFromExtendedPublicKey(extendedPublicKey: string, visibilityDerivationIndex: number, addressDerivationIndex: number): Promise<CoinAddress>;
-    getAddressesFromExtendedPublicKey(extendedPublicKey: string, visibilityDerivationIndex: number, addressCount: number, offset: number): Promise<CoinAddress[]>;
-    getNextAddressFromPublicKey(publicKey: string, current: CoinAddress): Promise<CoinAddress>;
-    getTransactionsFromPublicKey(publicKey: string, limit: number, cursor?: IProtocolTransactionCursor): Promise<IAirGapTransactionResult>;
-    getTransactionsFromExtendedPublicKey(extendedPublicKey: string, limit: number, cursor?: IProtocolTransactionCursor): Promise<IAirGapTransactionResult>;
-    getTransactionsFromAddresses(addresses: string[], limit: number, cursor?: IProtocolTransactionCursor): Promise<IAirGapTransactionResult>;
-    signWithExtendedPrivateKey(extendedPrivateKey: string, transaction: any, childDerivationPath?: string): Promise<IAirGapSignedTransaction>;
-    signWithPrivateKey(privateKey: Buffer, transaction: any): Promise<IAirGapSignedTransaction>;
-    getTransactionDetails(transaction: UnsignedTransaction, data?: {
-        [key: string]: unknown;
-    }): Promise<IAirGapTransaction[]>;
-    getTransactionDetailsFromSigned(transaction: SignedTransaction, data?: {
-        [key: string]: unknown;
-    }): Promise<IAirGapTransaction[]>;
-    getBalanceOfAddresses(addresses: string[], data?: {
-        [key: string]: unknown;
-    }): Promise<string>;
-    getBalanceOfPublicKey(publicKey: string, data?: {
-        addressIndex?: number;
-        [key: string]: unknown;
-    }): Promise<string>;
-    getBalanceOfExtendedPublicKey(extendedPublicKey: string, offset: number, data?: {
-        [key: string]: unknown;
-    }): Promise<string>;
-    getAvailableBalanceOfAddresses(addresses: string[], data?: {
-        [key: string]: unknown;
-    }): Promise<string>;
-    getTransactionStatuses(transactionHash: string[]): Promise<AirGapTransactionStatus[]>;
-    getBalanceOfPublicKeyForSubProtocols(publicKey: string, subProtocols: ICoinSubProtocol[]): Promise<string[]>;
-    estimateMaxTransactionValueFromExtendedPublicKey(extendedPublicKey: string, recipients: string[], fee?: string, data?: {
-        [key: string]: unknown;
-    }): Promise<string>;
-    estimateMaxTransactionValueFromPublicKey(publicKey: string, recipients: string[], fee?: string, data?: {
-        addressIndex?: number;
-        [key: string]: unknown;
-    }): Promise<string>;
-    estimateFeeDefaultsFromExtendedPublicKey(publicKey: string, recipients: string[], values: string[], data?: {
-        [key: string]: unknown;
-    }): Promise<FeeDefaults>;
-    estimateFeeDefaultsFromPublicKey(publicKey: string, recipients: string[], values: string[], data?: {
-        [key: string]: unknown;
-    }): Promise<FeeDefaults>;
-    prepareTransactionFromExtendedPublicKey(extendedPublicKey: string, offset: number, recipients: string[], values: string[], fee: string, extras?: {
-        [key: string]: unknown;
-    }): Promise<any>;
-    prepareTransactionFromPublicKey(publicKey: string, recipients: string[], values: string[], fee: string, extras?: {
-        [key: string]: unknown;
-    }): Promise<any>;
-    broadcastTransaction(rawTransaction: any): Promise<string>;
-    signMessage(message: string, keypair: {
-        publicKey?: string;
-        privateKey: Buffer;
-    }): Promise<string>;
-    verifyMessage(message: string, signature: string, publicKey: string): Promise<boolean>;
-    encryptAsymmetric(payload: string, publicKey: string): Promise<string>;
-    decryptAsymmetric(encryptedPayload: string, keypair: {
-        publicKey?: string;
-        privateKey: Buffer;
-    }): Promise<string>;
-    encryptAES(payload: string, privateKey: Buffer): Promise<string>;
-    decryptAES(encryptedPayload: string, privateKey: Buffer): Promise<string>;
+export interface ICoinProtocol extends ICoinOnlineProtocol, ICoinOfflineProtocol {
 }

package/protocols/NonExtendedProtocol.d.ts

@@ -1,13 +1,14 @@
+import { IAirGapAddressResult } from '../interfaces/IAirGapAddress';
 import { IProtocolTransactionCursor } from '../interfaces/IAirGapTransaction';
-import { FeeDefaults, CoinAddress } from './ICoinProtocol';
+import { FeeDefaults } from './ICoinProtocol';
 import { TezosTransactionResult } from './tezos/types/TezosTransactionResult';
 export declare abstract class NonExtendedProtocol {
     getExtendedPrivateKeyFromMnemonic(mnemonic: string, derivationPath: string, password?: string): Promise<string>;
     getExtendedPrivateKeyFromHexSecret(secret: string, derivationPath: string): Promise<string>;
     getBalanceOfExtendedPublicKey(extendedPublicKey: string, offset: number): Promise<string>;
     signWithExtendedPrivateKey(extendedPrivateKey: string, transaction: any, childDerivationPath: string): Promise<string>;
-    getAddressFromExtendedPublicKey(extendedPublicKey: string, visibilityDerivationIndex: number, addressDerivationIndex: number): Promise<CoinAddress>;
-    getAddressesFromExtendedPublicKey(extendedPublicKey: string, visibilityDerivationIndex: number, addressCount: number, offset: number): Promise<CoinAddress[]>;
+    getAddressFromExtendedPublicKey(extendedPublicKey: string, visibilityDerivationIndex: number, addressDerivationIndex: number): Promise<IAirGapAddressResult>;
+    getAddressesFromExtendedPublicKey(extendedPublicKey: string, visibilityDerivationIndex: number, addressCount: number, offset: number): Promise<IAirGapAddressResult[]>;
     estimateMaxTransactionValueFromExtendedPublicKey(extendedPublicKey: string, recipients: string[], fee: string): Promise<string>;
     estimateFeeDefaultsFromExtendedPublicKey(publicKey: string, recipients: string[], values: string[], data?: any): Promise<FeeDefaults>;
     getTransactionsFromExtendedPublicKey(extendedPublicKey: string, limit: number, cursor: IProtocolTransactionCursor): Promise<TezosTransactionResult>;

package/protocols/NonExtendedProtocol.js

@@ -17,7 +17,10 @@ var NonExtendedProtocol = /** @class */ (function () {
         return Promise.reject('extended private key signing for not implemented');
     };
     NonExtendedProtocol.prototype.getAddressFromExtendedPublicKey = function (extendedPublicKey, visibilityDerivationIndex, addressDerivationIndex) {
-        return Promise.resolve({ getValue: function () { return ''; } });
+        return Promise.resolve({
+            address: '',
+            cursor: { hasNext: false }
+        });
     };
     NonExtendedProtocol.prototype.getAddressesFromExtendedPublicKey = function (extendedPublicKey, visibilityDerivationIndex, addressCount, offset) {
         return Promise.resolve([]);

package/protocols/NonExtendedProtocol.js.map

@@ -1 +1 @@
-{"version":3,"file":"NonExtendedProtocol.js","sourceRoot":"","sources":["../../src/protocols/NonExtendedProtocol.ts"],"names":[],"mappings":";;;AAKA;IAAA;IAgEA,CAAC;IA/DQ,+DAAiC,GAAxC,UAAyC,QAAgB,EAAE,cAAsB,EAAE,QAAiB;QAClG,MAAM,OAAO,CAAC,MAAM,CAAC,8CAA8C,CAAC,CAAA;IACtE,CAAC;IAEM,gEAAkC,GAAzC,UAA0C,MAAc,EAAE,cAAsB;QAC9E,MAAM,OAAO,CAAC,MAAM,CAAC,8CAA8C,CAAC,CAAA;IACtE,CAAC;IAEM,2DAA6B,GAApC,UAAqC,iBAAyB,EAAE,MAAc;QAC5E,OAAO,OAAO,CAAC,MAAM,CAAC,yCAAyC,CAAC,CAAA;IAClE,CAAC;IAEM,wDAA0B,GAAjC,UAAkC,kBAA0B,EAAE,WAAgB,EAAE,mBAA2B;QACzG,OAAO,OAAO,CAAC,MAAM,CAAC,kDAAkD,CAAC,CAAA;IAC3E,CAAC;IAEM,6DAA+B,GAAtC,UACE,iBAAyB,EACzB,yBAAiC,EACjC,sBAA8B;QAE9B,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,cAAM,OAAA,EAAE,EAAF,CAAE,EAAE,CAAC,CAAA;IAChD,CAAC;IAEM,+DAAiC,GAAxC,UACE,iBAAyB,EACzB,yBAAiC,EACjC,YAAoB,EACpB,MAAc;QAEd,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;IAC5B,CAAC;IAEM,8EAAgD,GAAvD,UAAwD,iBAAyB,EAAE,UAAoB,EAAE,GAAW;QAClH,OAAO,OAAO,CAAC,MAAM,CAAC,gEAAgE,CAAC,CAAA;IACzF,CAAC;IAEM,sEAAwC,GAA/C,UACE,SAAiB,EACjB,UAAoB,EACpB,MAAgB,EAChB,IAAU;QAEV,OAAO,OAAO,CAAC,MAAM,CAAC,mEAAmE,CAAC,CAAA;IAC5F,CAAC;IAEM,kEAAoC,GAA3C,UACE,iBAAyB,EACzB,KAAa,EACb,MAAkC;QAElC,OAAO,OAAO,CAAC,MAAM,CAAC,wDAAwD,CAAC,CAAA;IACjF,CAAC;IAEM,qEAAuC,GAA9C,UACE,iBAAyB,EACzB,MAAc,EACd,UAAoB,EACpB,MAAgB,EAChB,GAAW;QAEX,OAAO,OAAO,CAAC,MAAM,CAAC,wCAAwC,CAAC,CAAA;IACjE,CAAC;IACH,0BAAC;AAAD,CAAC,AAhED,IAgEC;AAhEqB,kDAAmB"}
+{"version":3,"file":"NonExtendedProtocol.js","sourceRoot":"","sources":["../../src/protocols/NonExtendedProtocol.ts"],"names":[],"mappings":";;;AAMA;IAAA;IAmEA,CAAC;IAlEQ,+DAAiC,GAAxC,UAAyC,QAAgB,EAAE,cAAsB,EAAE,QAAiB;QAClG,MAAM,OAAO,CAAC,MAAM,CAAC,8CAA8C,CAAC,CAAA;IACtE,CAAC;IAEM,gEAAkC,GAAzC,UAA0C,MAAc,EAAE,cAAsB;QAC9E,MAAM,OAAO,CAAC,MAAM,CAAC,8CAA8C,CAAC,CAAA;IACtE,CAAC;IAEM,2DAA6B,GAApC,UAAqC,iBAAyB,EAAE,MAAc;QAC5E,OAAO,OAAO,CAAC,MAAM,CAAC,yCAAyC,CAAC,CAAA;IAClE,CAAC;IAEM,wDAA0B,GAAjC,UAAkC,kBAA0B,EAAE,WAAgB,EAAE,mBAA2B;QACzG,OAAO,OAAO,CAAC,MAAM,CAAC,kDAAkD,CAAC,CAAA;IAC3E,CAAC;IAEM,6DAA+B,GAAtC,UACE,iBAAyB,EACzB,yBAAiC,EACjC,sBAA8B;QAE9B,OAAO,OAAO,CAAC,OAAO,CAAC;YACrB,OAAO,EAAE,EAAE;YACX,MAAM,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE;SAC3B,CAAC,CAAA;IACJ,CAAC;IAEM,+DAAiC,GAAxC,UACE,iBAAyB,EACzB,yBAAiC,EACjC,YAAoB,EACpB,MAAc;QAEd,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;IAC5B,CAAC;IAEM,8EAAgD,GAAvD,UAAwD,iBAAyB,EAAE,UAAoB,EAAE,GAAW;QAClH,OAAO,OAAO,CAAC,MAAM,CAAC,gEAAgE,CAAC,CAAA;IACzF,CAAC;IAEM,sEAAwC,GAA/C,UACE,SAAiB,EACjB,UAAoB,EACpB,MAAgB,EAChB,IAAU;QAEV,OAAO,OAAO,CAAC,MAAM,CAAC,mEAAmE,CAAC,CAAA;IAC5F,CAAC;IAEM,kEAAoC,GAA3C,UACE,iBAAyB,EACzB,KAAa,EACb,MAAkC;QAElC,OAAO,OAAO,CAAC,MAAM,CAAC,wDAAwD,CAAC,CAAA;IACjF,CAAC;IAEM,qEAAuC,GAA9C,UACE,iBAAyB,EACzB,MAAc,EACd,UAAoB,EACpB,MAAgB,EAChB,GAAW;QAEX,OAAO,OAAO,CAAC,MAAM,CAAC,wCAAwC,CAAC,CAAA;IACjE,CAAC;IACH,0BAAC;AAAD,CAAC,AAnED,IAmEC;AAnEqB,kDAAmB"}

package/protocols/Secp256k1CryptoClient.d.ts

@@ -1,9 +1,8 @@
-/// <reference types="node" />
 import { CryptoClient } from './CryptoClient';
 export declare abstract class Secp256k1CryptoClient extends CryptoClient {
     encryptAsymmetric(payload: string, publicKey: string): Promise<string>;
     decryptAsymmetric(encryptedPayload: string, keypair: {
         publicKey: string;
-        privateKey: Buffer;
+        privateKey: string;
     }): Promise<string>;
 }

package/protocols/Secp256k1CryptoClient.js

@@ -67,7 +67,7 @@ var Secp256k1CryptoClient = /** @class */ (function (_super) {
     Secp256k1CryptoClient.prototype.decryptAsymmetric = function (encryptedPayload, keypair) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                return [2 /*return*/, index_1.decrypt(keypair.privateKey.toString('hex'), Buffer.from(encryptedPayload, 'hex')).toString()];
+                return [2 /*return*/, index_1.decrypt(keypair.privateKey, Buffer.from(encryptedPayload, 'hex')).toString()];
             });
         });
     };

package/protocols/Secp256k1CryptoClient.js.map

@@ -1 +1 @@
-{"version":3,"file":"Secp256k1CryptoClient.js","sourceRoot":"","sources":["../../src/protocols/Secp256k1CryptoClient.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,qEAA8E;AAE9E,+CAA6C;AAE7C;IAAoD,yCAAY;IAAhE;;IAQA,CAAC;IAPc,iDAAiB,GAA9B,UAA+B,OAAe,EAAE,SAAiB;;;gBAC/D,sBAAO,eAAO,CAAC,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAA;;;KAChE;IAEY,iDAAiB,GAA9B,UAA+B,gBAAwB,EAAE,OAAkD;;;gBACzG,sBAAO,eAAO,CAAC,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,gBAAgB,EAAE,KAAK,CAAC,CAAC,CAAC,QAAQ,EAAE,EAAA;;;KACpG;IACH,4BAAC;AAAD,CAAC,AARD,CAAoD,2BAAY,GAQ/D;AARqB,sDAAqB"}
+{"version":3,"file":"Secp256k1CryptoClient.js","sourceRoot":"","sources":["../../src/protocols/Secp256k1CryptoClient.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,qEAA8E;AAE9E,+CAA6C;AAE7C;IAAoD,yCAAY;IAAhE;;IAQA,CAAC;IAPc,iDAAiB,GAA9B,UAA+B,OAAe,EAAE,SAAiB;;;gBAC/D,sBAAO,eAAO,CAAC,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAA;;;KAChE;IAEY,iDAAiB,GAA9B,UAA+B,gBAAwB,EAAE,OAAkD;;;gBACzG,sBAAO,eAAO,CAAC,OAAO,CAAC,UAAU,EAAE,MAAM,CAAC,IAAI,CAAC,gBAAgB,EAAE,KAAK,CAAC,CAAC,CAAC,QAAQ,EAAE,EAAA;;;KACpF;IACH,4BAAC;AAAD,CAAC,AARD,CAAoD,2BAAY,GAQ/D;AARqB,sDAAqB"}

package/protocols/Sr25519CryptoClient.d.ts

@@ -1,9 +1,8 @@
-/// <reference types="node" />
 import { CryptoClient } from './CryptoClient';
 export declare abstract class Sr25519CryptoClient extends CryptoClient {
     encryptAsymmetric(payload: string, publicKey: string): Promise<string>;
     decryptAsymmetric(encryptedPayload: string, keypair: {
         publicKey: string;
-        privateKey: Buffer;
+        privateKey: string;
     }): Promise<string>;
 }

package/protocols/aeternity/AeternityAddress.d.ts

@@ -3,5 +3,5 @@ export declare class AeternityAddress implements CoinAddress {
     private readonly value;
     private constructor();
     static from(publicKey: string): AeternityAddress;
-    getValue(): string;
+    asString(): string;
 }

package/protocols/aeternity/AeternityAddress.js

@@ -29,7 +29,7 @@ var AeternityAddress = /** @class */ (function () {
         var base58 = bs58check.encode(Buffer.from(publicKey, 'hex'));
         return new AeternityAddress("ak_" + base58);
     };
-    AeternityAddress.prototype.getValue = function () {
+    AeternityAddress.prototype.asString = function () {
         return this.value;
     };
     return AeternityAddress;

package/protocols/aeternity/AeternityCryptoClient.d.ts

@@ -1,9 +1,8 @@
-/// <reference types="node" />
 import { Ed25519CryptoClient } from '../Ed25519CryptoClient';
 export declare class AeternityCryptoClient extends Ed25519CryptoClient {
     constructor();
     signMessage(message: string, keypair: {
-        privateKey: Buffer;
+        privateKey: string;
     }): Promise<string>;
     verifyMessage(message: string, signature: string, publicKey: string): Promise<boolean>;
 }

package/protocols/aeternity/AeternityCryptoClient.js

@@ -76,7 +76,7 @@ var AeternityCryptoClient = /** @class */ (function (_super) {
                     case 1:
                         _a.sent();
                         messageBuffer = personalMessageToBinary(message);
-                        rawSignature = sodium.crypto_sign_detached(messageBuffer, keypair.privateKey);
+                        rawSignature = sodium.crypto_sign_detached(messageBuffer, Buffer.from(keypair.privateKey, 'hex'));
                         return [2 /*return*/, Buffer.from(rawSignature).toString('hex')];
                 }
             });

package/protocols/aeternity/AeternityCryptoClient.js.map

@@ -1 +1 @@
-{"version":3,"file":"AeternityCryptoClient.js","sourceRoot":"","sources":["../../../src/protocols/aeternity/AeternityCryptoClient.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2CAA6C;AAC7C,uCAAgD;AAChD,4DAAmD;AAEnD,8DAA4D;AAE5D,IAAM,uBAAuB,GAAG,UAAC,OAAe;IAC9C,IAAM,MAAM,GAAW,MAAM,CAAC,IAAI,CAAC,6BAA6B,EAAE,MAAM,CAAC,CAAA;IACzE,IAAM,aAAa,GAAW,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAA;IAC1D,IAAI,aAAa,CAAC,MAAM,IAAI,IAAI,EAAE;QAChC,MAAM,IAAI,0BAAiB,CAAC,sBAAM,CAAC,SAAS,EAAE,kBAAkB,CAAC,CAAA;KAClE;IAED,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAA;AAClH,CAAC,CAAA;AAED;IAA2C,yCAAmB;IAC5D;eACE,iBAAO;IACT,CAAC;IAEY,2CAAW,GAAxB,UAAyB,OAAe,EAAE,OAA+B;;;;;4BACvE,qBAAM,MAAM,CAAC,KAAK,EAAA;;wBAAlB,SAAkB,CAAA;wBAEZ,aAAa,GAAW,uBAAuB,CAAC,OAAO,CAAC,CAAA;wBACxD,YAAY,GAAe,MAAM,CAAC,oBAAoB,CAAC,aAAa,EAAE,OAAO,CAAC,UAAU,CAAC,CAAA;wBAE/F,sBAAO,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAA;;;;KACjD;IAEY,6CAAa,GAA1B,UAA2B,OAAe,EAAE,SAAiB,EAAE,SAAiB;;;;;4BAC9E,qBAAM,MAAM,CAAC,KAAK,EAAA;;wBAAlB,SAAkB,CAAA;wBAEZ,YAAY,GAAW,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;wBACpD,aAAa,GAAW,uBAAuB,CAAC,OAAO,CAAC,CAAA;wBAE9D,sBAAO,MAAM,CAAC,2BAA2B,CAAC,YAAY,EAAE,aAAa,EAAE,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC,EAAA;;;;KACtG;IACH,4BAAC;AAAD,CAAC,AAtBD,CAA2C,yCAAmB,GAsB7D;AAtBY,sDAAqB"}
+{"version":3,"file":"AeternityCryptoClient.js","sourceRoot":"","sources":["../../../src/protocols/aeternity/AeternityCryptoClient.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2CAA6C;AAC7C,uCAAgD;AAChD,4DAAmD;AAEnD,8DAA4D;AAE5D,IAAM,uBAAuB,GAAG,UAAC,OAAe;IAC9C,IAAM,MAAM,GAAW,MAAM,CAAC,IAAI,CAAC,6BAA6B,EAAE,MAAM,CAAC,CAAA;IACzE,IAAM,aAAa,GAAW,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAA;IAC1D,IAAI,aAAa,CAAC,MAAM,IAAI,IAAI,EAAE;QAChC,MAAM,IAAI,0BAAiB,CAAC,sBAAM,CAAC,SAAS,EAAE,kBAAkB,CAAC,CAAA;KAClE;IAED,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAA;AAClH,CAAC,CAAA;AAED;IAA2C,yCAAmB;IAC5D;eACE,iBAAO;IACT,CAAC;IAEY,2CAAW,GAAxB,UAAyB,OAAe,EAAE,OAA+B;;;;;4BACvE,qBAAM,MAAM,CAAC,KAAK,EAAA;;wBAAlB,SAAkB,CAAA;wBAEZ,aAAa,GAAW,uBAAuB,CAAC,OAAO,CAAC,CAAA;wBACxD,YAAY,GAAe,MAAM,CAAC,oBAAoB,CAAC,aAAa,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC,CAAA;wBAEnH,sBAAO,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAA;;;;KACjD;IAEY,6CAAa,GAA1B,UAA2B,OAAe,EAAE,SAAiB,EAAE,SAAiB;;;;;4BAC9E,qBAAM,MAAM,CAAC,KAAK,EAAA;;wBAAlB,SAAkB,CAAA;wBAEZ,YAAY,GAAW,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;wBACpD,aAAa,GAAW,uBAAuB,CAAC,OAAO,CAAC,CAAA;wBAE9D,sBAAO,MAAM,CAAC,2BAA2B,CAAC,YAAY,EAAE,aAAa,EAAE,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC,EAAA;;;;KACtG;IACH,4BAAC;AAAD,CAAC,AAtBD,CAA2C,yCAAmB,GAsB7D;AAtBY,sDAAqB"}

package/protocols/aeternity/AeternityProtocol.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { IAirGapSignedTransaction } from '../../interfaces/IAirGapSignedTransaction';
 import { AirGapTransactionStatus, IAirGapTransaction } from '../../interfaces/IAirGapTransaction';
 import { SignedAeternityTransaction } from '../../serializer/schemas/definitions/signed-transaction-aeternity';
@@ -8,10 +7,9 @@ import { ProtocolSymbols } from '../../utils/ProtocolSymbols';
 import { CurrencyUnit, FeeDefaults, ICoinProtocol } from '../ICoinProtocol';
 import { ICoinSubProtocol } from '../ICoinSubProtocol';
 import { NonExtendedProtocol } from '../NonExtendedProtocol';
-import { AeternityTransactionCursor, AeternityTransactionResult } from './AeternityTypes';
-import { AeternityAddress } from './AeternityAddress';
 import { AeternityCryptoClient } from './AeternityCryptoClient';
 import { AeternityProtocolOptions } from './AeternityProtocolOptions';
+import { AeternityAddressCursor, AeternityAddressResult, AeternityTransactionCursor, AeternityTransactionResult } from './AeternityTypes';
 export declare class AeternityProtocol extends NonExtendedProtocol implements ICoinProtocol {
     readonly options: AeternityProtocolOptions;
     symbol: string;
@@ -39,7 +37,7 @@ export declare class AeternityProtocol extends NonExtendedProtocol implements IC
     getBlockExplorerLinkForAddress(address: string): Promise<string>;
     getBlockExplorerLinkForTxId(txId: string): Promise<string>;
     getPublicKeyFromMnemonic(mnemonic: string, derivationPath: string, password?: string): Promise<string>;
-    getPrivateKeyFromMnemonic(mnemonic: string, derivationPath: string, password?: string): Promise<Buffer>;
+    getPrivateKeyFromMnemonic(mnemonic: string, derivationPath: string, password?: string): Promise<string>;
     /**
      * Returns the PublicKey as String, derived from a supplied hex-string
      * @param secret HEX-Secret from BIP39
@@ -51,14 +49,13 @@ export declare class AeternityProtocol extends NonExtendedProtocol implements IC
      * @param secret HEX-Secret from BIP39
      * @param derivationPath DerivationPath for Key
      */
-    getPrivateKeyFromHexSecret(secret: string, derivationPath: string): Promise<Buffer>;
-    getAddressFromPublicKey(publicKey: string): Promise<AeternityAddress>;
-    getAddressesFromPublicKey(publicKey: string): Promise<AeternityAddress[]>;
-    getNextAddressFromPublicKey(publicKey: string, current: AeternityAddress): Promise<AeternityAddress>;
+    getPrivateKeyFromHexSecret(secret: string, derivationPath: string): Promise<string>;
+    getAddressFromPublicKey(publicKey: string, cursor?: AeternityAddressCursor): Promise<AeternityAddressResult>;
+    getAddressesFromPublicKey(publicKey: string, cursor?: AeternityAddressCursor): Promise<AeternityAddressResult[]>;
     getTransactionsFromPublicKey(publicKey: string, limit: number, cursor?: AeternityTransactionCursor): Promise<AeternityTransactionResult>;
     getTransactionsFromAddresses(addresses: string[], limit: number, cursor?: AeternityTransactionCursor): Promise<AeternityTransactionResult>;
     protected getPageNumber(limit: number, offset: number): number;
-    signWithPrivateKey(privateKey: Buffer, transaction: RawAeternityTransaction): Promise<IAirGapSignedTransaction>;
+    signWithPrivateKey(privateKey: string, transaction: RawAeternityTransaction): Promise<IAirGapSignedTransaction>;
     private decodeTx;
     getTransactionDetails(unsignedTx: UnsignedAeternityTransaction): Promise<IAirGapTransaction[]>;
     getTransactionDetailsFromSigned(signedTx: SignedAeternityTransaction): Promise<IAirGapTransaction[]>;
@@ -81,15 +78,15 @@ export declare class AeternityProtocol extends NonExtendedProtocol implements IC
     broadcastTransaction(rawTransaction: string): Promise<string>;
     private toHexBuffer;
     signMessage(message: string, keypair: {
-        privateKey: Buffer;
+        privateKey: string;
     }): Promise<string>;
     verifyMessage(message: string, signature: string, publicKey: string): Promise<boolean>;
     encryptAsymmetric(message: string, publicKey: string): Promise<string>;
     decryptAsymmetric(message: string, keypair: {
         publicKey: string;
-        privateKey: Buffer;
+        privateKey: string;
     }): Promise<string>;
-    encryptAES(message: string, privateKey: Buffer): Promise<string>;
-    decryptAES(message: string, privateKey: Buffer): Promise<string>;
+    encryptAES(message: string, privateKey: string): Promise<string>;
+    decryptAES(message: string, privateKey: string): Promise<string>;
     getTransactionStatuses(transactionHashes: string[]): Promise<AirGapTransactionStatus[]>;
 }