Class Algonaut

Hierarchy

Algonaut

Index

Constructors

constructor

new Algonaut(config?: AlgonautConfig): Algonaut

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

Optional config: AlgonautConfig

config object

Returns Algonaut

Properties

account

account: null | {
    active: boolean;
    address: string;
    chain: string;
    name: string;
    walletId: WALLET_ID;
} = ...

algodClient

algodClient: default

indexerClient

indexerClient: undefined | default = ...

libConfig

libConfig: undefined | {
disableLogs?: boolean;
} = defaultLibConfig

nodeConfig

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

sdk: __module = algosdk

walletState

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

connectedAccounts

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;
}[]
- Defined in src/index.ts:121

Methods

accountHasTokens

accountHasTokens(address: string, assetIndex: number): Promise<boolean>
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>
- Defined in src/index.ts:1522

atomicAssetTransferWithLSig

atomicAssetTransferWithLSig(args: AlgonautLsigSendAssetArguments): Promise<AlgonautAtomicTransaction>
Parameters
- args: AlgonautLsigSendAssetArguments
Returns Promise<AlgonautAtomicTransaction>
- Defined in src/index.ts:1618

atomicCallApp

atomicCallApp(args: AlgonautCallAppArguments): Promise<AlgonautAtomicTransaction>
Parameters
- args: AlgonautCallAppArguments
Returns Promise<AlgonautAtomicTransaction>
- Defined in src/index.ts:976

atomicCallAppWithLSig

atomicCallAppWithLSig(args: AlgonautLsigCallAppArguments): Promise<AlgonautAtomicTransaction>
Parameters
- args: AlgonautLsigCallAppArguments
Returns Promise<AlgonautAtomicTransaction>
- Defined in src/index.ts:1012

atomicCloseOutApp

atomicCloseOutApp(args: AlgonautCallAppArguments): Promise<AlgonautAtomicTransaction>
Returns an atomic transaction that closes out the user's local state in an application. The opposite of atomicOptInApp.

Returns
Promise resolving to atomic transaction
Parameters
- args: AlgonautCallAppArguments
  
  Object containing appIndex, appArgs, and optionalFields properties
Returns Promise<AlgonautAtomicTransaction>
- Defined in src/index.ts:1041

atomicCreateApp

atomicCreateApp(args: AlgonautDeployArguments): Promise<AlgonautAtomicTransaction>
Create an atomic transaction to deploy a new Smart Contract from TEAL code

Returns
AlgonautAtomicTransaction
Parameters
- args: AlgonautDeployArguments
  
  AlgonautDeployArguments
Returns Promise<AlgonautAtomicTransaction>
- Defined in src/index.ts:1213

atomicCreateAsset

atomicCreateAsset(args: AlgonautCreateAssetArguments): Promise<AlgonautAtomicTransaction>
Create asset transaction

Returns
atomic txn to create asset
Parameters
- args: AlgonautCreateAssetArguments
  
  : AlgonautCreateAssetArguments obj must contain: assetName, symbol, decimals, amount.
Returns Promise<AlgonautAtomicTransaction>
- Defined in src/index.ts:694

atomicDeleteApp

atomicDeleteApp(appIndex: number, optionalTxnArgs?: AlgonautTransactionFields): Promise<AlgonautAtomicTransaction>
Returns atomic transaction that deletes application

Returns
Promise resolving to atomic transaction that deletes application
Parameters
- appIndex: number
  
  ID of application
- Optional optionalTxnArgs: AlgonautTransactionFields
Returns Promise<AlgonautAtomicTransaction>
- Defined in src/index.ts:930

atomicDeleteAsset

atomicDeleteAsset(assetId: number, optionalTxnArgs?: AlgonautTransactionFields): Promise<AlgonautAtomicTransaction>
Parameters
- assetId: number
- Optional optionalTxnArgs: AlgonautTransactionFields
Returns Promise<AlgonautAtomicTransaction>
- Defined in src/index.ts:787

atomicOptInApp

atomicOptInApp(args: AlgonautCallAppArguments): Promise<AlgonautAtomicTransaction>
Creates transaction to opt into an app

Returns
AlgonautAtomicTransaction
Parameters
- args: AlgonautCallAppArguments
  
  AlgonautCallAppArgs
Returns Promise<AlgonautAtomicTransaction>
- Defined in src/index.ts:891

atomicOptInAsset

atomicOptInAsset(assetIndex: number, optionalTxnArgs?: AlgonautTransactionFields): Promise<AlgonautAtomicTransaction>
Parameters
- assetIndex: number
- Optional optionalTxnArgs: AlgonautTransactionFields
Returns Promise<AlgonautAtomicTransaction>
- Defined in src/index.ts:586

atomicPaymentWithLSig

atomicPaymentWithLSig(args: AlgonautLsigPaymentArguments): Promise<AlgonautAtomicTransaction>
Parameters
- args: AlgonautLsigPaymentArguments
Returns Promise<AlgonautAtomicTransaction>
- Defined in src/index.ts:1641

atomicSendAlgo

atomicSendAlgo(args: AlgonautPaymentArguments): Promise<AlgonautAtomicTransaction>
Parameters
- args: AlgonautPaymentArguments
Returns Promise<AlgonautAtomicTransaction>
- Defined in src/index.ts:1425

atomicSendAsset

atomicSendAsset(args: AlgonautSendAssetArguments): Promise<AlgonautAtomicTransaction>
Creates send asset transaction.

IMPORTANT: Before you can call this, the target account has to "opt-in" to the ASA index. You can't just send ASAs to people blind!

Returns
Promise resolving to AlgonautAtomicTransaction
Parameters
- args: AlgonautSendAssetArguments
  
  object containing to, assetIndex, and amount properties
Returns Promise<AlgonautAtomicTransaction>
- Defined in src/index.ts:829

atomicUpdateApp

atomicUpdateApp(args: AlgonautUpdateAppArguments): Promise<AlgonautAtomicTransaction>
Updates an application with makeApplicationUpdateTxn

Returns
atomic transaction that updates the app
Parameters
- args: AlgonautUpdateAppArguments
  
  AlgonautUpdateAppArguments
Returns Promise<AlgonautAtomicTransaction>
- Defined in src/index.ts:1351

b64StrToHumanStr

b64StrToHumanStr(encoded: string): string
Used for decoding state

Returns
Human-readable string
Parameters
- encoded: string
  
  Base64 string
Returns string
- Defined in src/index.ts:1790

callApp

callApp(args: AlgonautCallAppArguments, callbacks?: AlgonautTxnCallbacks): Promise<AlgonautTransactionStatus>
Call a "method" on a stateful contract. In TEAL, you're really giving an argument which branches to a specific place and reads the other args
Parameters
- args: AlgonautCallAppArguments
  
  Object containing appIndex, appArgs, and optionalFields properties
- Optional callbacks: AlgonautTxnCallbacks
Returns Promise<AlgonautTransactionStatus>
- Defined in src/index.ts:1007

checkStatus

checkStatus(): Promise<any>
Checks status of Algorand network

Returns
Promise resolving to status of Algorand network

Returns Promise<any>
- Defined in src/index.ts:243

closeOutApp

closeOutApp(args: AlgonautCallAppArguments, callbacks?: AlgonautTxnCallbacks): Promise<AlgonautTransactionStatus>
Closes out the user's local state in an application. The opposite of optInApp.

Returns
Promise resolving to atomic transaction
Parameters
- args: AlgonautCallAppArguments
  
  Object containing appIndex, appArgs, and optionalFields properties
- Optional callbacks: AlgonautTxnCallbacks
  
  optional AlgonautTxnCallbacks
Returns Promise<AlgonautTransactionStatus>
- Defined in src/index.ts:1076

compileProgram

compileProgram(programSource: string): Promise<Uint8Array>
Compiles TEAL source via algodClient.compile

Returns
Promise resolving to Buffer of compiled bytes
Parameters
- programSource: string
  
  source to compile
Returns Promise<Uint8Array>
- Defined in src/index.ts:1415

connect

connect(initWallets?: WalletInitParamsObj): Promise<Account[]>
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
- Optional initWallets: WalletInitParamsObj
Returns Promise<Account[]>
- Defined in src/index.ts:372

createApp

createApp(args: AlgonautDeployArguments, callbacks?: AlgonautTxnCallbacks): Promise<AlgonautTransactionStatus>
Create and deploy a new Smart Contract from TEAL code

Returns
AlgonautTransactionStatus
Parameters
- args: AlgonautDeployArguments
  
  AlgonautDeployArguments
- Optional callbacks: AlgonautTxnCallbacks
  
  optional AlgonautTxnCallbacks
Returns Promise<AlgonautTransactionStatus>
- Defined in src/index.ts:1137

createAsset

createAsset(args: AlgonautCreateAssetArguments, callbacks?: AlgonautTxnCallbacks): Promise<AlgonautTransactionStatus>
Create asset

Returns
asset index
Parameters
- args: AlgonautCreateAssetArguments
  
  AlgonautCreateAssetArguments. Must pass assetName, symbol, decimals, amount.
- Optional callbacks: AlgonautTxnCallbacks
  
  AlgonautTxnCallbacks
Returns Promise<AlgonautTransactionStatus>
- Defined in src/index.ts:762

createWallet

createWallet(): AlgonautWallet
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
- Defined in src/index.ts:1951

decodeBase64UnsignedTransaction

decodeBase64UnsignedTransaction(txn: string): Transaction
Does what it says on the tin.

Returns
transaction object
Parameters
- txn: string
  
  base64-encoded unsigned transaction
Returns Transaction
- Defined in src/index.ts:1855

decodeStateArray

decodeStateArray(stateArray: AlgonautAppStateEncoded[]): AlgonautStateData[]
Decodes app state into a human-readable format

Returns
Array of objects with key, value, and address properties
Parameters
- stateArray: AlgonautAppStateEncoded[]
  
  Encoded app state
Returns AlgonautStateData[]
- Defined in src/index.ts:1817

deleteApp

deleteApp(appIndex: number, callbacks?: AlgonautTxnCallbacks, optionalTxnArgs?: AlgonautTransactionFields): Promise<AlgonautTransactionStatus>
Deletes an application from the blockchain

Returns
Promise resolving to confirmed transaction or error
Parameters
- appIndex: number
  
  ID of application
- Optional callbacks: AlgonautTxnCallbacks
  
  optional AlgonautTxnCallbacks
- Optional optionalTxnArgs: AlgonautTransactionFields
Returns Promise<AlgonautTransactionStatus>
- Defined in src/index.ts:951

deleteAsset

deleteAsset(assetId: number, callbacks?: AlgonautTxnCallbacks, optionalTxnArgs?: AlgonautTransactionFields): Promise<AlgonautTransactionStatus>
Deletes asset

Returns
Promise resolving to confirmed transaction or error
Parameters
- assetId: number
  
  Index of the ASA to delete
- Optional callbacks: AlgonautTxnCallbacks
  
  optional AlgonautTxnCallbacks
- Optional optionalTxnArgs: AlgonautTransactionFields
Returns Promise<AlgonautTransactionStatus>
- Defined in src/index.ts:814

deployTealWithLSig

deployTealWithLSig(args: AlgonautLsigDeployArguments): Promise<AlgonautTransactionStatus>
deploys a contract from an lsig account keep in mind that the local and global byte and int values have caps, 16 for local and 32 for global and that the cost of deploying the app goes up based on how many of these slots you want to allocate

Returns
Parameters
- args: AlgonautLsigDeployArguments
  
  AlgonautLsigDeployArguments
Returns Promise<AlgonautTransactionStatus>
- Defined in src/index.ts:1279

disconnect

disconnect(wIds?: true | WALLET_ID[]): Promise<void>
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
- Optional wIds: true | WALLET_ID[]
Returns Promise<void>
- Defined in src/index.ts:448

disconnectAll

disconnectAll(): void
Returns void
- Defined in src/index.ts:513

enableWallets

enableWallets(walletInitParams?: WalletInitParamsObj): void
Parameters
- Optional walletInitParams: WalletInitParamsObj
Returns void
- Defined in src/index.ts:265

encodeArguments

encodeArguments(args: any[]): Uint8Array[]
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[]
- Defined in src/index.ts:672

fromBase64

fromBase64(encoded: string): string
Deprecated
Use b64StrToHumanStr instead

Returns
Human-readable string
Parameters
- encoded: string
  
  Base64 string
Returns string
- Defined in src/index.ts:1799

generateLogicSig

generateLogicSig(base64ProgramString: string): LogicSigAccount
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
- Defined in src/index.ts:576

getAccountInfo

getAccountInfo(address: string): Promise<any>
Fetch full account info for an account

Returns
Promise of type AccountInfo
Parameters
- address: string
  
  the accress to read info for
Returns Promise<any>
- Defined in src/index.ts:1474

getAlgoBalance

getAlgoBalance(address: string): Promise<any>
Checks Algo balance of account

Returns
Promise resolving to Algo balance
Parameters
- address: string
  
  Wallet of balance to check
Returns Promise<any>
- Defined in src/index.ts:1486

getAppEscrowAccount

getAppEscrowAccount(appId: number | bigint): string
Get an application's escrow account

Returns
Escrow account address as string
Parameters
- appId: number | bigint
  
  ID of application
Returns string
- Defined in src/index.ts:1086

getAppGlobalState

getAppGlobalState(applicationIndex: number): Promise<any>
Gets global state for an application.

Returns
object representing global state
Parameters
- applicationIndex: number
  
  the applications index
Returns Promise<any>
- Defined in src/index.ts:1536

getAppInfo

getAppInfo(appId: number): Promise<AlgonautAppState>
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>
- Defined in src/index.ts:1097

getAppLocalState

getAppLocalState(applicationIndex: number, address?: string): Promise<void | 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>
- Defined in src/index.ts:1552

getAssetInfo

getAssetInfo(assetIndex: number): Promise<any>
Get info about an asset

Returns
Parameters
- assetIndex: number
Returns Promise<any>
- Defined in src/index.ts:879

getNodeConfig

getNodeConfig(): undefined | boolean | {
    API_TOKEN: any;
    BASE_SERVER: string;
    INDEX_SERVER?: string;
    LEDGER: string;
    PORT: string;
}
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;
}
- Defined in src/index.ts:234

getTokenBalance

getTokenBalance(address: string, assetIndex: number): Promise<number>
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>
- Defined in src/index.ts:1499

initAcctSync

initAcctSync(): void
Returns void
- Defined in src/index.ts:253

inkeyConnect

inkeyConnect(): Promise<Account[]>
Deprecated
use .connect or loop through enabled wallets' methods

Returns Promise<Account[]>
- Defined in src/index.ts:293

inkeyDisconnect

inkeyDisconnect(): Promise<void>
Deprecated
use .disconnect or loop through enabled wallets' methods

Returns Promise<void>
- Defined in src/index.ts:303

inkeyHide

inkeyHide(): Promise<void>
Hides the inkey-wallet modal

Returns

Returns Promise<void>
- Defined in src/index.ts:343

inkeyShow

inkeyShow(): Promise<void>
Shows the inkey-wallet modal

Returns

Returns Promise<void>
- Defined in src/index.ts:312

isOptedIntoAsset

isOptedIntoAsset(args: {
account: string;
assetId: number;
}): Promise<boolean>
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>
- Defined in src/index.ts:649

isValidNodeConfig

isValidNodeConfig(nodeConfig?: {
    API_TOKEN: any;
    BASE_SERVER: string;
    INDEX_SERVER?: string;
    LEDGER: string;
    PORT: string;
}): 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
- Defined in src/index.ts:178

mnemonicConnect

mnemonicConnect(mnemonic: string): Promise<Account[]>
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[]>
- Defined in src/index.ts:283

normalizeTxns

normalizeTxns(txnOrTxns: Transaction | AlgonautAtomicTransaction | AlgonautAtomicTransaction[]): Uint8Array[]
Parameters
- txnOrTxns: Transaction | AlgonautAtomicTransaction | AlgonautAtomicTransaction[]
Returns Uint8Array[]
- Defined in src/index.ts:1662

optInApp

optInApp(args: AlgonautCallAppArguments, callbacks?: AlgonautTxnCallbacks): Promise<AlgonautTransactionStatus>
Opt-in the current account for an app.

Returns
Promise resolving to confirmed transaction or error
Parameters
- args: AlgonautCallAppArguments
  
  Object containing appIndex, appArgs, and optionalFields
- Optional callbacks: AlgonautTxnCallbacks
  
  optional AlgonautTxnCallbacks
Returns Promise<AlgonautTransactionStatus>
- Defined in src/index.ts:920

optInAsset

optInAsset(assetIndex: number, callbacks?: AlgonautTxnCallbacks, optionalTxnArgs?: AlgonautTransactionFields): Promise<AlgonautTransactionStatus>
Opt-in the current account for the a token or NFT Asset.

Returns
Promise resolving to confirmed transaction or error
Parameters
- assetIndex: number
  
  number of asset to opt-in to
- Optional callbacks: AlgonautTxnCallbacks
  
  AlgonautTxnCallbacks, passed to sendTransaction
- Optional optionalTxnArgs: AlgonautTransactionFields
Returns Promise<AlgonautTransactionStatus>
- Defined in src/index.ts:613

recoverAccount

recoverAccount(mnemonic: string): default
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
- Defined in src/index.ts:1971

sendAlgo

sendAlgo(args: AlgonautPaymentArguments, callbacks?: AlgonautTxnCallbacks): Promise<AlgonautTransactionStatus>
Sends ALGO from own account to args.to

Returns
Promise resolving to transaction status
Parameters
- args: AlgonautPaymentArguments
  
  AlgonautPaymentArgs object containing to, amount, and optional note
- Optional callbacks: AlgonautTxnCallbacks
  
  optional AlgonautTxnCallbacks
Returns Promise<AlgonautTransactionStatus>
- Defined in src/index.ts:1464

sendAsset

sendAsset(args: AlgonautSendAssetArguments, callbacks?: AlgonautTxnCallbacks): Promise<AlgonautTransactionStatus>
Sends asset to an address.

IMPORTANT: Before you can call this, the target account has to "opt-in" to the ASA index. You can't just send ASAs to people blind!

Returns
Promise resolving to confirmed transaction or error
Parameters
- args: AlgonautSendAssetArguments
  
  object containing to, assetIndex, and amount properties
- Optional callbacks: AlgonautTxnCallbacks
  
  optional AlgonautTxnCallbacks
Returns Promise<AlgonautTransactionStatus>
- Defined in src/index.ts:867

sendTransaction

sendTransaction(txnOrTxns: Transaction | AlgonautAtomicTransaction | AlgonautAtomicTransaction[], callbacks?: AlgonautTxnCallbacks): Promise<AlgonautTransactionStatus>
Sends a transaction or multiple w the correct wallet according to AW

Returns
Promise resolving to AlgonautTransactionStatus
Parameters
- txnOrTxns: Transaction | AlgonautAtomicTransaction | AlgonautAtomicTransaction[]
  
  Either an array of atomic transactions or a single transaction to sign
- Optional callbacks: AlgonautTxnCallbacks
  
  Optional object with callbacks - onSign, onSend, and onConfirm
Returns Promise<AlgonautTransactionStatus>
- Defined in src/index.ts:1722

setLibConfig

setLibConfig(libConfig?: {
disableLogs?: boolean;
}): void
Parameters
- Optional libConfig: {
  disableLogs?: boolean;
  }
  - Optional disableLogs?: boolean
Returns void
- Defined in src/index.ts:160

setNodeConfig

setNodeConfig(nodeConfig?: {
    API_TOKEN: any;
    BASE_SERVER: string;
    INDEX_SERVER?: string;
    LEDGER: string;
    PORT: string;
} | "testnet" | "mainnet"): 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
- Defined in src/index.ts:198

signTransaction

signTransaction(txnOrTxns: Transaction | AlgonautAtomicTransaction | AlgonautAtomicTransaction[]): Promise<Uint8Array[]>
Signs a transaction or multiple w the correct wallet according to AW (does not send / submit txn(s) to network)

Returns
Promise resolving to AlgonautTransactionStatus
Parameters
- txnOrTxns: Transaction | AlgonautAtomicTransaction | AlgonautAtomicTransaction[]
  
  Either an array of atomic transactions or a single transaction to sign
Returns Promise<Uint8Array[]>
- Defined in src/index.ts:1701

stateArrayToObject

stateArrayToObject(stateArray: object[]): any
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
- Defined in src/index.ts:1777

stopAcctSync

stopAcctSync(): void
Returns void
- Defined in src/index.ts:261

to8Arr

to8Arr(str: string, enc?: BufferEncoding): Uint8Array
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
- Defined in src/index.ts:1766

toUint8Array

toUint8Array(str: string, enc?: BufferEncoding): Uint8Array
Returns
string encoded as Uint8Array
Parameters
- str: string
  
  string
- enc: BufferEncoding = 'utf8'
  
  the encoding type of the string (defaults to utf8)
Returns Uint8Array
- Defined in src/index.ts:1756

txnB64ToTxnBuff

txnB64ToTxnBuff(txn: string): Buffer
txn(b64) -> txnBuff (buffer)

Returns
trransaction as buffer object
Parameters
- txn: string
  
  base64-encoded unsigned transaction
Returns Buffer
- Defined in src/index.ts:1993

txnBuffToB64

txnBuffToB64(buff: Uint8Array): string
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
- Defined in src/index.ts:2002

txnSummary

txnSummary(txn: Transaction): string
Describes an Algorand transaction, for display in Inkey
Parameters
- txn: Transaction
  
  Transaction to describe
Returns string
- Defined in src/index.ts:1863

txnToStr

txnToStr(txn: Transaction): string
Does what it says on the tin.

Returns
string (like for inkey / base64 transmit use)
Parameters
- txn: Transaction
  
  algorand txn object
Returns string
- Defined in src/index.ts:2011

updateApp

updateApp(args: AlgonautUpdateAppArguments, callbacks?: AlgonautTxnCallbacks): Promise<AlgonautTransactionStatus>
Sends an update app transaction

Returns
transaction status
Parameters
- args: AlgonautUpdateAppArguments
  
  AlgonautUpdateAppArguments
- Optional callbacks: AlgonautTxnCallbacks
  
  optional callbacks: onSign, onSend, onConfirm
Returns Promise<AlgonautTransactionStatus>
- Defined in src/index.ts:1405

valueAsAddr

valueAsAddr(encoded: string): string
Decodes a Base64-encoded Uint8 Algorand address and returns a string

Returns
Decoded address
Parameters
- encoded: string
  
  An encoded Algorand address
Returns string
- Defined in src/index.ts:1808

waitForConfirmation

waitForConfirmation(txId: string, limitDelta?: number, log?: boolean): Promise<AlgonautTransactionStatus>
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>
- Defined in src/index.ts:523

Class Algonaut

Hierarchy

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Example

Parameters

Optional config: AlgonautConfig

Returns Algonaut

Properties

account

algodClient

indexerClient

libConfig

nodeConfig

Type declaration

API_TOKEN: any

BASE_SERVER: string

Optional INDEX_SERVER?: string

LEDGER: string

PORT: string

sdk

walletState

Type declaration

activeAccount: null | { active: boolean; address: string; chain: string; name: string; walletId: WALLET_ID; }

activeAddress: string

activeWalletId: null | WALLET_ID

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[]>)

Parameters

Optional p: any

Returns Promise<Account[]>

connecting: boolean

disconnect: (() => 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>)

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>)

Returns Promise<void>

removeAccounts: (() => void)

Returns void

setAsActiveWallet: (() => void)

Returns void

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

Parameters

transactions: Uint8Array[]

Returns 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[]>)

Parameters

Optional p: any

Returns Promise<Account[]>

connecting: boolean

disconnect: (() => Promise<void>)

Returns Promise<void>

id: WALLET_ID

initParams: boolean | { config?: any; sdk?: any; }

inited: boolean

initing: boolean

`Optional` config: AlgonautConfig

`Optional` INDEX_SERVER?: string

activeAccount: null | {
active: boolean;
address: string;
chain: string;
name: string;
walletId: WALLET_ID;
}

`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[]>);
}

`Optional` p: any

initParams: boolean | {
config?: any;
sdk?: any;
}

`Readonly` isActive: boolean

`Readonly` isConnected: boolean

metadata: {
chain: string;
icon: string;
id: WALLET_ID;
name: string;
pkg: string;
}

`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[]>);
}

`Optional` p: any

initParams: boolean | {
config?: any;
sdk?: any;
}

`Readonly` isActive: boolean

`Readonly` isConnected: boolean

metadata: {
chain: string;
icon: string;
id: WALLET_ID;
name: string;
pkg: string;
}

`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[]>);
}

`Optional` p: any

initParams: boolean | {
config?: any;
sdk?: any;
}

`Readonly` isActive: boolean

`Readonly` isConnected: boolean

metadata: {
chain: string;
icon: string;
id: WALLET_ID;
name: string;
pkg: string;
}

`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[]>);
}

`Optional` p: any