@txnlab/use-wallet 2.4.0 → 2.6.0

package/dist/esm/src/clients/base/base.d.ts

@@ -8,7 +8,7 @@ declare abstract class BaseClient {
     keepWCAlive: HTMLAudioElement;
     metadata: Metadata;
     static metadata: Metadata;
-    abstract connect(onDisconnect: () => void): Promise<Wallet>;
+    abstract connect(onDisconnect: () => void, arg?: any): Promise<Wallet>;
     abstract disconnect(): Promise<void>;
     abstract reconnect(onDisconnect: () => void): Promise<Wallet | null>;
     abstract signTransactions(connectedAccounts: string[], txnGroups: Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;

package/dist/esm/src/clients/index.d.ts

@@ -6,12 +6,14 @@ import exodus from './exodus';
 import algosigner from './algosigner';
 import lute from './lute';
 import walletconnect from './walletconnect2';
+import magic from './magic';
 import kmd from './kmd';
 import mnemonic from './mnemonic';
 import { CustomProvider } from './custom/types';
 import custom from './custom';
-export { pera, myalgo, defly, exodus, algosigner, lute, walletconnect, kmd, mnemonic, custom, CustomProvider };
+import kibisis from './kibisis';
+export { pera, myalgo, defly, exodus, algosigner, lute, walletconnect, kmd, mnemonic, custom, CustomProvider, kibisis, magic };
 declare const _default: {
-    [x: string]: typeof pera | typeof myalgo | typeof defly | typeof exodus | typeof algosigner | typeof lute | typeof walletconnect | typeof kmd | typeof mnemonic | typeof custom | typeof daffi;
+    [x: string]: typeof pera | typeof myalgo | typeof defly | typeof exodus | typeof algosigner | typeof lute | typeof walletconnect | typeof kmd | typeof mnemonic | typeof custom | typeof kibisis | typeof magic | typeof daffi;
 };
 export default _default;

package/dist/esm/src/clients/kibisis/client.d.ts

@@ -0,0 +1,73 @@
+import BaseClient from '../base';
+import { PROVIDER_ID } from '../../constants';
+import type { InitParams, Network, Wallet } from '../../types';
+import type { Arc0027Account, KibisisClientConstructor, ProviderMethods, SendRequestWithTimeoutOptions } from './types';
+declare class KibisisClient extends BaseClient {
+    genesisHash: string;
+    methods: ProviderMethods[];
+    network: Network;
+    constructor({ metadata, algosdk, algodClient, genesisHash, methods, network }: KibisisClientConstructor);
+    static metadata: {
+        id: PROVIDER_ID;
+        icon: string;
+        isWalletConnect: boolean;
+        name: string;
+    };
+    /**
+     * public static functions
+     */
+    static init({ algodOptions, algosdkStatic, network }: InitParams<PROVIDER_ID.KIBISIS>): Promise<BaseClient | null>;
+    static mapAccountsToWallet(accounts: Arc0027Account[]): Wallet;
+    static sendRequestWithTimeout<Params, Result>({ method, params, timeout, reference }: SendRequestWithTimeoutOptions<Params>): Promise<Result | undefined>;
+    /**
+     * private functions
+     */
+    private convertBytesToBase64;
+    private convertBase64ToBytes;
+    /**
+     * 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;
+    /**
+     * Convenience function that 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 refreshSupportedMethods;
+    /**
+     * 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 {ProviderMethods} method -  the method to validate.
+     * @throws {METHOD_NOT_SUPPORTED_ERROR} if the method is not supported for the configured network.
+     */
+    private validateMethod;
+    /**
+     * public functions
+     */
+    connect(): Promise<Wallet>;
+    disconnect(): Promise<void>;
+    reconnect(): Promise<Wallet | null>;
+    signTransactions(connectedAccounts: string[], transactions: Uint8Array[], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
+}
+export default KibisisClient;

package/dist/esm/src/clients/kibisis/constants.d.ts

@@ -0,0 +1,37 @@
+/**
+ * arc-0027
+ */
+export declare const ARC_0027_PREFIX = "arc0027";
+export declare const ARC_0027_CHANNEL_NAME: string;
+export declare const ARC_0027_ENABLE_REQUEST: string;
+export declare const ARC_0027_GET_PROVIDERS_REQUEST: string;
+export declare const ARC_0027_PROVIDER_ID = "f6d1c86b-4493-42fb-b88d-a62407b4cdf6";
+export declare const ARC_0027_SIGN_TXNS_REQUEST: string;
+/**
+ * errors
+ */
+export declare const UNKNOWN_ERROR = 4000;
+export declare const METHOD_CANCELED_ERROR = 4001;
+export declare const METHOD_TIMED_OUT_ERROR = 4002;
+export declare const METHOD_NOT_SUPPORTED_ERROR = 4003;
+export declare const NETWORK_NOT_SUPPORTED_ERROR = 4004;
+export declare const UNAUTHORIZED_SIGNER_ERROR = 4100;
+export declare const INVALID_INPUT_ERROR = 4200;
+export declare const INVALID_GROUP_ID_ERROR = 4201;
+/**
+ * genesis hashes
+ */
+export declare const ALGORAND_BETANET_GENESIS_HASH = "mFgazF+2uRS1tMiL9dsj01hJGySEmPN28B/TjjvpVW0=";
+export declare const ALGORAND_MAINNET_GENESIS_HASH = "wGHE2Pwdvd7S12BL5FaOP20EGYesN73ktiC1qzkkit8=";
+export declare const ALGORAND_TESTNET_GENESIS_HASH = "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=";
+export declare const VOI_TESTNET_GENESIS_HASH = "IXnoWtviVVJW5LGivNFc0Dq14V3kqaXuK2u5OQrdVZo=";
+/**
+ * timeouts
+ */
+export declare const DEFAULT_REQUEST_TIMEOUT = 180000;
+export declare const LOWER_REQUEST_TIMEOUT = 750;
+export declare const UPPER_REQUEST_TIMEOUT = 300000;
+/**
+ * icon
+ */
+export declare const ICON: string;

package/dist/esm/src/clients/kibisis/index.d.ts

@@ -0,0 +1,2 @@
+import kibisis from './client';
+export default kibisis;

package/dist/esm/src/clients/kibisis/types.d.ts

@@ -0,0 +1,86 @@
+import type algosdk from 'algosdk';
+import type { Metadata, Network } from '../../types';
+export interface Arc0001SignTxns {
+    authAddr?: string;
+    multisig?: string;
+    signers?: string[];
+    stxn?: string;
+    txn: string;
+}
+export interface Arc0027Account {
+    address: string;
+    name?: string;
+}
+export interface KibisisClientConstructor {
+    metadata: Metadata;
+    algosdk: typeof algosdk;
+    algodClient: algosdk.Algodv2;
+    genesisHash: string;
+    methods: ProviderMethods[];
+    network: Network;
+}
+export interface NetworkConfiguration {
+    genesisHash: string;
+    genesisId: string;
+    methods: ProviderMethods[];
+}
+export type ProviderMethods = 'enable' | 'getProviders' | 'postTxns' | 'signAndPostTxns' | 'signBytes' | 'signTxns';
+export interface SendRequestWithTimeoutOptions<Params> {
+    method: ProviderMethods;
+    params: Params;
+    reference: string;
+    timeout?: number;
+}
+/**
+ * message schema
+ */
+export interface RequestMessage<Params> {
+    id: string;
+    params: Params;
+    reference: string;
+}
+export interface ResponseMessage<Result = undefined, ErrorData = undefined> {
+    error?: ResponseError<ErrorData>;
+    id: string;
+    reference: string;
+    requestId: string;
+    result?: Result;
+}
+export interface ResponseError<Data = undefined> {
+    code: number;
+    data: Data;
+    message: string;
+    providerId: string;
+}
+/**
+ * message payloads
+ */
+export interface EnableParams {
+    genesisHash: string;
+    providerId: string;
+}
+export interface EnableResult {
+    accounts: Arc0027Account[];
+    genesisHash: string;
+    genesisId: string;
+    providerId: string;
+    sessionId?: string;
+}
+export interface GetProvidersParams {
+    providerId: string;
+}
+export interface GetProvidersResult {
+    host: string;
+    icon: string;
+    name: string;
+    networks: NetworkConfiguration[];
+    providerId: string;
+}
+export interface SignTxnsParams {
+    providerId: string;
+    txns: Arc0001SignTxns[];
+}
+export interface SignTxnsResult {
+    providerId: string;
+    stxns: (string | null)[];
+}

package/dist/esm/src/clients/kibisis/utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Generates a UUID version 4 string. This function attempts to use the `crypto.randomUUID()` function from the Web
+ * Crypto API if it is available, otherwise it uses a polyfill method.
+ *
+ * NOTE: `crypto.randomUUID()` is not available in non-secure contexts; only localhost and HTTPS.
+ * @returns {string} a valid UUID version 4 string.
+ * @see {@link https://stackoverflow.com/a/2117523}
+ */
+export declare function generateUuid(): string;

package/dist/esm/src/clients/kibisis/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/src/clients/magic/client.d.ts

@@ -0,0 +1,35 @@
+import BaseClient from '../base';
+import { PROVIDER_ID } from '../../constants';
+import type { Network } from '../../types/node';
+import type { InitParams } from '../../types/providers';
+import type { Wallet } from '../../types/wallet';
+import type { MagicAuthConstructor, MagicAuthConnectOptions } from './types';
+declare class MagicAuth extends BaseClient {
+    #private;
+    clientOptions?: MagicAuthConnectOptions;
+    network: Network;
+    constructor({ metadata, client, clientOptions, algosdk, algodClient, network }: MagicAuthConstructor);
+    static metadata: {
+        id: PROVIDER_ID;
+        name: string;
+        icon: string;
+        isWalletConnect: boolean;
+    };
+    static init({ clientOptions, algodOptions, clientStatic, getDynamicClient, algosdkStatic, network }: InitParams<PROVIDER_ID.MAGIC>): Promise<BaseClient | null>;
+    connect(_: () => void, arg?: any): Promise<Wallet>;
+    reconnect(): Promise<{
+        accounts: {
+            name: string;
+            address: string;
+            providerId: PROVIDER_ID;
+            email: string;
+        }[];
+        id: PROVIDER_ID;
+        name: string;
+        icon: string;
+        isWalletConnect: boolean;
+    } | null>;
+    disconnect(): Promise<void>;
+    signTransactions(connectedAccounts: string[], txnGroups: Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
+}
+export default MagicAuth;

package/dist/esm/src/clients/magic/constants.d.ts

@@ -0,0 +1 @@
+export declare const ICON: string;

package/dist/esm/src/clients/magic/index.d.ts

@@ -0,0 +1,2 @@
+import magic from './client';
+export default magic;

package/dist/esm/src/clients/magic/types.d.ts

@@ -0,0 +1,27 @@
+import type algosdk from 'algosdk';
+import type { Network } from '../../types/node';
+import type { Metadata } from '../../types/wallet';
+import { SDKBase, InstanceWithExtensions } from '@magic-sdk/provider';
+import { AlgorandExtension } from '@magic-ext/algorand';
+export type MagicAuthConnectOptions = {
+    apiKey: string;
+};
+export interface MagicAuthTransaction {
+    txn: 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[];
+}
+export type MagicAuthConstructor = {
+    metadata: Metadata;
+    client: InstanceWithExtensions<SDKBase, {
+        algorand: AlgorandExtension;
+    }>;
+    clientOptions: MagicAuthConnectOptions;
+    algosdk: typeof algosdk;
+    algodClient: algosdk.Algodv2;
+    network: Network;
+};

package/dist/esm/src/constants/constants.d.ts

@@ -9,8 +9,10 @@ export declare enum PROVIDER_ID {
     ALGOSIGNER = "algosigner",
     DEFLY = "defly",
     EXODUS = "exodus",
+    KIBISIS = "kibisis",
     WALLETCONNECT = "walletconnect",
-    MNEMONIC = "mnemonic"
+    MNEMONIC = "mnemonic",
+    MAGIC = "magic"
 }
 export declare const DEFAULT_NETWORK: Network;
 export declare const DEFAULT_NODE_BASEURL = "https://mainnet-api.algonode.cloud";

package/dist/esm/src/testUtils/mockClients.d.ts

@@ -3,6 +3,7 @@ import DaffiWalletClient from '../clients/daffi/client';
 import DeflyWalletClient from '../clients/defly/client';
 import ExodusClient from '../clients/exodus/client';
 import LuteClient from '../clients/lute/client';
+import KibisisClient from '../clients/kibisis/client';
 import KMDWalletClient from '../clients/kmd/client';
 import MnemonicWalletClient from '../clients/mnemonic/client';
 import MyAlgoWalletClient from '../clients/myalgo/client';
@@ -11,6 +12,7 @@ import WalletConnectClient from '../clients/walletconnect2/client';
 import { PROVIDER_ID } from '../constants';
 import type { Account, ClientOptions } from '../types';
 import CustomWalletClient from '../clients/custom/client';
+import MagicAuthClient from '../clients/magic/client';
 type ClientTypeMap = {
     [PROVIDER_ID.ALGOSIGNER]: AlgoSignerClient;
     [PROVIDER_ID.CUSTOM]: CustomWalletClient;
@@ -23,6 +25,8 @@ type ClientTypeMap = {
     [PROVIDER_ID.PERA]: PeraWalletClient;
     [PROVIDER_ID.WALLETCONNECT]: WalletConnectClient;
     [PROVIDER_ID.LUTE]: LuteClient;
+    [PROVIDER_ID.KIBISIS]: KibisisClient;
+    [PROVIDER_ID.MAGIC]: MagicAuthClient;
 };
 export declare const createMockClient: <T extends PROVIDER_ID>(providerId: T, clientOptions?: ClientOptions, accounts?: Array<Account>) => ClientTypeMap[T];
 export declare const createAlgoSignerMockInstance: (clientOptions?: ClientOptions, accounts?: Array<Account>) => AlgoSignerClient;
@@ -30,10 +34,12 @@ export declare const createDaffiMockInstance: (clientOptions?: ClientOptions, ac
 export declare const createDeflyMockInstance: (clientOptions?: ClientOptions, accounts?: Array<Account>) => DeflyWalletClient;
 export declare const createExodusMockInstance: (clientOptions?: ClientOptions, accounts?: Array<Account>) => ExodusClient;
 export declare const createLuteMockInstance: (clientOptions?: ClientOptions, accounts?: Array<Account>) => LuteClient;
+export declare const createKibisisMockInstance: (clientOptions?: ClientOptions, accounts?: Array<Account>) => KibisisClient;
 export declare const createKmdMockInstance: (clientOptions?: ClientOptions, accounts?: Array<Account>) => KMDWalletClient;
 export declare const createCustomMockInstance: (clientOptions?: ClientOptions, accounts?: Array<Account>) => CustomWalletClient;
 export declare const createMnemonicMockInstance: (clientOptions?: ClientOptions, accounts?: Array<Account>) => MnemonicWalletClient;
 export declare const createMyAlgoMockInstance: (clientOptions?: ClientOptions, accounts?: Array<Account>) => MyAlgoWalletClient;
 export declare const createPeraMockInstance: (clientOptions?: ClientOptions, accounts?: Array<Account>) => PeraWalletClient;
 export declare const createWalletConnectMockInstance: (clientOptions?: ClientOptions, accounts?: Array<Account>) => WalletConnectClient;
+export declare const createMagicMockInstance: (clientOptions?: ClientOptions, accounts?: Array<Account>) => MagicAuthClient;
 export {};

package/dist/esm/src/types/providers.d.ts

@@ -17,6 +17,7 @@ import type { DaffiWalletConnectOptions } from '../clients/daffi/types';
 import type { NonEmptyArray } from './utilities';
 import type BaseClient from '../clients/base';
 import type { CustomOptions } from '../clients/custom/types';
+import { Magic } from 'magic-sdk';
 export type ProviderConfigMapping = {
     [PROVIDER_ID.PERA]: {
         clientOptions?: PeraWalletConnectOptions;
@@ -73,6 +74,18 @@ export type ProviderConfigMapping = {
         clientStatic?: undefined;
         getDynamicClient?: undefined;
     };
+    [PROVIDER_ID.KIBISIS]: {
+        clientOptions?: undefined;
+        clientStatic?: undefined;
+        getDynamicClient?: undefined;
+    };
+    [PROVIDER_ID.MAGIC]: {
+        clientOptions?: {
+            apiKey: string;
+        };
+        clientStatic?: undefined;
+        getDynamicClient?: () => Promise<typeof Magic>;
+    };
 };
 /**
  * Enforces correct configuration given for each provider. For example,
@@ -108,11 +121,15 @@ type DynamicClient<T> = {
     getDynamicClient: () => Promise<T>;
 };
 type OneOfStaticOrDynamicClient<T> = StaticClient<T> | DynamicClient<T>;
-type ProviderDef = (ProviderConfig<PROVIDER_ID.PERA> & OneOfStaticOrDynamicClient<typeof PeraWalletConnect>) | (ProviderConfig<PROVIDER_ID.DEFLY> & OneOfStaticOrDynamicClient<typeof DeflyWalletConnect>) | (ProviderConfig<PROVIDER_ID.DAFFI> & OneOfStaticOrDynamicClient<typeof DaffiWalletConnect>) | (ProviderConfig<PROVIDER_ID.LUTE> & OneOfStaticOrDynamicClient<typeof LuteConnect> & {
+type ProviderDef = (ProviderConfig<PROVIDER_ID.PERA> & OneOfStaticOrDynamicClient<typeof PeraWalletConnect>) | (ProviderConfig<PROVIDER_ID.MAGIC> & OneOfStaticOrDynamicClient<typeof Magic> & {
+    clientOptions: {
+        apiKey: string;
+    };
+}) | (ProviderConfig<PROVIDER_ID.DEFLY> & OneOfStaticOrDynamicClient<typeof DeflyWalletConnect>) | (ProviderConfig<PROVIDER_ID.DAFFI> & OneOfStaticOrDynamicClient<typeof DaffiWalletConnect>) | (ProviderConfig<PROVIDER_ID.LUTE> & OneOfStaticOrDynamicClient<typeof LuteConnect> & {
     clientOptions: LuteConnectOptions;
 }) | (ProviderConfig<PROVIDER_ID.WALLETCONNECT> & OneOfStaticOrDynamicClient<typeof WalletConnectModalSign> & {
     clientOptions: WalletConnectModalSignOptions;
-}) | (ProviderConfig<PROVIDER_ID.MYALGO> & OneOfStaticOrDynamicClient<typeof MyAlgoConnect>) | ProviderConfig<PROVIDER_ID.EXODUS> | ProviderConfig<PROVIDER_ID.KMD> | ProviderConfig<PROVIDER_ID.CUSTOM> | PROVIDER_ID.EXODUS | PROVIDER_ID.KMD | PROVIDER_ID.ALGOSIGNER | PROVIDER_ID.MNEMONIC | PROVIDER_ID.CUSTOM;
+}) | (ProviderConfig<PROVIDER_ID.MYALGO> & OneOfStaticOrDynamicClient<typeof MyAlgoConnect>) | ProviderConfig<PROVIDER_ID.EXODUS> | ProviderConfig<PROVIDER_ID.KMD> | ProviderConfig<PROVIDER_ID.CUSTOM> | ProviderConfig<PROVIDER_ID.KIBISIS> | PROVIDER_ID.EXODUS | PROVIDER_ID.KMD | PROVIDER_ID.ALGOSIGNER | PROVIDER_ID.MNEMONIC | PROVIDER_ID.CUSTOM | PROVIDER_ID.KIBISIS;
 export type ProvidersArray = NonEmptyArray<ProviderDef>;
 export type WalletClient = BaseClient;
 export type SupportedProviders = Partial<Record<PROVIDER_ID, WalletClient | null>>;

package/dist/esm/src/types/wallet.d.ts

@@ -4,12 +4,13 @@ export interface Account {
     name: string;
     address: string;
     authAddr?: string;
+    email?: string;
 }
 export type Provider = {
     accounts: Account[];
     isActive: boolean;
     isConnected: boolean;
-    connect: () => Promise<void>;
+    connect: (arg?: any) => Promise<void>;
     disconnect: () => Promise<void>;
     reconnect: () => Promise<void>;
     setActiveProvider: () => void;