@baking-bad/tezos-etherlink-bridge-sdk/dist/types/tokenBridge/tokenBridge.d.ts

SDK designed for building token bridge applications between Tezos (L1) and Etherlink (L2)

import type { TokenBridgeComponents } from './tokenBridgeComponents';
import type { SignerTokenBalances, TokenBridgeDataApi } from './tokenBridgeDataApi';
import type { TokenBridgeOptions } from './tokenBridgeOptions';
import type { TokenBridgeStreamApi } from './tokenBridgeStreamApi';
import type { EtherlinkBridgeBlockchainService, TezosBridgeBlockchainService } from '../bridgeBlockchainService';
import { BridgeTokenTransferStatus, type TokenPair, type DepositOptions, type DepositResult, type StartWithdrawResult, type FinishWithdrawResult, type BridgeTokenTransfer, type PendingBridgeTokenDeposit, type CreatedBridgeTokenDeposit, type FinishedBridgeTokenDeposit, type PendingBridgeTokenWithdrawal, type CreatedBridgeTokenWithdrawal, type SealedBridgeTokenWithdrawal, type FinishedBridgeTokenWithdrawal } from '../bridgeCore';
import type { AccountTokenBalance, AccountTokenBalances, BalancesFetchOptions, TokensFetchOptions, TransfersFetchOptions } from '../bridgeDataProviders';
import { type PublicEventEmitter } from '../common';
import type { TezosToken, NativeTezosToken, NonNativeTezosToken, EtherlinkToken, NativeEtherlinkToken, NonNativeEtherlinkToken } from '../tokens';
interface TokenBridgeComponentsEvents {
    readonly tokenTransferCreated: PublicEventEmitter<readonly [tokenTransfer: BridgeTokenTransfer]>;
    readonly tokenTransferUpdated: PublicEventEmitter<readonly [tokenTransfer: BridgeTokenTransfer]>;
}
export declare class TokenBridge<TTezosBridgeBlockchainService extends TezosBridgeBlockchainService = TezosBridgeBlockchainService, TEtherlinkBridgeBlockchainService extends EtherlinkBridgeBlockchainService = EtherlinkBridgeBlockchainService> implements Disposable {
    private static readonly defaultLastCreatedTokenTransfersTimerPeriod;
    private static readonly defaultLastCreatedTokenTransferLifetime;
    readonly data: TokenBridgeDataApi;
    readonly stream: TokenBridgeStreamApi;
    readonly bridgeComponents: TokenBridgeComponents<TTezosBridgeBlockchainService, TEtherlinkBridgeBlockchainService>;
    protected readonly events: TokenBridgeComponentsEvents;
    protected readonly tokenTransferStatusWatchers: Map<string, Map<BridgeTokenTransferStatus, {
        readonly promise: Promise<BridgeTokenTransfer>;
        readonly resolve: (transfer: BridgeTokenTransfer) => void;
        readonly reject: (error: unknown) => void;
    }>>;
    private readonly lastCreatedTokenTransfers;
    private lastCreatedTokenTransfersTimerId;
    private _isDisposed;
    constructor(options: TokenBridgeOptions<TTezosBridgeBlockchainService, TEtherlinkBridgeBlockchainService>);
    get isDisposed(): boolean;
    addEventListener<EventType extends keyof TokenBridgeComponentsEvents>(type: EventType, listener: Parameters<TokenBridgeComponentsEvents[EventType]['addListener']>[0]): void;
    removeEventListener<EventType extends keyof TokenBridgeComponentsEvents>(type: EventType, listener: Parameters<TokenBridgeComponentsEvents[EventType]['addListener']>[0]): void;
    removeAllEventListeners<EventType extends keyof TokenBridgeComponentsEvents>(type: EventType): void;
    waitForStatus(transfer: PendingBridgeTokenDeposit, status: BridgeTokenTransferStatus.Created): Promise<CreatedBridgeTokenDeposit>;
    waitForStatus(transfer: PendingBridgeTokenDeposit | CreatedBridgeTokenDeposit, status: BridgeTokenTransferStatus.Finished): Promise<FinishedBridgeTokenDeposit>;
    waitForStatus(transfer: PendingBridgeTokenWithdrawal, status: BridgeTokenTransferStatus.Created): Promise<CreatedBridgeTokenWithdrawal>;
    waitForStatus(transfer: PendingBridgeTokenWithdrawal | CreatedBridgeTokenWithdrawal, status: BridgeTokenTransferStatus.Sealed): Promise<SealedBridgeTokenWithdrawal>;
    waitForStatus(transfer: PendingBridgeTokenWithdrawal | CreatedBridgeTokenWithdrawal | SealedBridgeTokenWithdrawal, status: BridgeTokenTransferStatus.Finished): Promise<FinishedBridgeTokenWithdrawal>;
    waitForStatus(transfer: BridgeTokenTransfer, status: BridgeTokenTransferStatus): Promise<BridgeTokenTransfer>;
    deposit(amount: bigint, token: NativeTezosToken): Promise<DepositResult<TTezosBridgeBlockchainService['depositNativeToken']>>;
    deposit(amount: bigint, token: NativeTezosToken, etherlinkReceiverAddress: string): Promise<DepositResult<TTezosBridgeBlockchainService['depositNativeToken']>>;
    deposit(amount: bigint, token: NativeTezosToken, options: DepositOptions): Promise<DepositResult<TTezosBridgeBlockchainService['depositNativeToken']>>;
    deposit(amount: bigint, token: NativeTezosToken, etherlinkReceiverAddress: string, options: DepositOptions): Promise<DepositResult<TTezosBridgeBlockchainService['depositNativeToken']>>;
    deposit(amount: bigint, token: NonNativeTezosToken): Promise<DepositResult<TTezosBridgeBlockchainService['depositNonNativeToken']>>;
    deposit(amount: bigint, token: NonNativeTezosToken, etherlinkReceiverAddress: string): Promise<DepositResult<TTezosBridgeBlockchainService['depositNonNativeToken']>>;
    deposit(amount: bigint, token: NonNativeTezosToken, options: DepositOptions): Promise<DepositResult<TTezosBridgeBlockchainService['depositNonNativeToken']>>;
    deposit(amount: bigint, token: NonNativeTezosToken, etherlinkReceiverAddress: string, options: DepositOptions): Promise<DepositResult<TTezosBridgeBlockchainService['depositNonNativeToken']>>;
    deposit(amount: bigint, token: TezosToken, etherlinkReceiverAddressOrOptions?: string | DepositOptions, options?: DepositOptions): Promise<DepositResult<TTezosBridgeBlockchainService['depositNativeToken']> | DepositResult<TTezosBridgeBlockchainService['depositNonNativeToken']>>;
    startWithdraw(amount: bigint, token: NativeEtherlinkToken, tezosReceiverAddress?: string): Promise<StartWithdrawResult<TEtherlinkBridgeBlockchainService['withdrawNativeToken']>>;
    startWithdraw(amount: bigint, token: NonNativeEtherlinkToken, tezosReceiverAddress?: string): Promise<StartWithdrawResult<TEtherlinkBridgeBlockchainService['withdrawNonNativeToken']>>;
    startWithdraw(amount: bigint, token: EtherlinkToken, tezosReceiverAddress?: string): Promise<StartWithdrawResult<TEtherlinkBridgeBlockchainService['withdrawNativeToken']> | StartWithdrawResult<TEtherlinkBridgeBlockchainService['withdrawNonNativeToken']>>;
    finishWithdraw(sealedBridgeTokenWithdrawal: SealedBridgeTokenWithdrawal): Promise<FinishWithdrawResult<TTezosBridgeBlockchainService['finishWithdraw']>>;
    getTezosSignerAddress(): Promise<string | undefined>;
    getEtherlinkSignerAddress(): Promise<string | undefined>;
    [Symbol.dispose](): void;
    protected getBalance(accountAddress: string, token: TezosToken | EtherlinkToken): Promise<AccountTokenBalance>;
    protected getBalances(accountAddress: string): Promise<AccountTokenBalances>;
    protected getBalances(accountAddress: string, tokens: ReadonlyArray<TezosToken | EtherlinkToken>): Promise<AccountTokenBalances>;
    protected getBalances(accountAddress: string, fetchOptions: BalancesFetchOptions): Promise<AccountTokenBalances>;
    protected getBalances(accountAddress: string, tokensOfFetchOptions?: ReadonlyArray<TezosToken | EtherlinkToken> | BalancesFetchOptions): Promise<AccountTokenBalances>;
    protected getRegisteredTokenPair(token: TezosToken | EtherlinkToken): Promise<TokenPair | null>;
    protected getRegisteredTokenPairs(): Promise<TokenPair[]>;
    protected getRegisteredTokenPairs(fetchOptions: TokensFetchOptions): Promise<TokenPair[]>;
    protected getRegisteredTokenPairs(fetchOptions?: TokensFetchOptions): Promise<TokenPair[]>;
    protected getTokenTransfer(tokenTransferId: string): Promise<BridgeTokenTransfer | null>;
    protected getTokenTransfers(): Promise<BridgeTokenTransfer[]>;
    protected getTokenTransfers(fetchOptions: TransfersFetchOptions): Promise<BridgeTokenTransfer[]>;
    protected getTokenTransfers(fetchOptions?: TransfersFetchOptions): Promise<BridgeTokenTransfer[]>;
    protected getAccountTokenTransfers(accountAddress: string): Promise<BridgeTokenTransfer[]>;
    protected getAccountTokenTransfers(accountAddresses: readonly string[]): Promise<BridgeTokenTransfer[]>;
    protected getAccountTokenTransfers(accountAddress: string, fetchOptions: TransfersFetchOptions): Promise<BridgeTokenTransfer[]>;
    protected getAccountTokenTransfers(accountAddresses: readonly string[], fetchOptions: TransfersFetchOptions): Promise<BridgeTokenTransfer[]>;
    protected getAccountTokenTransfers(accountAddressOrAddresses: string | readonly string[], fetchOptions?: TransfersFetchOptions): Promise<BridgeTokenTransfer[]>;
    protected getOperationTokenTransfers(operationHash: string): Promise<BridgeTokenTransfer[]>;
    protected getOperationTokenTransfers(tokenTransfer: BridgeTokenTransfer): Promise<BridgeTokenTransfer[]>;
    protected getOperationTokenTransfers(operationHashOrTokenTransfer: string | BridgeTokenTransfer): Promise<BridgeTokenTransfer[]>;
    protected getSignerBalances(): Promise<SignerTokenBalances>;
    protected getSignerTokenTransfers(): Promise<BridgeTokenTransfer[]>;
    protected getSignerTokenTransfers(fetchOptions: TransfersFetchOptions): Promise<BridgeTokenTransfer[]>;
    protected getSignerTokenTransfers(fetchOptions?: TransfersFetchOptions): Promise<BridgeTokenTransfer[]>;
    protected subscribeToTokenTransfer(tokenTransferId: string): void;
    protected unsubscribeFromTokenTransfer(tokenTransferId: string): void;
    protected subscribeToTokenTransfers(): void;
    protected unsubscribeFromTokenTransfers(): void;
    protected subscribeToAccountTokenTransfers(accountAddress: string): void;
    protected subscribeToAccountTokenTransfers(accountAddresses: readonly string[]): void;
    protected subscribeToAccountTokenTransfers(accountAddressOrAddresses: string | readonly string[]): void;
    protected unsubscribeFromAccountTokenTransfers(accountAddress: string): void;
    protected unsubscribeFromAccountTokenTransfers(accountAddresses: readonly string[]): void;
    protected unsubscribeFromAccountTokenTransfers(accountAddressOrAddresses: string | readonly string[]): void;
    protected subscribeToOperationTokenTransfers(transfer: BridgeTokenTransfer): void;
    protected subscribeToOperationTokenTransfers(operationHash: BridgeTokenTransfer): void;
    protected subscribeToOperationTokenTransfers(operationHashOrTokenTransfer: string | BridgeTokenTransfer): void;
    protected unsubscribeFromOperationTokenTransfers(transfer: BridgeTokenTransfer): void;
    protected unsubscribeFromOperationTokenTransfers(operationHash: BridgeTokenTransfer): void;
    protected unsubscribeFromOperationTokenTransfers(operationHashOrTokenTransfer: string | BridgeTokenTransfer): void;
    protected unsubscribeFromOperationTokenTransfers(operationHashOrTokenTransfer: string | BridgeTokenTransfer): void;
    protected unsubscribeFromAllSubscriptions(): void;
    protected emitLocalTokenTransferCreatedEvent(tokenTransfer: BridgeTokenTransfer): void;
    protected emitTokenTransferCreatedOrUpdatedEvent(tokenTransfer: BridgeTokenTransfer): void;
    protected resolveStatusWatcherIfNeeded(tokenTransfer: BridgeTokenTransfer): void;
    protected rejectAndClearAllStatusWatchers(error: unknown): void;
    protected attachEvents(): void;
    protected detachEvents(): void;
    protected handleTransfersBridgeDataProviderTokenTransferCreated: (createdTokenTransfer: BridgeTokenTransfer) => void;
    protected handleTransfersBridgeDataProviderTokenTransferUpdated: (updatedTokenTransfer: BridgeTokenTransfer) => void;
    protected ensureIsNotDisposed(): void;
    private ensureLastCreatedTokenTransfersTimerIsStarted;
    private getRequiredTezosSignerAddress;
    private getRequiredEtherlinkSignerAddress;
}
export {};