Hierarchy

  • Algonaut

Constructors

  • Instantiates Algonaut.js.

    Example

    Usage:

    import { Algonaut } from '@thencc/algonautjs';
    const algonaut = new Algonaut({
    nodeConfig: {
    BASE_SERVER: 'https://testnet-algorand.api.purestake.io/ps2',
    INDEX_SERVER: 'https://testnet-algorand.api.purestake.io/idx2'
    LEDGER: 'TestNet',
    PORT: '',
    API_TOKEN: { 'X-API-Key': 'YOUR_API_TOKEN' }
    }
    });

    Parameters

    Returns Algonaut

Properties

account: null | {
    active: boolean;
    address: string;
    chain: string;
    name: string;
    walletId: WALLET_ID;
} = ...
algodClient: default
indexerClient: undefined | default = ...
libConfig: undefined | {
    disableLogs?: boolean;
} = defaultLibConfig
nodeConfig: {
    API_TOKEN: any;
    BASE_SERVER: string;
    INDEX_SERVER?: string;
    LEDGER: string;
    PORT: string;
} = defaultNodeConfig

Type declaration

  • API_TOKEN: any
  • BASE_SERVER: string
  • Optional INDEX_SERVER?: string
  • LEDGER: string
  • PORT: string
sdk: __module = algosdk
walletState: {
    activeAccount: null | {
        active: boolean;
        address: string;
        chain: string;
        name: string;
        walletId: WALLET_ID;
    };
    activeAddress: string;
    activeWallet: undefined | {
        accounts: readonly {
            active: boolean;
            address: string;
            chain: string;
            name: string;
            walletId: WALLET_ID;
        }[];
        activeAccount: undefined | {
            active: boolean;
            address: string;
            chain: string;
            name: string;
            walletId: WALLET_ID;
        };
        client: null | {
            connect: ((x: any) => Promise<Wallet>);
            disconnect: (() => Promise<void>);
            reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
            signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
        };
        connect: ((p?: any) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: WALLET_ID;
        initParams: boolean | {
            config?: any;
            sdk?: any;
        };
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<true>);
        metadata: {
            chain: string;
            icon: string;
            id: WALLET_ID;
            name: string;
            pkg: string;
        };
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
        signing: boolean;
    };
    activeWalletId: null | WALLET_ID;
    allWallets: {
        algosigner?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
        defly?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
        exodus?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
        inkey?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
        mnemonic?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
        myalgo?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
        pera?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
    };
    connectedAccounts: readonly {
        active: boolean;
        address: string;
        chain: string;
        name: string;
        walletId: WALLET_ID;
    }[];
    enabledWallets: null | {
        algosigner?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
        defly?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
        exodus?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
        inkey?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
        mnemonic?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
        myalgo?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
        pera?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
    };
    isSigning: boolean;
    stored: {
        activeAccount: null | {
            active: boolean;
            address: string;
            chain: string;
            name: string;
            walletId: WALLET_ID;
        };
        connectedAccounts: {
            active: boolean;
            address: string;
            chain: string;
            name: string;
            walletId: WALLET_ID;
        }[];
        version: number;
    };
} = AnyWalletState

Type declaration

  • activeAccount: null | {
        active: boolean;
        address: string;
        chain: string;
        name: string;
        walletId: WALLET_ID;
    }
  • activeAddress: string
  • activeWallet: undefined | {
        accounts: readonly {
            active: boolean;
            address: string;
            chain: string;
            name: string;
            walletId: WALLET_ID;
        }[];
        activeAccount: undefined | {
            active: boolean;
            address: string;
            chain: string;
            name: string;
            walletId: WALLET_ID;
        };
        client: null | {
            connect: ((x: any) => Promise<Wallet>);
            disconnect: (() => Promise<void>);
            reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
            signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
        };
        connect: ((p?: any) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: WALLET_ID;
        initParams: boolean | {
            config?: any;
            sdk?: any;
        };
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<true>);
        metadata: {
            chain: string;
            icon: string;
            id: WALLET_ID;
            name: string;
            pkg: string;
        };
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
        signing: boolean;
    }
  • activeWalletId: null | WALLET_ID
  • allWallets: {
        algosigner?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
        defly?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
        exodus?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
        inkey?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
        mnemonic?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
        myalgo?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
        pera?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
    }
    • Optional algosigner?: {
          accounts: readonly {
              active: boolean;
              address: string;
              chain: string;
              name: string;
              walletId: WALLET_ID;
          }[];
          activeAccount: undefined | {
              active: boolean;
              address: string;
              chain: string;
              name: string;
              walletId: WALLET_ID;
          };
          client: null | {
              connect: ((x: any) => Promise<Wallet>);
              disconnect: (() => Promise<void>);
              reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
              signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
          };
          connect: ((p?: any) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: WALLET_ID;
          initParams: boolean | {
              config?: any;
              sdk?: any;
          };
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<true>);
          metadata: {
              chain: string;
              icon: string;
              id: WALLET_ID;
              name: string;
              pkg: string;
          };
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
          signing: boolean;
      }
      • Readonly accounts: readonly {
            active: boolean;
            address: string;
            chain: string;
            name: string;
            walletId: WALLET_ID;
        }[]
      • Readonly activeAccount: undefined | {
            active: boolean;
            address: string;
            chain: string;
            name: string;
            walletId: WALLET_ID;
        }
      • client: null | {
            connect: ((x: any) => Promise<Wallet>);
            disconnect: (() => Promise<void>);
            reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
            signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
        }
      • connect: ((p?: any) => Promise<Account[]>)
          • (p?: any): Promise<Account[]>
          • Parameters

            • Optional p: any

            Returns Promise<Account[]>

      • connecting: boolean
      • disconnect: (() => Promise<void>)
          • (): Promise<void>
          • Returns Promise<void>

      • id: WALLET_ID
      • initParams: boolean | {
            config?: any;
            sdk?: any;
        }
      • inited: boolean
      • initing: boolean
      • Readonly isActive: boolean
      • Readonly isConnected: boolean
      • loadClient: (() => Promise<true>)
          • (): Promise<true>
          • Returns Promise<true>

      • metadata: {
            chain: string;
            icon: string;
            id: WALLET_ID;
            name: string;
            pkg: string;
        }
        • chain: string
        • icon: string
        • id: WALLET_ID
        • name: string
        • pkg: string
      • reconnect: (() => Promise<void>)
          • (): Promise<void>
          • Returns Promise<void>

      • removeAccounts: (() => void)
          • (): void
          • Returns void

      • setAsActiveWallet: (() => void)
          • (): void
          • Returns void

      • signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>)
          • (transactions: Uint8Array[]): Promise<Uint8Array[]>
          • Parameters

            • transactions: Uint8Array[]

            Returns Promise<Uint8Array[]>

      • signing: boolean
    • Optional defly?: {
          accounts: readonly {
              active: boolean;
              address: string;
              chain: string;
              name: string;
              walletId: WALLET_ID;
          }[];
          activeAccount: undefined | {
              active: boolean;
              address: string;
              chain: string;
              name: string;
              walletId: WALLET_ID;
          };
          client: null | {
              connect: ((x: any) => Promise<Wallet>);
              disconnect: (() => Promise<void>);
              reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
              signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
          };
          connect: ((p?: any) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: WALLET_ID;
          initParams: boolean | {
              config?: any;
              sdk?: any;
          };
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<true>);
          metadata: {
              chain: string;
              icon: string;
              id: WALLET_ID;
              name: string;
              pkg: string;
          };
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
          signing: boolean;
      }
      • Readonly accounts: readonly {
            active: boolean;
            address: string;
            chain: string;
            name: string;
            walletId: WALLET_ID;
        }[]
      • Readonly activeAccount: undefined | {
            active: boolean;
            address: string;
            chain: string;
            name: string;
            walletId: WALLET_ID;
        }
      • client: null | {
            connect: ((x: any) => Promise<Wallet>);
            disconnect: (() => Promise<void>);
            reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
            signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
        }
      • connect: ((p?: any) => Promise<Account[]>)
          • (p?: any): Promise<Account[]>
          • Parameters

            • Optional p: any

            Returns Promise<Account[]>

      • connecting: boolean
      • disconnect: (() => Promise<void>)
          • (): Promise<void>
          • Returns Promise<void>

      • id: WALLET_ID
      • initParams: boolean | {
            config?: any;
            sdk?: any;
        }
      • inited: boolean
      • initing: boolean
      • Readonly isActive: boolean
      • Readonly isConnected: boolean
      • loadClient: (() => Promise<true>)
          • (): Promise<true>
          • Returns Promise<true>

      • metadata: {
            chain: string;
            icon: string;
            id: WALLET_ID;
            name: string;
            pkg: string;
        }
        • chain: string
        • icon: string
        • id: WALLET_ID
        • name: string
        • pkg: string
      • reconnect: (() => Promise<void>)
          • (): Promise<void>
          • Returns Promise<void>

      • removeAccounts: (() => void)
          • (): void
          • Returns void

      • setAsActiveWallet: (() => void)
          • (): void
          • Returns void

      • signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>)
          • (transactions: Uint8Array[]): Promise<Uint8Array[]>
          • Parameters

            • transactions: Uint8Array[]

            Returns Promise<Uint8Array[]>

      • signing: boolean
    • Optional exodus?: {
          accounts: readonly {
              active: boolean;
              address: string;
              chain: string;
              name: string;
              walletId: WALLET_ID;
          }[];
          activeAccount: undefined | {
              active: boolean;
              address: string;
              chain: string;
              name: string;
              walletId: WALLET_ID;
          };
          client: null | {
              connect: ((x: any) => Promise<Wallet>);
              disconnect: (() => Promise<void>);
              reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
              signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
          };
          connect: ((p?: any) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: WALLET_ID;
          initParams: boolean | {
              config?: any;
              sdk?: any;
          };
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<true>);
          metadata: {
              chain: string;
              icon: string;
              id: WALLET_ID;
              name: string;
              pkg: string;
          };
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
          signing: boolean;
      }
      • Readonly accounts: readonly {
            active: boolean;
            address: string;
            chain: string;
            name: string;
            walletId: WALLET_ID;
        }[]
      • Readonly activeAccount: undefined | {
            active: boolean;
            address: string;
            chain: string;
            name: string;
            walletId: WALLET_ID;
        }
      • client: null | {
            connect: ((x: any) => Promise<Wallet>);
            disconnect: (() => Promise<void>);
            reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
            signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
        }
      • connect: ((p?: any) => Promise<Account[]>)
          • (p?: any): Promise<Account[]>
          • Parameters

            • Optional p: any

            Returns Promise<Account[]>

      • connecting: boolean
      • disconnect: (() => Promise<void>)
          • (): Promise<void>
          • Returns Promise<void>

      • id: WALLET_ID
      • initParams: boolean | {
            config?: any;
            sdk?: any;
        }
      • inited: boolean
      • initing: boolean
      • Readonly isActive: boolean
      • Readonly isConnected: boolean
      • loadClient: (() => Promise<true>)
          • (): Promise<true>
          • Returns Promise<true>

      • metadata: {
            chain: string;
            icon: string;
            id: WALLET_ID;
            name: string;
            pkg: string;
        }
        • chain: string
        • icon: string
        • id: WALLET_ID
        • name: string
        • pkg: string
      • reconnect: (() => Promise<void>)
          • (): Promise<void>
          • Returns Promise<void>

      • removeAccounts: (() => void)
          • (): void
          • Returns void

      • setAsActiveWallet: (() => void)
          • (): void
          • Returns void

      • signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>)
          • (transactions: Uint8Array[]): Promise<Uint8Array[]>
          • Parameters

            • transactions: Uint8Array[]

            Returns Promise<Uint8Array[]>

      • signing: boolean
    • Optional inkey?: {
          accounts: readonly {
              active: boolean;
              address: string;
              chain: string;
              name: string;
              walletId: WALLET_ID;
          }[];
          activeAccount: undefined | {
              active: boolean;
              address: string;
              chain: string;
              name: string;
              walletId: WALLET_ID;
          };
          client: null | {
              connect: ((x: any) => Promise<Wallet>);
              disconnect: (() => Promise<void>);
              reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
              signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
          };
          connect: ((p?: any) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: WALLET_ID;
          initParams: boolean | {
              config?: any;
              sdk?: any;
          };
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<true>);
          metadata: {
              chain: string;
              icon: string;
              id: WALLET_ID;
              name: string;
              pkg: string;
          };
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
          signing: boolean;
      }
      • Readonly accounts: readonly {
            active: boolean;
            address: string;
            chain: string;
            name: string;
            walletId: WALLET_ID;
        }[]
      • Readonly activeAccount: undefined | {
            active: boolean;
            address: string;
            chain: string;
            name: string;
            walletId: WALLET_ID;
        }
      • client: null | {
            connect: ((x: any) => Promise<Wallet>);
            disconnect: (() => Promise<void>);
            reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
            signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
        }
      • connect: ((p?: any) => Promise<Account[]>)
          • (p?: any): Promise<Account[]>
          • Parameters

            • Optional p: any

            Returns Promise<Account[]>

      • connecting: boolean
      • disconnect: (() => Promise<void>)
          • (): Promise<void>
          • Returns Promise<void>

      • id: WALLET_ID
      • initParams: boolean | {
            config?: any;
            sdk?: any;
        }
      • inited: boolean
      • initing: boolean
      • Readonly isActive: boolean
      • Readonly isConnected: boolean
      • loadClient: (() => Promise<true>)
          • (): Promise<true>
          • Returns Promise<true>

      • metadata: {
            chain: string;
            icon: string;
            id: WALLET_ID;
            name: string;
            pkg: string;
        }
        • chain: string
        • icon: string
        • id: WALLET_ID
        • name: string
        • pkg: string
      • reconnect: (() => Promise<void>)
          • (): Promise<void>
          • Returns Promise<void>

      • removeAccounts: (() => void)
          • (): void
          • Returns void

      • setAsActiveWallet: (() => void)
          • (): void
          • Returns void

      • signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>)
          • (transactions: Uint8Array[]): Promise<Uint8Array[]>
          • Parameters

            • transactions: Uint8Array[]

            Returns Promise<Uint8Array[]>

      • signing: boolean
    • Optional mnemonic?: {
          accounts: readonly {
              active: boolean;
              address: string;
              chain: string;
              name: string;
              walletId: WALLET_ID;
          }[];
          activeAccount: undefined | {
              active: boolean;
              address: string;
              chain: string;
              name: string;
              walletId: WALLET_ID;
          };
          client: null | {
              connect: ((x: any) => Promise<Wallet>);
              disconnect: (() => Promise<void>);
              reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
              signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
          };
          connect: ((p?: any) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: WALLET_ID;
          initParams: boolean | {
              config?: any;
              sdk?: any;
          };
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<true>);
          metadata: {
              chain: string;
              icon: string;
              id: WALLET_ID;
              name: string;
              pkg: string;
          };
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
          signing: boolean;
      }
      • Readonly accounts: readonly {
            active: boolean;
            address: string;
            chain: string;
            name: string;
            walletId: WALLET_ID;
        }[]
      • Readonly activeAccount: undefined | {
            active: boolean;
            address: string;
            chain: string;
            name: string;
            walletId: WALLET_ID;
        }
      • client: null | {
            connect: ((x: any) => Promise<Wallet>);
            disconnect: (() => Promise<void>);
            reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
            signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
        }
      • connect: ((p?: any) => Promise<Account[]>)
          • (p?: any): Promise<Account[]>
          • Parameters

            • Optional p: any

            Returns Promise<Account[]>

      • connecting: boolean
      • disconnect: (() => Promise<void>)
          • (): Promise<void>
          • Returns Promise<void>

      • id: WALLET_ID
      • initParams: boolean | {
            config?: any;
            sdk?: any;
        }
      • inited: boolean
      • initing: boolean
      • Readonly isActive: boolean
      • Readonly isConnected: boolean
      • loadClient: (() => Promise<true>)
          • (): Promise<true>
          • Returns Promise<true>

      • metadata: {
            chain: string;
            icon: string;
            id: WALLET_ID;
            name: string;
            pkg: string;
        }
        • chain: string
        • icon: string
        • id: WALLET_ID
        • name: string
        • pkg: string
      • reconnect: (() => Promise<void>)
          • (): Promise<void>
          • Returns Promise<void>

      • removeAccounts: (() => void)
          • (): void
          • Returns void

      • setAsActiveWallet: (() => void)
          • (): void
          • Returns void

      • signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>)
          • (transactions: Uint8Array[]): Promise<Uint8Array[]>
          • Parameters

            • transactions: Uint8Array[]

            Returns Promise<Uint8Array[]>

      • signing: boolean
    • Optional myalgo?: {
          accounts: readonly {
              active: boolean;
              address: string;
              chain: string;
              name: string;
              walletId: WALLET_ID;
          }[];
          activeAccount: undefined | {
              active: boolean;
              address: string;
              chain: string;
              name: string;
              walletId: WALLET_ID;
          };
          client: null | {
              connect: ((x: any) => Promise<Wallet>);
              disconnect: (() => Promise<void>);
              reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
              signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
          };
          connect: ((p?: any) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: WALLET_ID;
          initParams: boolean | {
              config?: any;
              sdk?: any;
          };
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<true>);
          metadata: {
              chain: string;
              icon: string;
              id: WALLET_ID;
              name: string;
              pkg: string;
          };
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
          signing: boolean;
      }
      • Readonly accounts: readonly {
            active: boolean;
            address: string;
            chain: string;
            name: string;
            walletId: WALLET_ID;
        }[]
      • Readonly activeAccount: undefined | {
            active: boolean;
            address: string;
            chain: string;
            name: string;
            walletId: WALLET_ID;
        }
      • client: null | {
            connect: ((x: any) => Promise<Wallet>);
            disconnect: (() => Promise<void>);
            reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
            signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
        }
      • connect: ((p?: any) => Promise<Account[]>)
          • (p?: any): Promise<Account[]>
          • Parameters

            • Optional p: any

            Returns Promise<Account[]>

      • connecting: boolean
      • disconnect: (() => Promise<void>)
          • (): Promise<void>
          • Returns Promise<void>

      • id: WALLET_ID
      • initParams: boolean | {
            config?: any;
            sdk?: any;
        }
      • inited: boolean
      • initing: boolean
      • Readonly isActive: boolean
      • Readonly isConnected: boolean
      • loadClient: (() => Promise<true>)
          • (): Promise<true>
          • Returns Promise<true>

      • metadata: {
            chain: string;
            icon: string;
            id: WALLET_ID;
            name: string;
            pkg: string;
        }
        • chain: string
        • icon: string
        • id: WALLET_ID
        • name: string
        • pkg: string
      • reconnect: (() => Promise<void>)
          • (): Promise<void>
          • Returns Promise<void>

      • removeAccounts: (() => void)
          • (): void
          • Returns void

      • setAsActiveWallet: (() => void)
          • (): void
          • Returns void

      • signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>)
          • (transactions: Uint8Array[]): Promise<Uint8Array[]>
          • Parameters

            • transactions: Uint8Array[]

            Returns Promise<Uint8Array[]>

      • signing: boolean
    • Optional pera?: {
          accounts: readonly {
              active: boolean;
              address: string;
              chain: string;
              name: string;
              walletId: WALLET_ID;
          }[];
          activeAccount: undefined | {
              active: boolean;
              address: string;
              chain: string;
              name: string;
              walletId: WALLET_ID;
          };
          client: null | {
              connect: ((x: any) => Promise<Wallet>);
              disconnect: (() => Promise<void>);
              reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
              signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
          };
          connect: ((p?: any) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: WALLET_ID;
          initParams: boolean | {
              config?: any;
              sdk?: any;
          };
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<true>);
          metadata: {
              chain: string;
              icon: string;
              id: WALLET_ID;
              name: string;
              pkg: string;
          };
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
          signing: boolean;
      }
      • Readonly accounts: readonly {
            active: boolean;
            address: string;
            chain: string;
            name: string;
            walletId: WALLET_ID;
        }[]
      • Readonly activeAccount: undefined | {
            active: boolean;
            address: string;
            chain: string;
            name: string;
            walletId: WALLET_ID;
        }
      • client: null | {
            connect: ((x: any) => Promise<Wallet>);
            disconnect: (() => Promise<void>);
            reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
            signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
        }
      • connect: ((p?: any) => Promise<Account[]>)
          • (p?: any): Promise<Account[]>
          • Parameters

            • Optional p: any

            Returns Promise<Account[]>

      • connecting: boolean
      • disconnect: (() => Promise<void>)
          • (): Promise<void>
          • Returns Promise<void>

      • id: WALLET_ID
      • initParams: boolean | {
            config?: any;
            sdk?: any;
        }
      • inited: boolean
      • initing: boolean
      • Readonly isActive: boolean
      • Readonly isConnected: boolean
      • loadClient: (() => Promise<true>)
          • (): Promise<true>
          • Returns Promise<true>

      • metadata: {
            chain: string;
            icon: string;
            id: WALLET_ID;
            name: string;
            pkg: string;
        }
        • chain: string
        • icon: string
        • id: WALLET_ID
        • name: string
        • pkg: string
      • reconnect: (() => Promise<void>)
          • (): Promise<void>
          • Returns Promise<void>

      • removeAccounts: (() => void)
          • (): void
          • Returns void

      • setAsActiveWallet: (() => void)
          • (): void
          • Returns void

      • signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>)
          • (transactions: Uint8Array[]): Promise<Uint8Array[]>
          • Parameters

            • transactions: Uint8Array[]

            Returns Promise<Uint8Array[]>

      • signing: boolean
  • connectedAccounts: readonly {
        active: boolean;
        address: string;
        chain: string;
        name: string;
        walletId: WALLET_ID;
    }[]
  • enabledWallets: null | {
        algosigner?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
        defly?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
        exodus?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
        inkey?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
        mnemonic?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
        myalgo?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
        pera?: {
            accounts: readonly {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            }[];
            activeAccount: undefined | {
                active: boolean;
                address: string;
                chain: string;
                name: string;
                walletId: WALLET_ID;
            };
            client: null | {
                connect: ((x: any) => Promise<Wallet>);
                disconnect: (() => Promise<void>);
                reconnect: ((onDisconnect: (() => void)) => Promise<null | Wallet>);
                signTransactions: ((connectedAccounts: string[], transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            };
            connect: ((p?: any) => Promise<Account[]>);
            connecting: boolean;
            disconnect: (() => Promise<void>);
            id: WALLET_ID;
            initParams: boolean | {
                config?: any;
                sdk?: any;
            };
            inited: boolean;
            initing: boolean;
            isActive: boolean;
            isConnected: boolean;
            loadClient: (() => Promise<true>);
            metadata: {
                chain: string;
                icon: string;
                id: WALLET_ID;
                name: string;
                pkg: string;
            };
            reconnect: (() => Promise<void>);
            removeAccounts: (() => void);
            setAsActiveWallet: (() => void);
            signTransactions: ((transactions: Uint8Array[]) => Promise<Uint8Array[]>);
            signing: boolean;
        };
    }
  • isSigning: boolean
  • stored: {
        activeAccount: null | {
            active: boolean;
            address: string;
            chain: string;
            name: string;
            walletId: WALLET_ID;
        };
        connectedAccounts: {
            active: boolean;
            address: string;
            chain: string;
            name: string;
            walletId: WALLET_ID;
        }[];
        version: number;
    }
    • activeAccount: null | {
          active: boolean;
          address: string;
          chain: string;
          name: string;
          walletId: WALLET_ID;
      }
    • connectedAccounts: {
          active: boolean;
          address: string;
          chain: string;
          name: string;
          walletId: WALLET_ID;
      }[]
    • version: number

Accessors

  • get connectedAccounts(): readonly {
        active: boolean;
        address: string;
        chain: string;
        name: string;
        walletId: WALLET_ID;
    }[]
  • Returns readonly {
        active: boolean;
        address: string;
        chain: string;
        name: string;
        walletId: WALLET_ID;
    }[]

Methods

  • Checks if account has at least one token (before playback) Keeping this here in case this is a faster/less expensive operation than checking actual balance

    Parameters

    • address: string

      Address to check

    • assetIndex: number

      the index of the ASA

    Returns Promise<boolean>

  • Used for decoding state

    Returns

    Human-readable string

    Parameters

    • encoded: string

      Base64 string

    Returns string

  • Checks status of Algorand network

    Returns

    Promise resolving to status of Algorand network

    Returns Promise<any>

  • Compiles TEAL source via algodClient.compile

    Returns

    Promise resolving to Buffer of compiled bytes

    Parameters

    • programSource: string

      source to compile

    Returns Promise<Uint8Array>

  • Connects a wallet to be used as algonaut.account. uses: - the SINGLE passed in init params for the specified wallet

    • or, the SINGLE enabled wallet IF 1 wallet is enabled (as is the default. just inkey) FAILs and throws when multiple init params are passed in or multiple wallets are enabled when nothing is passed in (since it doesnt know which to connect up)

    Parameters

    Returns Promise<Account[]>

  • Creates a wallet address + mnemonic from account's secret key. Changed in 0.3: this does NOT set algonaut.account.

    Returns

    AlgonautWallet Object containing address and mnemonic

    Returns AlgonautWallet

  • Does what it says on the tin.

    Returns

    transaction object

    Parameters

    • txn: string

      base64-encoded unsigned transaction

    Returns Transaction

  • disconnects - the active wallet IF no arg passed in - all the wallets IF "true" is passed in as an arg - or, specific wallets if an array of wallet ids is passed in. (ex: ["inkey", "algosigner", "mnemonic"] )

    Parameters

    Returns Promise<void>

  • Sync function that returns a correctly-encoded argument array for an algo transaction

    Returns

    a Uint8Array of encoded arguments

    Parameters

    • args: any[]

      must be an any[] array, as it will often need to be a mix of strings and numbers. Valid types are: string, number, and bigint

    Returns Uint8Array[]

  • Deprecated

    Use b64StrToHumanStr instead

    Returns

    Human-readable string

    Parameters

    • encoded: string

      Base64 string

    Returns string

  • Creates a LogicSig from a base64 program string. Note that this method does not COMPILE the program, just builds an LSig from an already compiled base64 result!

    Returns

    an algosdk LogicSigAccount

    Parameters

    • base64ProgramString: string

    Returns LogicSigAccount

  • Fetch full account info for an account

    Returns

    Promise of type AccountInfo

    Parameters

    • address: string

      the accress to read info for

    Returns Promise<any>

  • Checks Algo balance of account

    Returns

    Promise resolving to Algo balance

    Parameters

    • address: string

      Wallet of balance to check

    Returns Promise<any>

  • Get an application's escrow account

    Returns

    Escrow account address as string

    Parameters

    • appId: number | bigint

      ID of application

    Returns string

  • Gets global state for an application.

    Returns

    object representing global state

    Parameters

    • applicationIndex: number

      the applications index

    Returns Promise<any>

  • Get info about an application (globals, locals, creator address, index)

    Returns

    Promise resolving to application state

    Parameters

    • appId: number

      ID of application

    Returns Promise<AlgonautAppState>

  • Gets account local state for an app. Defaults to AnyWallets.activeAddress unless an address is provided.

    Parameters

    • applicationIndex: number

      the applications index

    • Optional address: string

    Returns Promise<void | AlgonautAppState>

  • Get info about an asset

    Returns

    Parameters

    • assetIndex: number

    Returns Promise<any>

  • Returns

    nodeConfig object or false if no nodeConfig is set

    Returns undefined | boolean | {
        API_TOKEN: any;
        BASE_SERVER: string;
        INDEX_SERVER?: string;
        LEDGER: string;
        PORT: string;
    }

  • Checks token balance of account

    Returns

    Promise resolving to token balance

    Parameters

    • address: string

      Wallet of balance to check

    • assetIndex: number

      the ASA index

    Returns Promise<number>

  • Deprecated

    use .connect or loop through enabled wallets' methods

    Returns Promise<Account[]>

  • Deprecated

    use .disconnect or loop through enabled wallets' methods

    Returns Promise<void>

  • Hides the inkey-wallet modal

    Returns

    Returns Promise<void>

  • Shows the inkey-wallet modal

    Returns

    Returns Promise<void>

  • You can be opted into an asset but still have a zero balance. Use this call for cases where you just need to know the address's opt-in state

    Returns

    boolean true if account holds asset

    Parameters

    • args: {
          account: string;
          assetId: number;
      }

      object containing account and assetId properties

      • account: string
      • assetId: number

    Returns Promise<boolean>

  • checks if config obj is valid for use

    Returns

    boolean. true is good.

    Parameters

    • Optional nodeConfig: {
          API_TOKEN: any;
          BASE_SERVER: string;
          INDEX_SERVER?: string;
          LEDGER: string;
          PORT: string;
      }
      • API_TOKEN: any
      • BASE_SERVER: string
      • Optional INDEX_SERVER?: string
      • LEDGER: string
      • PORT: string

    Returns boolean

  • Deprecated

    use .connect() with mnemonic arg Recovers account from mnemonic (helpful for rapid development but overall very insecure unless on server-side)

    Returns

    If mnemonic is valid, it returns the account (address, chain). Otherwise, throws an error.

    Parameters

    • mnemonic: string

      Mnemonic associated with Algonaut account

    Returns Promise<Account[]>

  • Recovers account from mnemonic Changed in 0.3: this does NOT set algonaut.account.

    Returns

    If mnemonic is valid, returns algosdk account (.addr, .sk). Otherwise, throws an error.

    Parameters

    • mnemonic: string

      Mnemonic associated with Algonaut account

    Returns default

  • Parameters

    • Optional libConfig: {
          disableLogs?: boolean;
      }
      • Optional disableLogs?: boolean

    Returns void

  • sets config for use (new algod, indexerClient, etc)

    Parameters

    • Optional nodeConfig: {
          API_TOKEN: any;
          BASE_SERVER: string;
          INDEX_SERVER?: string;
          LEDGER: string;
          PORT: string;
      } | "testnet" | "mainnet"

    Returns void

  • Helper function to turn globals and locals array into more useful objects

    Returns

    A more useful object: { array[0].key: array[0].value, array[1].key: array[1].value, ... } TODO add correct typing for this method

    Parameters

    • stateArray: object[]

      State array returned from functions like getAppInfo

    Returns any

  • Deprecated

    use toUint8Array instead.

    Returns

    string encoded as Uint8Array

    Parameters

    • str: string

      string

    • enc: BufferEncoding = 'utf8'

      the encoding type of the string (defaults to utf8)

    Returns Uint8Array

  • Returns

    string encoded as Uint8Array

    Parameters

    • str: string

      string

    • enc: BufferEncoding = 'utf8'

      the encoding type of the string (defaults to utf8)

    Returns Uint8Array

  • txn(b64) -> txnBuff (buffer)

    Returns

    trransaction as buffer object

    Parameters

    • txn: string

      base64-encoded unsigned transaction

    Returns Buffer

  • Converts between buff -> b64 (txns)

    Returns

    string (like for inkey / base64 transmit use)

    Parameters

    • buff: Uint8Array

      likely a algorand txn as a Uint8Array buffer

    Returns string

  • Describes an Algorand transaction, for display in Inkey

    Parameters

    • txn: Transaction

      Transaction to describe

    Returns string

  • Does what it says on the tin.

    Returns

    string (like for inkey / base64 transmit use)

    Parameters

    • txn: Transaction

      algorand txn object

    Returns string

  • Decodes a Base64-encoded Uint8 Algorand address and returns a string

    Returns

    Decoded address

    Parameters

    • encoded: string

      An encoded Algorand address

    Returns string

  • General purpose method to await transaction confirmation

    Parameters

    • txId: string

      a string id of the transacion you want to watch

    • Optional limitDelta: number

      how many rounds to wait, defaults to 50

    • log: boolean = false

      set to true if you'd like to see "waiting for confirmation" log messages

    Returns Promise<AlgonautTransactionStatus>

Generated using TypeDoc