@txnlab/use-wallet 2.8.0 → 3.0.0-beta.2

package/dist/index.d.cts

@@ -0,0 +1,511 @@
+import { Store } from '@tanstack/store';
+import algosdk from 'algosdk';
+import { WalletConnectModalConfig } from '@walletconnect/modal';
+import { SignClientTypes } from '@walletconnect/types';
+
+declare enum NetworkId {
+    MAINNET = "mainnet",
+    TESTNET = "testnet",
+    BETANET = "betanet",
+    LOCALNET = "localnet"
+}
+interface AlgodConfig {
+    token: string | algosdk.AlgodTokenHeader | algosdk.CustomTokenHeader | algosdk.BaseHTTPClient;
+    baseServer: string;
+    port?: string | number;
+    headers?: Record<string, string>;
+}
+type NetworkConfigMap = Record<NetworkId, AlgodConfig>;
+type NetworkConfig = Partial<AlgodConfig> | Partial<Record<NetworkId, Partial<AlgodConfig>>>;
+
+interface DeflyWalletConnectOptions {
+    bridge?: string;
+    shouldShowSignTxnToast?: boolean;
+    chainId?: 416001 | 416002 | 416003 | 4160;
+}
+declare class DeflyWallet extends BaseWallet {
+    private client;
+    private options;
+    protected store: Store<State>;
+    constructor({ id, store, subscribe, getAlgodClient, options, metadata }: WalletConstructor<WalletId.DEFLY>);
+    static defaultMetadata: {
+        name: string;
+        icon: string;
+    };
+    private initializeClient;
+    connect: () => Promise<WalletAccount[]>;
+    disconnect: () => Promise<void>;
+    resumeSession: () => Promise<void>;
+    signTransactions: (txnGroup: algosdk.Transaction[] | algosdk.Transaction[][] | Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean) => Promise<Uint8Array[]>;
+    transactionSigner: (txnGroup: algosdk.Transaction[], indexesToSign: number[]) => Promise<Uint8Array[]>;
+}
+
+/** @see https://docs.exodus.com/api-reference/algorand-provider-arc-api/ */
+interface EnableNetworkOpts {
+    genesisID?: string;
+    genesisHash?: string;
+}
+interface EnableAccountsOpts {
+    accounts?: string[];
+}
+type ExodusOptions = EnableNetworkOpts & EnableAccountsOpts;
+interface EnableNetworkResult {
+    genesisID: string;
+    genesisHash: string;
+}
+interface EnableAccountsResult {
+    accounts: string[];
+}
+type EnableResult = EnableNetworkResult & EnableAccountsResult;
+type SignTxnsResult = (string | null)[];
+interface Exodus {
+    isConnected: boolean;
+    address: string | null;
+    enable: (options?: ExodusOptions) => Promise<EnableResult>;
+    signTxns: (transactions: WalletTransaction[]) => Promise<SignTxnsResult>;
+}
+type WindowExtended = {
+    algorand: Exodus;
+} & Window & typeof globalThis;
+declare class ExodusWallet extends BaseWallet {
+    private client;
+    private options;
+    protected store: Store<State>;
+    constructor({ id, store, subscribe, getAlgodClient, options, metadata }: WalletConstructor<WalletId.EXODUS>);
+    static defaultMetadata: {
+        name: string;
+        icon: string;
+    };
+    private initializeClient;
+    connect: () => Promise<WalletAccount[]>;
+    disconnect: () => Promise<void>;
+    resumeSession: () => Promise<void>;
+    signTransactions: (txnGroup: algosdk.Transaction[] | algosdk.Transaction[][] | Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean) => Promise<Uint8Array[]>;
+    transactionSigner: (txnGroup: algosdk.Transaction[], indexesToSign: number[]) => Promise<Uint8Array[]>;
+}
+
+type ProviderMethod = 'enable' | 'getProviders' | 'postTxns' | 'signAndPostTxns' | 'signBytes' | 'signTxns';
+interface SendRequestWithTimeoutOptions<Params> {
+    method: ProviderMethod;
+    params: Params;
+    reference: string;
+    timeout?: number;
+}
+declare class KibisisWallet extends BaseWallet {
+    methods: ProviderMethod[];
+    protected store: Store<State>;
+    constructor({ id, store, subscribe, getAlgodClient, metadata }: WalletConstructor<WalletId.KIBISIS>);
+    static defaultMetadata: {
+        name: string;
+        icon: string;
+    };
+    static sendRequestWithTimeout<Params, Result>({ method, params, timeout, reference }: SendRequestWithTimeoutOptions<Params>): Promise<Result | undefined>;
+    /**
+     * Calls the enable method on the provider that returns the authorized accounts.
+     * @returns {Arc0027Account[]} the authorized accounts.
+     * @throws {METHOD_CANCELED_ERROR} if the method was cancelled by the user.
+     * @throws {METHOD_NOT_SUPPORTED_ERROR} if the method is not supported for the configured network.
+     * @throws {METHOD_TIMED_OUT_ERROR} if the method timed out by lack of response.
+     * @throws {NETWORK_NOT_SUPPORTED_ERROR} if the network is not supported for the configured network.
+     * @throws {UNKNOWN_ERROR} if the response result was empty.
+     */
+    private enable;
+    /**
+     * Gets the genesis hash of the algod client's configured network.
+     * @returns {string} the genesis hash
+     */
+    private getGenesisHash;
+    /**
+     * Gets the provider information and updates the supported methods. This should be called
+     * before interacting with the provider to ensure methods are supported.
+     * @throws {METHOD_TIMED_OUT_ERROR} if the method timed out by lack of response.
+     * @throws {NETWORK_NOT_SUPPORTED_ERROR} if the network is not supported for the configured network.
+     * @throws {UNKNOWN_ERROR} if the response result was empty.
+     */
+    private getSupportedMethods;
+    /**
+     * Calls the signTxns methods to sign the supplied transactions.
+     * @param {Arc0001SignTxns[]} txns -  the unsigned or signed transactions as defined in ARC-0001.
+     * @returns {(string | null)[]} the authorized accounts.
+     * @throws {INVALID_INPUT_ERROR} if computed group ID for the txns does not match the assigned group ID.
+     * @throws {INVALID_GROUP_ID_ERROR} if the unsigned txns is malformed or not conforming to ARC-0001.
+     * @throws {METHOD_CANCELED_ERROR} if the method was cancelled by the user.
+     * @throws {METHOD_NOT_SUPPORTED_ERROR} if the method is not supported for the configured network.
+     * @throws {METHOD_TIMED_OUT_ERROR} if the method timed out by lack of response.
+     * @throws {NETWORK_NOT_SUPPORTED_ERROR} if the network is not supported for the configured network.
+     * @throws {UNAUTHORIZED_SIGNER_ERROR} if a signer in the request is not authorized by the provider.
+     * @throws {UNKNOWN_ERROR} if the response result was empty.
+     */
+    private signTxns;
+    /**
+     * Validates whether a method is supported with the provider.
+     * @param {ProviderMethod} method -  the method to validate.
+     * @throws {METHOD_NOT_SUPPORTED_ERROR} if the method is not supported for the configured network.
+     */
+    private validateMethod;
+    connect: () => Promise<WalletAccount[]>;
+    disconnect: () => Promise<void>;
+    resumeSession: () => Promise<void>;
+    signTransactions: (txnGroup: algosdk.Transaction[] | algosdk.Transaction[][] | Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean) => Promise<Uint8Array[]>;
+    transactionSigner: (txnGroup: algosdk.Transaction[], indexesToSign: number[]) => Promise<Uint8Array[]>;
+}
+
+interface KmdConstructor {
+    token: string | algosdk.KMDTokenHeader | algosdk.CustomTokenHeader;
+    baseServer?: string;
+    port?: string | number;
+    headers?: Record<string, string>;
+}
+type KmdOptions = Partial<Pick<KmdConstructor, 'token'>> & Omit<KmdConstructor, 'token'> & {
+    wallet?: string;
+};
+declare class KmdWallet extends BaseWallet {
+    private client;
+    private options;
+    private walletName;
+    private walletId;
+    private password;
+    protected store: Store<State>;
+    constructor({ id, store, subscribe, getAlgodClient, options, metadata }: WalletConstructor<WalletId.KMD>);
+    static defaultMetadata: {
+        name: string;
+        icon: string;
+    };
+    private initializeClient;
+    connect: () => Promise<WalletAccount[]>;
+    disconnect: () => Promise<void>;
+    resumeSession: () => Promise<void>;
+    signTransactions: (txnGroup: algosdk.Transaction[] | algosdk.Transaction[][] | Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean) => Promise<Uint8Array[]>;
+    transactionSigner: (txnGroup: algosdk.Transaction[], indexesToSign: number[]) => Promise<Uint8Array[]>;
+    private fetchWalletId;
+    private fetchToken;
+    private fetchAccounts;
+    private releaseToken;
+    private getPassword;
+}
+
+interface LuteConnectOptions {
+    siteName?: string;
+}
+declare class LuteWallet extends BaseWallet {
+    private client;
+    private options;
+    protected store: Store<State>;
+    constructor({ id, store, subscribe, getAlgodClient, options, metadata }: WalletConstructor<WalletId.LUTE>);
+    static defaultMetadata: {
+        name: string;
+        icon: string;
+    };
+    private initializeClient;
+    private getGenesisId;
+    connect: () => Promise<WalletAccount[]>;
+    disconnect: () => Promise<void>;
+    resumeSession: () => Promise<void>;
+    signTransactions: (txnGroup: algosdk.Transaction[] | algosdk.Transaction[][] | Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean) => Promise<Uint8Array[]>;
+    transactionSigner: (txnGroup: algosdk.Transaction[], indexesToSign: number[]) => Promise<Uint8Array[]>;
+}
+
+type MnemonicOptions = {
+    persistToStorage?: boolean;
+};
+declare class MnemonicWallet extends BaseWallet {
+    private account;
+    private options;
+    protected store: Store<State>;
+    constructor({ id, store, subscribe, getAlgodClient, options, metadata }: WalletConstructor<WalletId.MNEMONIC>);
+    static defaultMetadata: {
+        name: string;
+        icon: string;
+    };
+    private initializeAccount;
+    connect: () => Promise<WalletAccount[]>;
+    disconnect: () => Promise<void>;
+    resumeSession: () => Promise<void>;
+    signTransactions: (txnGroup: algosdk.Transaction[] | algosdk.Transaction[][] | Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean) => Promise<Uint8Array[]>;
+    transactionSigner: (txnGroup: algosdk.Transaction[], indexesToSign: number[]) => Promise<Uint8Array[]>;
+}
+
+interface PeraWalletConnectOptions {
+    bridge?: string;
+    shouldShowSignTxnToast?: boolean;
+    chainId?: 416001 | 416002 | 416003 | 4160;
+    compactMode?: boolean;
+}
+declare class PeraWallet extends BaseWallet {
+    private client;
+    private options;
+    protected store: Store<State>;
+    constructor({ id, store, subscribe, getAlgodClient, options, metadata }: WalletConstructor<WalletId.PERA>);
+    static defaultMetadata: {
+        name: string;
+        icon: string;
+    };
+    private initializeClient;
+    connect: () => Promise<WalletAccount[]>;
+    disconnect: () => Promise<void>;
+    resumeSession: () => Promise<void>;
+    signTransactions: (txnGroup: algosdk.Transaction[] | algosdk.Transaction[][] | Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean) => Promise<Uint8Array[]>;
+    transactionSigner: (txnGroup: algosdk.Transaction[], indexesToSign: number[]) => Promise<Uint8Array[]>;
+}
+
+interface SignClientOptions {
+    projectId: string;
+    relayUrl?: string;
+    metadata?: SignClientTypes.Metadata;
+}
+type WalletConnectModalOptions = Pick<WalletConnectModalConfig, 'enableExplorer' | 'explorerRecommendedWalletIds' | 'privacyPolicyUrl' | 'termsOfServiceUrl' | 'themeMode' | 'themeVariables'>;
+type WalletConnectOptions = SignClientOptions & WalletConnectModalOptions;
+declare class WalletConnect extends BaseWallet {
+    private client;
+    private options;
+    private modal;
+    private modalOptions;
+    private session;
+    private chains;
+    protected store: Store<State>;
+    constructor({ id, store, subscribe, getAlgodClient, options, metadata }: WalletConstructor<WalletId.WALLETCONNECT>);
+    static defaultMetadata: {
+        name: string;
+        icon: string;
+    };
+    private initializeClient;
+    private initializeModal;
+    private onSessionConnected;
+    connect: () => Promise<WalletAccount[]>;
+    disconnect: () => Promise<void>;
+    resumeSession: () => Promise<void>;
+    signTransactions: (txnGroup: algosdk.Transaction[] | algosdk.Transaction[][] | Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean) => Promise<Uint8Array[]>;
+    transactionSigner: (txnGroup: algosdk.Transaction[], indexesToSign: number[]) => Promise<Uint8Array[]>;
+}
+
+declare enum WalletId {
+    DEFLY = "defly",
+    EXODUS = "exodus",
+    KIBISIS = "kibisis",
+    KMD = "kmd",
+    LUTE = "lute",
+    MNEMONIC = "mnemonic",
+    PERA = "pera",
+    WALLETCONNECT = "walletconnect"
+}
+type WalletMap = {
+    [WalletId.DEFLY]: typeof DeflyWallet;
+    [WalletId.EXODUS]: typeof ExodusWallet;
+    [WalletId.KIBISIS]: typeof KibisisWallet;
+    [WalletId.KMD]: typeof KmdWallet;
+    [WalletId.LUTE]: typeof LuteWallet;
+    [WalletId.MNEMONIC]: typeof MnemonicWallet;
+    [WalletId.PERA]: typeof PeraWallet;
+    [WalletId.WALLETCONNECT]: typeof WalletConnect;
+};
+type WalletOptionsMap = {
+    [WalletId.DEFLY]: DeflyWalletConnectOptions;
+    [WalletId.EXODUS]: ExodusOptions;
+    [WalletId.KIBISIS]: Record<string, never>;
+    [WalletId.KMD]: KmdOptions;
+    [WalletId.LUTE]: LuteConnectOptions;
+    [WalletId.MNEMONIC]: MnemonicOptions;
+    [WalletId.PERA]: PeraWalletConnectOptions;
+    [WalletId.WALLETCONNECT]: WalletConnectOptions;
+};
+type SupportedWallet = WalletIdConfig<WalletId> | WalletId;
+type WalletConfigMap = {
+    [K in keyof WalletOptionsMap]: {
+        options?: WalletOptionsMap[K];
+        metadata?: Partial<WalletMetadata>;
+    };
+};
+type WalletOptions<T extends keyof WalletOptionsMap> = WalletOptionsMap[T];
+type WalletConfig<T extends keyof WalletConfigMap> = WalletConfigMap[T];
+type WalletIdConfig<T extends keyof WalletConfigMap> = {
+    [K in T]: {
+        id: K;
+    } & WalletConfigMap[K];
+}[T];
+type NonEmptyArray<T> = [T, ...T[]];
+type SupportedWallets = NonEmptyArray<SupportedWallet>;
+type WalletMetadata = {
+    name: string;
+    icon: string;
+};
+interface BaseWalletConstructor {
+    id: WalletId;
+    metadata: Partial<WalletMetadata> | undefined;
+    getAlgodClient: () => algosdk.Algodv2;
+    store: Store<State>;
+    subscribe: (callback: (state: State) => void) => () => void;
+}
+type WalletConstructor<T extends keyof WalletOptionsMap> = BaseWalletConstructor & {
+    options?: WalletOptions<T>;
+    defaultMetadata?: WalletMetadata;
+};
+type WalletAccount = {
+    name: string;
+    address: string;
+};
+/** @see https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0001.md#interface-multisigmetadata */
+interface MultisigMetadata {
+    /**
+     * Multisig version.
+     */
+    version: number;
+    /**
+     * Multisig threshold value. Authorization requires a subset of signatures,
+     * equal to or greater than the threshold value.
+     */
+    threshold: number;
+    /**
+     * List of Algorand addresses of possible signers for this
+     * multisig. Order is important.
+     */
+    addrs: string[];
+}
+/** @see https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0001.md#interface-wallettransaction */
+interface WalletTransaction {
+    /**
+     * Base64 encoding of the canonical msgpack encoding of a Transaction.
+     */
+    txn: string;
+    /**
+     * Optional authorized address used to sign the transaction when the account
+     * is rekeyed. Also called the signor/sgnr.
+     */
+    authAddr?: string;
+    /**
+     * Multisig metadata used to sign the transaction
+     */
+    msig?: MultisigMetadata;
+    /**
+     * Optional list of addresses that must sign the transactions
+     */
+    signers?: string[];
+    /**
+     * Optional base64 encoding of the canonical msgpack encoding of a
+     * SignedTxn corresponding to txn, when signers=[]
+     */
+    stxn?: string;
+    /**
+     * Optional message explaining the reason of the transaction
+     */
+    message?: string;
+    /**
+     * Optional message explaining the reason of this group of transaction
+     * Field only allowed in the first transaction of a group
+     */
+    groupMessage?: string;
+}
+/** @see https://github.com/perawallet/connect/blob/1.3.3/src/util/model/peraWalletModels.ts */
+interface SignerTransaction {
+    txn: algosdk.Transaction;
+    /**
+     * Optional authorized address used to sign the transaction when
+     * the account is rekeyed. Also called the signor/sgnr.
+     */
+    authAddr?: string;
+    /**
+     * Optional list of addresses that must sign the transactions.
+     * Wallet skips to sign this txn if signers is empty array.
+     * If undefined, wallet tries to sign it.
+     */
+    signers?: string[];
+    /**
+     * Optional message explaining the reason of the transaction
+     */
+    message?: string;
+}
+interface JsonRpcRequest<T = any> {
+    id: number;
+    jsonrpc: string;
+    method: string;
+    params: T;
+}
+
+declare abstract class BaseWallet {
+    readonly id: WalletId;
+    readonly metadata: WalletMetadata;
+    protected store: Store<State>;
+    protected getAlgodClient: () => algosdk.Algodv2;
+    subscribe: (callback: (state: State) => void) => () => void;
+    protected constructor({ id, metadata, store, subscribe, getAlgodClient }: WalletConstructor<WalletId>);
+    static defaultMetadata: WalletMetadata;
+    abstract connect(): Promise<WalletAccount[]>;
+    abstract disconnect(): Promise<void>;
+    abstract resumeSession(): Promise<void>;
+    setActive: () => void;
+    setActiveAccount: (account: string) => void;
+    abstract signTransactions(txnGroup: algosdk.Transaction[] | algosdk.Transaction[][] | Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
+    abstract transactionSigner(txnGroup: algosdk.Transaction[], indexesToSign: number[]): Promise<Uint8Array[]>;
+    get name(): string;
+    get accounts(): WalletAccount[];
+    get addresses(): string[];
+    get activeAccount(): WalletAccount | null;
+    get activeAddress(): string | null;
+    get activeNetwork(): NetworkId;
+    get isConnected(): boolean;
+    get isActive(): boolean;
+    protected onDisconnect(): void;
+}
+
+type WalletState = {
+    accounts: WalletAccount[];
+    activeAccount: WalletAccount | null;
+};
+type WalletStateMap = Partial<Record<WalletId, WalletState>>;
+interface State {
+    wallets: WalletStateMap;
+    activeWallet: WalletId | null;
+    activeNetwork: NetworkId;
+}
+declare const defaultState: State;
+
+interface WalletManagerConfig {
+    wallets?: SupportedWallet[];
+    network?: NetworkId;
+    algod?: NetworkConfig;
+}
+declare class WalletManager {
+    _clients: Map<WalletId, BaseWallet>;
+    networkConfig: NetworkConfigMap;
+    algodClient: algosdk.Algodv2;
+    store: Store<State>;
+    subscribe: (callback: (state: State) => void) => () => void;
+    constructor({ wallets, network, algod }?: WalletManagerConfig);
+    private loadPersistedState;
+    private savePersistedState;
+    private initializeWallets;
+    get wallets(): BaseWallet[];
+    getWallet(walletId: WalletId): BaseWallet | undefined;
+    resumeSessions(): Promise<void>;
+    private initNetworkConfig;
+    private createAlgodClient;
+    getAlgodClient: () => algosdk.Algodv2;
+    setActiveNetwork(networkId: NetworkId): void;
+    get activeNetwork(): NetworkId;
+    get activeWallet(): BaseWallet | null;
+    get activeWalletAccounts(): WalletAccount[] | null;
+    get activeWalletAddresses(): string[] | null;
+    get activeAccount(): WalletAccount | null;
+    get activeAddress(): string | null;
+    get signTransactions(): (txnGroup: algosdk.Transaction[] | algosdk.Transaction[][] | Uint8Array[] | Uint8Array[][], indexesToSign?: number[] | undefined, returnGroup?: boolean | undefined) => Promise<Uint8Array[]>;
+    /**
+     * A function which can sign transactions from an atomic transaction group. The logic will be
+     * specific to each wallet, but the function will always return a promise that resolves to an
+     * array of encoded signed transactions matching the length of the indexesToSign array.
+     *
+     * @see https://github.com/algorand/js-algorand-sdk/blob/v2.6.0/src/signer.ts#L7-L18
+     *
+     * @param txnGroup - The atomic group containing transactions to be signed
+     * @param indexesToSign - An array of indexes in the atomic transaction group that should be signed
+     * @returns A promise which resolves an array of encoded signed transactions. The length of the
+     *   array will be the same as the length of indexesToSign, and each index i in the array
+     *   corresponds to the signed transaction from txnGroup[indexesToSign[i]]
+     */
+    get transactionSigner(): algosdk.TransactionSigner;
+}
+
+declare class StorageAdapter {
+    static getItem(key: string): string | null;
+    static setItem(key: string, value: string): void;
+}
+
+export { BaseWallet, type BaseWalletConstructor, DeflyWallet, type DeflyWalletConnectOptions, type EnableResult, type Exodus, type ExodusOptions, ExodusWallet, type JsonRpcRequest, type KmdOptions, KmdWallet, type MnemonicOptions, MnemonicWallet, type MultisigMetadata, NetworkId, PeraWallet, type PeraWalletConnectOptions, type SignTxnsResult, type SignerTransaction, type State, StorageAdapter, type SupportedWallet, type SupportedWallets, type WalletAccount, type WalletConfig, type WalletConfigMap, WalletConnect, type WalletConnectOptions, type WalletConstructor, WalletId, type WalletIdConfig, WalletManager, type WalletManagerConfig, type WalletMap, type WalletMetadata, type WalletOptions, type WalletOptionsMap, type WalletState, type WalletTransaction, type WindowExtended, defaultState };