@wallfree-dev/cosmos-core 0.13.42

package/v1/protocol/CosmosBaseProtocol.d.ts

@@ -0,0 +1,100 @@
+import { DelegateeDetails, DelegatorDetails } from '@wallfree-dev/coinlib-core';
+import { DelegationDetails } from '@wallfree-dev/coinlib-core/protocols/ICoinDelegateProtocol';
+import { Address, AirGapProtocol, AirGapTransaction, AirGapTransactionsWithCursor, Amount, Balance, CryptoDerivative, FeeDefaults, KeyPair, ProtocolMetadata, PublicKey, SecretKey, Signature, TransactionFullConfiguration, TransactionDetails } from '@wallfree-dev/module-kit';
+import { AirGapDelegateProtocol } from '@wallfree-dev/module-kit/internal';
+import { CosmosCryptoConfiguration } from '../types/crypto';
+import { CosmosTransaction } from '../types/data/transaction/CosmosTransaction';
+import { CosmosProtocolNetwork, CosmosProtocolOptions } from '../types/protocol';
+import { CosmosDelegation, CosmosUnbondingDelegation, CosmosValidator } from '../types/rpc';
+import { CosmosDelegationActionType, CosmosSignedTransaction, CosmosTransactionCursor, CosmosUnsignedTransaction } from '../types/transaction';
+export interface CosmosBaseProtocol<_Units extends string> extends AirGapProtocol<{
+    AddressResult: Address;
+    ProtocolNetwork: CosmosProtocolNetwork;
+    CryptoConfiguration: CosmosCryptoConfiguration;
+    SignedTransaction: CosmosSignedTransaction;
+    TransactionCursor: CosmosTransactionCursor;
+    Units: _Units;
+    FeeEstimation: FeeDefaults<_Units>;
+    UnsignedTransaction: CosmosUnsignedTransaction;
+}, 'Crypto', 'FetchDataForAddress'> {
+    getKeyPairFromSecretKey(secretKey: SecretKey): Promise<KeyPair>;
+}
+export interface CosmosBaseStakingProtocol<_Units extends string> extends CosmosBaseProtocol<_Units>, AirGapDelegateProtocol {
+    prepareDelegatorActionFromPublicKey(publicKey: PublicKey, type: CosmosDelegationActionType, data?: {
+        validator: Address;
+        amount?: string;
+    }): Promise<CosmosTransaction[]>;
+    undelegate(publicKey: PublicKey, validatorAddress: Address, amount: Amount<_Units>, memo?: string): Promise<CosmosTransaction>;
+    delegate(publicKey: PublicKey, validatorAddress: Address | string[], amount: Amount<_Units>, undelegate: boolean, memo?: string): Promise<CosmosTransaction>;
+    withdrawDelegationRewards(publicKey: PublicKey, validatorAddresses: Address[], memo?: string): Promise<CosmosTransaction>;
+    withdrawAllDelegationRewards(delegatorAddress: Address, fee: Amount<_Units>, memo?: string): Promise<string>;
+    fetchTotalReward(delegatorAddress: Address): Promise<Amount<_Units>>;
+    fetchRewardForDelegation(delegatorAddress: Address, validatorAddress: Address): Promise<Amount<_Units>>;
+    fetchDelegations(address: Address): Promise<CosmosDelegation[]>;
+    fetchTotalDelegatedAmount(address: Address): Promise<Amount<_Units>>;
+    fetchValidator(address: Address): Promise<CosmosValidator>;
+    fetchValidators(): Promise<CosmosValidator[]>;
+    fetchUnbondingDelegations(delegatorAddress: Address): Promise<CosmosUnbondingDelegation[]>;
+    fetchTotalUnbondingAmount(address: Address): Promise<Amount<_Units>>;
+    fetchSelfDelegation(address: Address): Promise<CosmosDelegation>;
+}
+export declare abstract class CosmosBaseProtocolImpl<_Units extends string> implements CosmosBaseStakingProtocol<_Units> {
+    protected readonly options: CosmosProtocolOptions<_Units>;
+    private readonly nodeClient;
+    private readonly cryptoClient;
+    private readonly cryptoConfiguration;
+    constructor(options: CosmosProtocolOptions<_Units>);
+    getKeyPairFromSecretKey(secretKey: SecretKey): Promise<KeyPair>;
+    getCryptoConfiguration(): Promise<CosmosCryptoConfiguration>;
+    getKeyPairFromDerivative(derivative: CryptoDerivative): Promise<KeyPair>;
+    signTransactionWithSecretKey(transaction: CosmosUnsignedTransaction, secretKey: SecretKey): Promise<CosmosSignedTransaction>;
+    abstract getMetadata(): Promise<ProtocolMetadata<_Units, _Units>>;
+    getAddressFromPublicKey(publicKey: PublicKey): Promise<string>;
+    getDetailsFromTransaction(transaction: CosmosSignedTransaction | CosmosUnsignedTransaction, publicKey: PublicKey): Promise<AirGapTransaction<_Units, _Units>[]>;
+    private getDetailsFromSignedTransaction;
+    private getDetailsFromUnsignedTransaction;
+    getNetwork(): Promise<CosmosProtocolNetwork>;
+    getTransactionsForPublicKey(publicKey: PublicKey, limit: number, cursor?: CosmosTransactionCursor | undefined): Promise<AirGapTransactionsWithCursor<CosmosTransactionCursor, _Units, _Units>>;
+    getBalanceOfPublicKey(publicKey: PublicKey, configuration?: undefined): Promise<Balance<_Units>>;
+    getTransactionMaxAmountWithPublicKey(publicKey: PublicKey, to: string[], configuration?: TransactionFullConfiguration<_Units> | undefined): Promise<Amount<_Units>>;
+    abstract getTransactionFeeWithPublicKey(publicKey: PublicKey, details: TransactionDetails<_Units>[]): Promise<FeeDefaults<_Units>>;
+    prepareTransactionWithPublicKey(publicKey: PublicKey, details: TransactionDetails<_Units>[], configuration?: TransactionFullConfiguration<_Units> | undefined): Promise<CosmosUnsignedTransaction>;
+    broadcastTransaction(transaction: CosmosSignedTransaction): Promise<string>;
+    signMessageWithKeyPair(message: string, keyPair: KeyPair): Promise<Signature>;
+    verifyMessageWithPublicKey(message: string, signature: Signature, publicKey: PublicKey): Promise<boolean>;
+    decryptAsymmetricWithKeyPair(payload: string, keyPair: KeyPair): Promise<string>;
+    encryptAsymmetricWithPublicKey(payload: string, publicKey: PublicKey): Promise<string>;
+    encryptAESWithSecretKey(payload: string, secretKey: SecretKey): Promise<string>;
+    decryptAESWithSecretKey(payload: string, secretKey: SecretKey): Promise<string>;
+    getTransactionsForAddress(address: string, limit: number, cursor?: CosmosTransactionCursor | undefined): Promise<AirGapTransactionsWithCursor<CosmosTransactionCursor, _Units, _Units>>;
+    getBalanceOfAddress(address: string, _configuration?: undefined): Promise<Balance<_Units>>;
+    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>;
+    private getDelegatorDetails;
+    private getAvailableDelegatorActions;
+    getDelegationDetailsFromPublicKey(publicKey: PublicKey, delegatees: string[]): Promise<DelegationDetails>;
+    getDelegationDetailsFromAddress(address: string, delegatees: string[]): Promise<DelegationDetails>;
+    prepareDelegatorActionFromPublicKey(publicKey: PublicKey, type: CosmosDelegationActionType, data?: {
+        validator: string;
+        amount?: string;
+    } | undefined): Promise<CosmosTransaction[]>;
+    undelegate(publicKey: PublicKey, validatorAddress: string, amount: Amount<_Units>, memo?: string | undefined): Promise<CosmosTransaction>;
+    delegate(publicKey: PublicKey, validatorAddress: string | string[], amount: Amount<_Units>, undelegate: boolean, memo?: string | undefined): Promise<CosmosTransaction>;
+    withdrawDelegationRewards(publicKey: PublicKey, _validatorAddresses: string[], memo?: string | undefined): Promise<CosmosTransaction>;
+    withdrawAllDelegationRewards(delegatorAddress: string, fee: Amount<_Units>, memo?: string | undefined): Promise<string>;
+    fetchTotalReward(delegatorAddress: string): Promise<Amount<_Units>>;
+    fetchRewardForDelegation(delegatorAddress: string, validatorAddress: string): Promise<Amount<_Units>>;
+    fetchDelegations(address: string): Promise<CosmosDelegation[]>;
+    fetchTotalDelegatedAmount(address: string): Promise<Amount<_Units>>;
+    fetchValidator(address: string): Promise<CosmosValidator>;
+    fetchValidators(): Promise<CosmosValidator[]>;
+    fetchUnbondingDelegations(delegatorAddress: string): Promise<CosmosUnbondingDelegation[]>;
+    fetchTotalUnbondingAmount(address: string): Promise<Amount<_Units>>;
+    fetchSelfDelegation(address: string): Promise<CosmosDelegation>;
+}