@txnlab/use-wallet 0.1.15 → 0.1.16

package/dist/cjs/algod/index.d.ts

@@ -0,0 +1,3 @@
+import algosdk from "algosdk";
+declare const algodClient: algosdk.Algodv2;
+export { algosdk, algodClient };

package/dist/cjs/clients/algosigner.d.ts

@@ -3,9 +3,7 @@
  * https://github.com/PureStake/algosigner/blob/develop/docs/dApp-integration.md
  */
 import BaseWallet from "./base";
-import type { InitAlgodClient } from "./base";
 import { PROVIDER_ID } from "../constants";
-import { providers } from "../providers";
 import type { WalletProvider } from "../types";
 import { TransactionsArray } from "../types";
 declare type AlgoSignerTransaction = {
@@ -33,13 +31,13 @@ declare type AlgoSigner = {
 declare type InitWallet = {
     client: AlgoSigner;
     id: PROVIDER_ID;
-    providers: typeof providers;
+    provider: WalletProvider;
 };
 declare class AlgoSignerClient extends BaseWallet {
     #private;
     id: PROVIDER_ID;
     provider: WalletProvider;
-    constructor(initAlgodClient: InitAlgodClient, initWallet: InitWallet);
+    constructor(initWallet: InitWallet);
     static init(): Promise<AlgoSignerClient>;
     connect(): Promise<{
         accounts: {
@@ -58,5 +56,4 @@ declare class AlgoSignerClient extends BaseWallet {
     signTransactions(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
     signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
 }
-declare const _default: Promise<void | AlgoSignerClient>;
-export default _default;
+export default AlgoSignerClient;

package/dist/cjs/clients/base.d.ts

@@ -1,21 +1,14 @@
-import type _algosdk from "algosdk";
+import { algosdk } from "../algod";
 import { PROVIDER_ID } from "../constants";
 import type { WalletProvider, Asset, Wallet, AccountInfo } from "../types";
 import { ConfirmedTxn } from "../types";
 import { TransactionsArray, TxnInfo } from "../types";
-/** @todo implement audio hack */
-export declare type InitAlgodClient = {
-    algosdk: typeof _algosdk;
-    token: string;
-    server: string;
-    port: string;
-};
 export interface BaseWalletInterface {
     connect(onDisconnect: () => void): Promise<Wallet>;
     healthCheck(): Promise<Record<string, never>>;
     disconnect(): Promise<void>;
     reconnect(onDisconnect: () => void): Promise<Wallet | null>;
-    decodeTransaction(txn: string, isSigned: boolean): _algosdk.Transaction;
+    decodeTransaction(txn: string, isSigned: boolean): algosdk.Transaction;
     logEncodedTransaction(txn: string, isSigned: boolean): void;
     groupTransactionsBySender(transactions: TransactionsArray): Record<string, TxnInfo[]>;
     signTransactions(activeAddress: string, transactions: Array<Uint8Array>): Promise<Uint8Array[]>;
@@ -28,8 +21,6 @@ export interface BaseWalletInterface {
     waitForConfirmation(txId: string, timeout?: number): Promise<ConfirmedTxn>;
 }
 declare abstract class BaseWallet implements BaseWalletInterface {
-    algodClient: _algosdk.Algodv2;
-    algosdk: typeof _algosdk;
     keepWCAlive: HTMLAudioElement;
     protected abstract id: PROVIDER_ID;
     protected abstract provider: WalletProvider;
@@ -38,7 +29,7 @@ declare abstract class BaseWallet implements BaseWalletInterface {
     abstract reconnect(onDisconnect: () => void): Promise<Wallet | null>;
     abstract signTransactions(activeAdress: string, transactions: Array<Uint8Array>): Promise<Uint8Array[]>;
     abstract signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
-    protected constructor({ algosdk, token, server, port }: InitAlgodClient);
+    protected constructor();
     healthCheck(): Promise<{}>;
     getAccountInfo(address: string): Promise<AccountInfo>;
     getAssets(address: string): Promise<Asset[]>;
@@ -52,7 +43,7 @@ declare abstract class BaseWallet implements BaseWalletInterface {
         };
         txId: string;
     }>;
-    decodeTransaction: (txn: string, isSigned: boolean) => _algosdk.Transaction;
+    decodeTransaction: (txn: string, isSigned: boolean) => algosdk.Transaction;
     logEncodedTransaction(txn: string, isSigned: boolean): void;
     groupTransactionsBySender(transactions: TransactionsArray): Record<string, any>;
     sendRawTransactions(transactions: Uint8Array[]): Promise<{

package/dist/cjs/clients/defly.d.ts

@@ -1,15 +1,9 @@
-/**
- * Helpful resources:
- * https://github.com/blockshake-io/defly-connect
- */
-import { providers } from "../providers";
 import type { WalletProvider, Wallet } from "../types";
 import { PROVIDER_ID } from "../constants";
 import type { Transaction } from "algosdk";
 import BaseWallet from "./base";
-import type { InitAlgodClient } from "./base";
 import { TransactionsArray } from "../types";
-import type { DeflyWalletConnect } from "@blockshake/defly-connect";
+import { DeflyWalletConnect } from "@blockshake/defly-connect";
 export interface DeflyTransaction {
     txn: Transaction;
     /**
@@ -22,13 +16,13 @@ export interface DeflyTransaction {
 declare type InitWallet = {
     id: PROVIDER_ID;
     client: DeflyWalletConnect;
-    providers: typeof providers;
+    provider: WalletProvider;
 };
 declare class DeflyWalletClient extends BaseWallet {
     #private;
     id: PROVIDER_ID;
     provider: WalletProvider;
-    constructor(initAlgodClient: InitAlgodClient, initWallet: InitWallet);
+    constructor(initWallet: InitWallet);
     static init(): Promise<DeflyWalletClient>;
     connect(onDisconnect: () => void): Promise<Wallet>;
     reconnect(onDisconnect: () => void): Promise<{
@@ -47,5 +41,4 @@ declare class DeflyWalletClient extends BaseWallet {
     signTransactions(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
     signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
 }
-declare const _default: Promise<void | DeflyWalletClient>;
-export default _default;
+export default DeflyWalletClient;

package/dist/cjs/clients/exodus.d.ts

@@ -3,9 +3,7 @@
  * https://docs.exodus.com/api-reference/algorand-provider-api/
  */
 import BaseWallet from "./base";
-import type { InitAlgodClient } from "./base";
 import { PROVIDER_ID } from "../constants";
-import { providers } from "../providers";
 import type { WalletProvider } from "../types";
 import { TransactionsArray } from "../types";
 declare type Bytes = Readonly<Uint8Array>;
@@ -24,13 +22,13 @@ declare type Exodus = {
 declare type InitWallet = {
     client: Exodus;
     id: PROVIDER_ID;
-    providers: typeof providers;
+    provider: WalletProvider;
 };
 declare class ExodusClient extends BaseWallet {
     #private;
     id: PROVIDER_ID;
     provider: WalletProvider;
-    constructor(initAlgodClient: InitAlgodClient, initWallet: InitWallet);
+    constructor(initWallet: InitWallet);
     static init(): Promise<ExodusClient>;
     connect(): Promise<{
         accounts: {
@@ -48,5 +46,4 @@ declare class ExodusClient extends BaseWallet {
     signTransactions(activeAdress: string, transactions: Array<Uint8Array>): Promise<Uint8Array[]>;
     signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
 }
-declare const _default: Promise<void | ExodusClient>;
-export default _default;
+export default ExodusClient;

package/dist/cjs/clients/index.d.ts

@@ -1,406 +1,16 @@
-import { PROVIDER_ID } from "../constants";
+import peraWalletClient from "./perawallet";
+import myAlgoWalletClient from "./myalgowallet";
+import algoSignerClient from "./algosigner";
+import deflyClient from "./defly";
+import exodusClient from "./exodus";
+import kmdClient from "./kmd";
+import walletconnectClient from "./walletconnect";
 export declare const clients: {
-    "KMD Wallet": Promise<void | {
-        "__#6@#client": import("algosdk").Kmd;
-        walletId: string;
-        id: PROVIDER_ID;
-        provider: import("..").WalletProvider;
-        connect(): Promise<import("..").Wallet>;
-        disconnect(): Promise<void>;
-        reconnect(): Promise<import("..").Wallet | null>;
-        requestPassword(): Promise<string>;
-        getWalletToken(walletId: string, password: string): Promise<string>;
-        releaseToken(token: string): Promise<void>;
-        listWallets(): Promise<Record<string, string>>;
-        listAccounts(wallet: string, password: string): Promise<import("..").Account[]>;
-        signTransactions(activeAddress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
-        signEncodedTransactions(transactions: import("..").TransactionsArray): Promise<Uint8Array[]>;
-        algodClient: import("algosdk").Algodv2;
-        algosdk: typeof import("algosdk/dist/types/src/main");
-        keepWCAlive: HTMLAudioElement;
-        healthCheck(): Promise<{}>;
-        getAccountInfo(address: string): Promise<import("..").AccountInfo>;
-        getAssets(address: string): Promise<import("..").Asset[]>;
-        waitForConfirmation(txId: string, timeout?: number): Promise<{
-            "confirmed-round": number;
-            "global-state-delta": Record<string, unknown>[];
-            "pool-error": string;
-            txn: {
-                sig: Uint8Array;
-                txn: import("..").Txn;
-            };
-            txId: string;
-        }>;
-        decodeTransaction: (txn: string, isSigned: boolean) => import("algosdk").Transaction;
-        logEncodedTransaction(txn: string, isSigned: boolean): void;
-        groupTransactionsBySender(transactions: import("..").TransactionsArray): Record<string, any>;
-        sendRawTransactions(transactions: Uint8Array[]): Promise<{
-            "confirmed-round": number;
-            "global-state-delta": Record<string, unknown>[];
-            "pool-error": string;
-            txn: {
-                sig: Uint8Array;
-                txn: import("..").Txn;
-            };
-            txId: string;
-            id: any;
-        }>;
-        keepWCAliveStart(): void;
-        keepWCAliveStop(): void;
-    }>;
-    "Pera Wallet": Promise<void | {
-        "__#1@#client": import("@perawallet/connect/dist/PeraWalletConnect").default;
-        id: PROVIDER_ID;
-        provider: import("..").WalletProvider;
-        connect(onDisconnect: () => void): Promise<import("..").Wallet>;
-        reconnect(onDisconnect: () => void): Promise<{
-            accounts: {
-                name: string;
-                address: string;
-                providerId: PROVIDER_ID;
-            }[];
-            id: PROVIDER_ID;
-            name: string;
-            icon: string;
-            isWalletConnect: boolean;
-        } | null>;
-        disconnect(): Promise<void>;
-        formatTransactionsArray(transactions: import("..").TransactionsArray): import("./perawallet").PeraTransaction[];
-        signTransactions(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
-        signEncodedTransactions(transactions: import("..").TransactionsArray): Promise<Uint8Array[]>;
-        algodClient: import("algosdk").Algodv2;
-        algosdk: typeof import("algosdk/dist/types/src/main");
-        keepWCAlive: HTMLAudioElement;
-        healthCheck(): Promise<{}>;
-        getAccountInfo(address: string): Promise<import("..").AccountInfo>;
-        getAssets(address: string): Promise<import("..").Asset[]>;
-        waitForConfirmation(txId: string, timeout?: number): Promise<{
-            "confirmed-round": number;
-            "global-state-delta": Record<string, unknown>[];
-            "pool-error": string;
-            txn: {
-                sig: Uint8Array;
-                txn: import("..").Txn;
-            };
-            txId: string;
-        }>;
-        decodeTransaction: (txn: string, isSigned: boolean) => import("algosdk").Transaction;
-        logEncodedTransaction(txn: string, isSigned: boolean): void;
-        groupTransactionsBySender(transactions: import("..").TransactionsArray): Record<string, any>;
-        sendRawTransactions(transactions: Uint8Array[]): Promise<{
-            "confirmed-round": number;
-            "global-state-delta": Record<string, unknown>[];
-            "pool-error": string;
-            txn: {
-                sig: Uint8Array;
-                txn: import("..").Txn;
-            };
-            txId: string;
-            id: any;
-        }>;
-        keepWCAliveStart(): void;
-        keepWCAliveStop(): void;
-    }>;
-    "MyAlgo Wallet": Promise<void | {
-        "__#2@#client": import("@randlabs/myalgo-connect").default;
-        id: PROVIDER_ID;
-        provider: import("..").WalletProvider;
-        connect(): Promise<{
-            accounts: {
-                providerId: PROVIDER_ID;
-                address: string;
-                name: string;
-            }[];
-            id: PROVIDER_ID;
-            name: string;
-            icon: string;
-            isWalletConnect: boolean;
-        }>;
-        reconnect(): Promise<null>;
-        disconnect(): Promise<void>;
-        signTransactions(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
-        signEncodedTransactions(transactions: import("..").TransactionsArray): Promise<Uint8Array[]>;
-        algodClient: import("algosdk").Algodv2;
-        algosdk: typeof import("algosdk/dist/types/src/main");
-        keepWCAlive: HTMLAudioElement;
-        healthCheck(): Promise<{}>;
-        getAccountInfo(address: string): Promise<import("..").AccountInfo>;
-        getAssets(address: string): Promise<import("..").Asset[]>;
-        waitForConfirmation(txId: string, timeout?: number): Promise<{
-            "confirmed-round": number;
-            "global-state-delta": Record<string, unknown>[];
-            "pool-error": string;
-            txn: {
-                sig: Uint8Array;
-                txn: import("..").Txn;
-            };
-            txId: string;
-        }>;
-        decodeTransaction: (txn: string, isSigned: boolean) => import("algosdk").Transaction;
-        logEncodedTransaction(txn: string, isSigned: boolean): void;
-        groupTransactionsBySender(transactions: import("..").TransactionsArray): Record<string, any>;
-        sendRawTransactions(transactions: Uint8Array[]): Promise<{
-            "confirmed-round": number;
-            "global-state-delta": Record<string, unknown>[];
-            "pool-error": string;
-            txn: {
-                sig: Uint8Array;
-                txn: import("..").Txn;
-            };
-            txId: string;
-            id: any;
-        }>;
-        keepWCAliveStart(): void;
-        keepWCAliveStop(): void;
-    }>;
-    "Algo Signer": Promise<void | {
-        "__#3@#client": {
-            connect: () => Promise<Record<string, never>>;
-            accounts: (ledger: {
-                ledger: string;
-            }) => Promise<{
-                address: string;
-            }[]>;
-            signTxn: (transactions: {
-                txn: string;
-                signers?: [] | undefined;
-                multisig?: string | undefined;
-            }[]) => Promise<{
-                txID: string;
-                blob: string;
-            }[]>;
-            encoding: {
-                msgpackToBase64(transaction: Uint8Array): string;
-                byteArrayToString(transaction: Uint8Array): string;
-            };
-        };
-        id: PROVIDER_ID;
-        provider: import("..").WalletProvider;
-        connect(): Promise<{
-            accounts: {
-                name: string;
-                address: string;
-                providerId: PROVIDER_ID;
-            }[];
-            id: PROVIDER_ID;
-            name: string;
-            icon: string;
-            isWalletConnect: boolean;
-        }>;
-        reconnect(onDisconnect: () => void): Promise<null>;
-        disconnect(): Promise<void>;
-        formatTransactionsArray(transactions: import("..").TransactionsArray): {
-            txn: string;
-            signers?: [] | undefined;
-            multisig?: string | undefined;
-        }[];
-        signTransactions(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
-        signEncodedTransactions(transactions: import("..").TransactionsArray): Promise<Uint8Array[]>;
-        algodClient: import("algosdk").Algodv2;
-        algosdk: typeof import("algosdk/dist/types/src/main");
-        keepWCAlive: HTMLAudioElement;
-        healthCheck(): Promise<{}>;
-        getAccountInfo(address: string): Promise<import("..").AccountInfo>;
-        getAssets(address: string): Promise<import("..").Asset[]>;
-        waitForConfirmation(txId: string, timeout?: number): Promise<{
-            "confirmed-round": number;
-            "global-state-delta": Record<string, unknown>[];
-            "pool-error": string;
-            txn: {
-                sig: Uint8Array;
-                txn: import("..").Txn;
-            };
-            txId: string;
-        }>;
-        decodeTransaction: (txn: string, isSigned: boolean) => import("algosdk").Transaction;
-        logEncodedTransaction(txn: string, isSigned: boolean): void;
-        groupTransactionsBySender(transactions: import("..").TransactionsArray): Record<string, any>;
-        sendRawTransactions(transactions: Uint8Array[]): Promise<{
-            "confirmed-round": number;
-            "global-state-delta": Record<string, unknown>[];
-            "pool-error": string;
-            txn: {
-                sig: Uint8Array;
-                txn: import("..").Txn;
-            };
-            txId: string;
-            id: any;
-        }>;
-        keepWCAliveStart(): void;
-        keepWCAliveStop(): void;
-    }>;
-    Defly: Promise<void | {
-        "__#4@#client": import("@blockshake/defly-connect/dist/DeflyWalletConnect").default;
-        id: PROVIDER_ID;
-        provider: import("..").WalletProvider;
-        connect(onDisconnect: () => void): Promise<import("..").Wallet>;
-        reconnect(onDisconnect: () => void): Promise<{
-            accounts: {
-                name: string;
-                address: string;
-                providerId: PROVIDER_ID;
-            }[];
-            id: PROVIDER_ID;
-            name: string;
-            icon: string;
-            isWalletConnect: boolean;
-        } | null>;
-        disconnect(): Promise<void>;
-        formatTransactionsArray(transactions: import("..").TransactionsArray): import("./defly").DeflyTransaction[];
-        signTransactions(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
-        signEncodedTransactions(transactions: import("..").TransactionsArray): Promise<Uint8Array[]>;
-        algodClient: import("algosdk").Algodv2;
-        algosdk: typeof import("algosdk/dist/types/src/main");
-        keepWCAlive: HTMLAudioElement;
-        healthCheck(): Promise<{}>;
-        getAccountInfo(address: string): Promise<import("..").AccountInfo>;
-        getAssets(address: string): Promise<import("..").Asset[]>;
-        waitForConfirmation(txId: string, timeout?: number): Promise<{
-            "confirmed-round": number;
-            "global-state-delta": Record<string, unknown>[];
-            "pool-error": string;
-            txn: {
-                sig: Uint8Array;
-                txn: import("..").Txn;
-            };
-            txId: string;
-        }>;
-        decodeTransaction: (txn: string, isSigned: boolean) => import("algosdk").Transaction;
-        logEncodedTransaction(txn: string, isSigned: boolean): void;
-        groupTransactionsBySender(transactions: import("..").TransactionsArray): Record<string, any>;
-        sendRawTransactions(transactions: Uint8Array[]): Promise<{
-            "confirmed-round": number;
-            "global-state-delta": Record<string, unknown>[];
-            "pool-error": string;
-            txn: {
-                sig: Uint8Array;
-                txn: import("..").Txn;
-            };
-            txId: string;
-            id: any;
-        }>;
-        keepWCAliveStart(): void;
-        keepWCAliveStop(): void;
-    }>;
-    Exodus: Promise<void | {
-        "__#5@#client": {
-            isConnected: boolean;
-            address: string | null;
-            connect: () => Promise<{
-                address: string;
-            }>;
-            disconnect: () => void;
-            signAndSendTransaction(transactions: Readonly<Uint8Array>[]): Promise<{
-                txId: string;
-            }>;
-            signTransaction(transactions: Readonly<Uint8Array>[]): Promise<Readonly<Uint8Array>[]>;
-        };
-        id: PROVIDER_ID;
-        provider: import("..").WalletProvider;
-        connect(): Promise<{
-            accounts: {
-                name: string;
-                address: string;
-                providerId: PROVIDER_ID;
-            }[];
-            id: PROVIDER_ID;
-            name: string;
-            icon: string;
-            isWalletConnect: boolean;
-        }>;
-        reconnect(onDisconnect: () => void): Promise<null>;
-        disconnect(): Promise<void>;
-        signTransactions(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
-        signEncodedTransactions(transactions: import("..").TransactionsArray): Promise<Uint8Array[]>;
-        algodClient: import("algosdk").Algodv2;
-        algosdk: typeof import("algosdk/dist/types/src/main");
-        keepWCAlive: HTMLAudioElement;
-        healthCheck(): Promise<{}>;
-        getAccountInfo(address: string): Promise<import("..").AccountInfo>;
-        getAssets(address: string): Promise<import("..").Asset[]>;
-        waitForConfirmation(txId: string, timeout?: number): Promise<{
-            "confirmed-round": number;
-            "global-state-delta": Record<string, unknown>[];
-            "pool-error": string;
-            txn: {
-                sig: Uint8Array;
-                txn: import("..").Txn;
-            };
-            txId: string;
-        }>;
-        decodeTransaction: (txn: string, isSigned: boolean) => import("algosdk").Transaction;
-        logEncodedTransaction(txn: string, isSigned: boolean): void;
-        groupTransactionsBySender(transactions: import("..").TransactionsArray): Record<string, any>;
-        sendRawTransactions(transactions: Uint8Array[]): Promise<{
-            "confirmed-round": number;
-            "global-state-delta": Record<string, unknown>[];
-            "pool-error": string;
-            txn: {
-                sig: Uint8Array;
-                txn: import("..").Txn;
-            };
-            txId: string;
-            id: any;
-        }>;
-        keepWCAliveStart(): void;
-        keepWCAliveStop(): void;
-    }>;
-    "Wallet Connect": Promise<void | {
-        "__#7@#client": import("@walletconnect/client").default;
-        id: PROVIDER_ID;
-        provider: import("..").WalletProvider;
-        connect(): Promise<import("..").Wallet>;
-        reconnect(): Promise<{
-            accounts: {
-                name: string;
-                address: string;
-                providerId: PROVIDER_ID;
-            }[];
-            id: PROVIDER_ID;
-            name: string;
-            icon: string;
-            isWalletConnect: boolean;
-        } | null>;
-        check(): boolean;
-        disconnect(): Promise<void>;
-        formatTransactionsArray(transactions: import("..").TransactionsArray): {
-            txn: string;
-            message?: string | undefined;
-            signers?: [] | string[] | undefined;
-        }[];
-        signTransactions(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
-        signEncodedTransactions(transactions: import("..").TransactionsArray): Promise<Uint8Array[]>;
-        algodClient: import("algosdk").Algodv2;
-        algosdk: typeof import("algosdk/dist/types/src/main");
-        keepWCAlive: HTMLAudioElement;
-        healthCheck(): Promise<{}>;
-        getAccountInfo(address: string): Promise<import("..").AccountInfo>;
-        getAssets(address: string): Promise<import("..").Asset[]>;
-        waitForConfirmation(txId: string, timeout?: number): Promise<{
-            "confirmed-round": number;
-            "global-state-delta": Record<string, unknown>[];
-            "pool-error": string;
-            txn: {
-                sig: Uint8Array;
-                txn: import("..").Txn;
-            };
-            txId: string;
-        }>;
-        decodeTransaction: (txn: string, isSigned: boolean) => import("algosdk").Transaction;
-        logEncodedTransaction(txn: string, isSigned: boolean): void;
-        groupTransactionsBySender(transactions: import("..").TransactionsArray): Record<string, any>;
-        sendRawTransactions(transactions: Uint8Array[]): Promise<{
-            "confirmed-round": number;
-            "global-state-delta": Record<string, unknown>[];
-            "pool-error": string;
-            txn: {
-                sig: Uint8Array;
-                txn: import("..").Txn;
-            };
-            txId: string;
-            id: any;
-        }>;
-        keepWCAliveStart(): void;
-        keepWCAliveStop(): void;
-    }>;
+    "KMD Wallet": typeof kmdClient;
+    "Pera Wallet": typeof peraWalletClient;
+    "MyAlgo Wallet": typeof myAlgoWalletClient;
+    "Algo Signer": typeof algoSignerClient;
+    Defly: typeof deflyClient;
+    Exodus: typeof exodusClient;
+    "Wallet Connect": typeof walletconnectClient;
 };

package/dist/cjs/clients/kmd.d.ts

@@ -1,21 +1,19 @@
 import type { Kmd } from "algosdk";
 import BaseWallet from "./base";
-import type { InitAlgodClient } from "./base";
 import { PROVIDER_ID } from "../constants";
-import { providers } from "../providers";
 import type { Account, Wallet, WalletProvider } from "../types";
 import { TransactionsArray } from "../types";
 declare type InitWallet = {
     client: Kmd;
     id: PROVIDER_ID;
-    providers: typeof providers;
+    provider: WalletProvider;
 };
 declare class KMDWallet extends BaseWallet {
     #private;
     walletId: string;
     id: PROVIDER_ID;
     provider: WalletProvider;
-    constructor(initAlgodClient: InitAlgodClient, initWallet: InitWallet);
+    constructor(initWallet: InitWallet);
     static init(): Promise<KMDWallet>;
     connect(): Promise<Wallet>;
     disconnect(): Promise<void>;
@@ -28,5 +26,4 @@ declare class KMDWallet extends BaseWallet {
     signTransactions(activeAddress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
     signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
 }
-declare const _default: Promise<void | KMDWallet>;
-export default _default;
+export default KMDWallet;

package/dist/cjs/clients/myalgowallet.d.ts

@@ -3,22 +3,20 @@
  * https://github.com/randlabs/myalgo-connect
  */
 import BaseWallet from "./base";
-import type MyAlgoConnect from "@randlabs/myalgo-connect";
-import type { InitAlgodClient } from "./base";
+import MyAlgoConnect from "@randlabs/myalgo-connect";
 import { PROVIDER_ID } from "../constants";
-import { providers } from "../providers";
 import type { WalletProvider } from "../types";
 import { TransactionsArray } from "../types";
 declare type InitWallet = {
     id: PROVIDER_ID;
     client: MyAlgoConnect;
-    providers: typeof providers;
+    provider: WalletProvider;
 };
 declare class MyAlgoWalletClient extends BaseWallet {
     #private;
     id: PROVIDER_ID;
     provider: WalletProvider;
-    constructor(initAlgodClient: InitAlgodClient, initWallet: InitWallet);
+    constructor(initWallet: InitWallet);
     static init(): Promise<MyAlgoWalletClient>;
     connect(): Promise<{
         accounts: {
@@ -36,5 +34,4 @@ declare class MyAlgoWalletClient extends BaseWallet {
     signTransactions(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
     signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
 }
-declare const _default: Promise<void | MyAlgoWalletClient>;
-export default _default;
+export default MyAlgoWalletClient;