10143118155

Committed 26 Jun 2024 12:36PM UTC coverage: 75.281% (-2.0%) from 77.243%

Build # 10143118155

Build Type

push

github

Committed by

web-flow

Commit Message

[feature]: add bitte-wallet in wallet package (#517)

Co-authored-by: Ruben Marcus <ruben@rubenmarcus.dev>

Run Details

909 of 1395 branches covered (65.16%)

Branch coverage included in aggregate %.

12 of 62 new or added lines in 2 files covered. (19.35%)

2 existing lines in 1 file now uncovered.

1235 of 1453 relevant lines covered (85.0%)

13.45 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

11.96

/packages/auth/src/bitte-wallet.ts

import {
  setupWalletSelector,
  VerifiedOwner,
  VerifyOwnerParams,
  Wallet,
} from '@near-wallet-selector/core';
import { setupModal } from '@near-wallet-selector/modal-ui';
import { map, distinctUntilChanged, Subscription } from 'rxjs';

import {
  WALLET_CONNECTION_POLL_INTERVAL,
  WALLET_CONNECTION_TIMEOUT,
} from './constants';

import type {
  WalletSelector,
  AccountState,
  WalletModuleFactory,
} from '@near-wallet-selector/core';
import type { WalletSelectorModal } from '@near-wallet-selector/modal-ui';
import { SUPPORTED_NEAR_WALLETS } from './wallets.setup';
import { ERROR_MESSAGES } from './errorMessages';
import { mbjs } from '@mintbase-js/sdk';
import { setupBitteWallet } from '@mintbase-js/wallet';
import { ConnectionTimeoutError } from './wallet';

// mintbase SDK wallet functionality wraps
// Near Wallet Selector lib, provided by NEAR Protocol
// https://github.com/near/wallet-selector/

export type WalletSelectorComponents = {
  selector: WalletSelector;
  modal: WalletSelectorModal;
}


const walletUrls = {
  testnet: 'https://testnet.wallet.bitte.ai/',
  mainnet: 'https://wallet.bitte.ai',
};

export const BitteWalletAuth = {
  walletSelectorComponents: {
    selector: null,
    modal: null,
  },
  setupBitteWalletSelector: async (
    callbackUrl,
    onlyMbWallet = false,
    network?,
    contractAddress?,
    options?: { additionalWallets?: Array<WalletModuleFactory> },
  ): Promise<WalletSelectorComponents> => {


    if (onlyMbWallet === false) {

      BitteWalletAuth.walletSelectorComponents.selector = await setupWalletSelector({
        network: network,
        debug: mbjs.keys.debugMode,
        modules: [
          setupBitteWallet({
            walletUrl: walletUrls[network],
            deprecated: false,
            callbackUrl: callbackUrl,
          }),
          ...(options?.additionalWallets || []),
          ...SUPPORTED_NEAR_WALLETS,
        ],
      });
    } else {
      BitteWalletAuth.walletSelectorComponents.selector = await setupWalletSelector({
        network: network,
        debug: mbjs.keys.debugMode,
        modules: [
          setupBitteWallet({
            walletUrl: walletUrls[network],
            deprecated: false,
            callbackUrl: callbackUrl,
          }),
          ...(options?.additionalWallets || []),
        ],
      });
    }

    BitteWalletAuth.walletSelectorComponents.modal = setupModal( BitteWalletAuth.walletSelectorComponents.selector, {
      contractId: contractAddress,
    });

    return BitteWalletAuth.walletSelectorComponents;
  },
  setupWalletSelectorComponents: async (
    network?,
    contractAddress?,
    options?: { additionalWallets?: Array<WalletModuleFactory> },
  ): Promise<WalletSelectorComponents> => {
    const selector = await setupWalletSelector({
      network: network,
      debug: mbjs.keys.debugMode,
      modules: [
        ...SUPPORTED_NEAR_WALLETS,
        ...(options?.additionalWallets || []),
      ],
    });

    const modal = setupModal(selector, {
      contractId: contractAddress,
    });

    BitteWalletAuth.walletSelectorComponents = {
      selector,
      modal,
    };
    return BitteWalletAuth.walletSelectorComponents;
  },
  SetupNotCalledError: class extends Error {
    constructor(message?: string) {
      super(message);
      this.name = 'SetupNotCalledError';
    }
  },
  ConnectionTimeoutError: class extends Error {
    message: string
  },
  validateWalletComponentsAreSetup:(): void => {
    if (!BitteWalletAuth.walletSelectorComponents.selector) {
      throw new BitteWalletAuth.SetupNotCalledError(ERROR_MESSAGES.WALLET_SETUP_NOT_CALLED_ERROR);
    }
  },
  registerWalletAccountsSubscriber: (
    callback: (accounts: AccountState[]) => void,
  ): Subscription => {
    BitteWalletAuth.validateWalletComponentsAreSetup();

    return BitteWalletAuth.walletSelectorComponents.selector.store.observable
      .pipe(
        map((state:any) => state.accounts),
        distinctUntilChanged(),
      )
      .subscribe(callback);
  },
  timerReference: null,
  pollForWalletConnection: async (): Promise<AccountState[]> => {
    BitteWalletAuth.validateWalletComponentsAreSetup();
    // clear any existing timer
    clearTimeout(BitteWalletAuth.timerReference);

    const tryToResolveAccountsFromState = (
      resolve: (value: AccountState[]) => void,
      reject: (err: ConnectionTimeoutError) => void,
      elapsed = 0,
    ): void => {
      const { accounts } =
        BitteWalletAuth.walletSelectorComponents.selector.store.getState() || {};

      // accounts present in state
      if (accounts) {
        resolve(accounts);
      }

      // timed out
      if (elapsed > WALLET_CONNECTION_TIMEOUT) {
        reject(
          new ConnectionTimeoutError(ERROR_MESSAGES.WALLET_CONNECTION_NOT_FOUND),
        );
      }

      // try again
      clearTimeout(BitteWalletAuth.timerReference);
      BitteWalletAuth.timerReference = setTimeout(
        () =>
          tryToResolveAccountsFromState(
            resolve,
            reject,
            elapsed + WALLET_CONNECTION_POLL_INTERVAL,
          ),
        WALLET_CONNECTION_POLL_INTERVAL,
      );
    };

    return new Promise((resolve, reject) =>
      tryToResolveAccountsFromState(resolve, reject),
    );
  },
  getWallet: async (): Promise<Wallet> => {
    BitteWalletAuth.validateWalletComponentsAreSetup();

    return await BitteWalletAuth.walletSelectorComponents.selector.wallet();
  },
  connectWalletSelector:(): void => {
    BitteWalletAuth.validateWalletComponentsAreSetup();

    BitteWalletAuth.walletSelectorComponents.modal.show();
  },
  disconnectFromWalletSelector: async (): Promise<void> => {
    BitteWalletAuth.validateWalletComponentsAreSetup();

    const wallet = await BitteWalletAuth.walletSelectorComponents.selector.wallet();
    wallet.signOut();
  },
  getVerifiedOwner: async (
    params: VerifyOwnerParams,
  ): Promise<VerifiedOwner | undefined> => {
    BitteWalletAuth.validateWalletComponentsAreSetup();

    const { message, callbackUrl, meta } = params;

    const wallet = await BitteWalletAuth.walletSelectorComponents.selector.wallet();

    const owner = (await wallet.verifyOwner({
      message: message,
      callbackUrl: callbackUrl,
      meta: meta,
    })) as VerifiedOwner;

    return owner;
  },
  signMessage: async (
    params: VerifyOwnerParams,
  ): Promise<VerifiedOwner> => {
    const owner = await BitteWalletAuth.getVerifiedOwner(params);

    return owner;
  },
};

1	import {	3✔
2	setupWalletSelector,
3	VerifiedOwner,
4	VerifyOwnerParams,
5	Wallet,
6	} from '@near-wallet-selector/core';
7	import { setupModal } from '@near-wallet-selector/modal-ui';	3✔
8	import { map, distinctUntilChanged, Subscription } from 'rxjs';	3✔
9
10	import {	3✔
11	WALLET_CONNECTION_POLL_INTERVAL,
12	WALLET_CONNECTION_TIMEOUT,
13	} from './constants';
14
15	import type {
16	WalletSelector,
17	AccountState,
18	WalletModuleFactory,
19	} from '@near-wallet-selector/core';
20	import type { WalletSelectorModal } from '@near-wallet-selector/modal-ui';
21	import { SUPPORTED_NEAR_WALLETS } from './wallets.setup';	3✔
22	import { ERROR_MESSAGES } from './errorMessages';	3✔
23	import { mbjs } from '@mintbase-js/sdk';	3✔
24	import { setupBitteWallet } from '@mintbase-js/wallet';	3✔
25	import { ConnectionTimeoutError } from './wallet';	3✔
26
27	// mintbase SDK wallet functionality wraps
28	// Near Wallet Selector lib, provided by NEAR Protocol
29	// https://github.com/near/wallet-selector/
30
31	export type WalletSelectorComponents = {
32	selector: WalletSelector;
33	modal: WalletSelectorModal;
34	}
35
36
37	const walletUrls = {	3✔
38	testnet: 'https://testnet.wallet.bitte.ai/',
39	mainnet: 'https://wallet.bitte.ai',
40	};
41
42	export const BitteWalletAuth = {	3✔
43	walletSelectorComponents: {
44	selector: null,
45	modal: null,
46	},
47	setupBitteWalletSelector: async (
48	callbackUrl,
49	onlyMbWallet = false,	×
50	network?,
51	contractAddress?,
52	options?: { additionalWallets?: Array<WalletModuleFactory> },
NEW 53	): Promise<WalletSelectorComponents> => {	×
54
55
NEW 56	if (onlyMbWallet === false) {	×
57
NEW 58	BitteWalletAuth.walletSelectorComponents.selector = await setupWalletSelector({	×
59	network: network,
60	debug: mbjs.keys.debugMode,
61	modules: [
62	setupBitteWallet({
63	walletUrl: walletUrls[network],
64	deprecated: false,
65	callbackUrl: callbackUrl,
66	}),
67	...(options?.additionalWallets \|\| []),	×
68	...SUPPORTED_NEAR_WALLETS,
69	],
70	});
71	} else {
NEW 72	BitteWalletAuth.walletSelectorComponents.selector = await setupWalletSelector({	×
73	network: network,
74	debug: mbjs.keys.debugMode,
75	modules: [
76	setupBitteWallet({
77	walletUrl: walletUrls[network],
78	deprecated: false,
79	callbackUrl: callbackUrl,
80	}),
81	...(options?.additionalWallets \|\| []),	×
82	],
83	});
84	}
85
NEW 86	BitteWalletAuth.walletSelectorComponents.modal = setupModal( BitteWalletAuth.walletSelectorComponents.selector, {	×
87	contractId: contractAddress,
88	});
89
NEW 90	return BitteWalletAuth.walletSelectorComponents;	×
91	},
92	setupWalletSelectorComponents: async (
93	network?,
94	contractAddress?,
95	options?: { additionalWallets?: Array<WalletModuleFactory> },
NEW 96	): Promise<WalletSelectorComponents> => {	×
NEW 97	const selector = await setupWalletSelector({	×
98	network: network,
99	debug: mbjs.keys.debugMode,
100	modules: [
101	...SUPPORTED_NEAR_WALLETS,
102	...(options?.additionalWallets \|\| []),	×
103	],
104	});
105
NEW 106	const modal = setupModal(selector, {	×
107	contractId: contractAddress,
108	});
109
NEW 110	BitteWalletAuth.walletSelectorComponents = {	×
111	selector,
112	modal,
113	};
NEW 114	return BitteWalletAuth.walletSelectorComponents;	×
115	},
116	SetupNotCalledError: class extends Error {
117	constructor(message?: string) {
NEW 118	super(message);	×
NEW 119	this.name = 'SetupNotCalledError';	×
120	}
121	},
122	ConnectionTimeoutError: class extends Error {
123	message: string
124	},
125	validateWalletComponentsAreSetup:(): void => {
NEW 126	if (!BitteWalletAuth.walletSelectorComponents.selector) {	×
NEW 127	throw new BitteWalletAuth.SetupNotCalledError(ERROR_MESSAGES.WALLET_SETUP_NOT_CALLED_ERROR);	×
128	}
129	},
130	registerWalletAccountsSubscriber: (
131	callback: (accounts: AccountState[]) => void,
132	): Subscription => {
NEW 133	BitteWalletAuth.validateWalletComponentsAreSetup();	×
134
NEW 135	return BitteWalletAuth.walletSelectorComponents.selector.store.observable	×
136	.pipe(
NEW 137	map((state:any) => state.accounts),	×
138	distinctUntilChanged(),
139	)
140	.subscribe(callback);
141	},
142	timerReference: null,
NEW 143	pollForWalletConnection: async (): Promise<AccountState[]> => {	×
NEW 144	BitteWalletAuth.validateWalletComponentsAreSetup();	×
145	// clear any existing timer
NEW 146	clearTimeout(BitteWalletAuth.timerReference);	×
147
NEW 148	const tryToResolveAccountsFromState = (	×
149	resolve: (value: AccountState[]) => void,
150	reject: (err: ConnectionTimeoutError) => void,
151	elapsed = 0,	×
152	): void => {
153	const { accounts } =
NEW 154	BitteWalletAuth.walletSelectorComponents.selector.store.getState() \|\| {};	×
155
156	// accounts present in state
NEW 157	if (accounts) {	×
NEW 158	resolve(accounts);	×
159	}
160
161	// timed out
NEW 162	if (elapsed > WALLET_CONNECTION_TIMEOUT) {	×
NEW 163	reject(	×
164	new ConnectionTimeoutError(ERROR_MESSAGES.WALLET_CONNECTION_NOT_FOUND),
165	);
166	}
167
168	// try again
NEW 169	clearTimeout(BitteWalletAuth.timerReference);	×
NEW 170	BitteWalletAuth.timerReference = setTimeout(	×
171	() =>
NEW 172	tryToResolveAccountsFromState(	×
173	resolve,
174	reject,
175	elapsed + WALLET_CONNECTION_POLL_INTERVAL,
176	),
177	WALLET_CONNECTION_POLL_INTERVAL,
178	);
179	};
180
NEW 181	return new Promise((resolve, reject) =>	×
NEW 182	tryToResolveAccountsFromState(resolve, reject),	×
183	);
184	},
NEW 185	getWallet: async (): Promise<Wallet> => {	×
NEW 186	BitteWalletAuth.validateWalletComponentsAreSetup();	×
187
NEW 188	return await BitteWalletAuth.walletSelectorComponents.selector.wallet();	×
189	},
190	connectWalletSelector:(): void => {
NEW 191	BitteWalletAuth.validateWalletComponentsAreSetup();	×
192
NEW 193	BitteWalletAuth.walletSelectorComponents.modal.show();	×
194	},
NEW 195	disconnectFromWalletSelector: async (): Promise<void> => {	×
NEW 196	BitteWalletAuth.validateWalletComponentsAreSetup();	×
197
NEW 198	const wallet = await BitteWalletAuth.walletSelectorComponents.selector.wallet();	×
NEW 199	wallet.signOut();	×
200	},
201	getVerifiedOwner: async (
202	params: VerifyOwnerParams,
NEW 203	): Promise<VerifiedOwner \| undefined> => {	×
NEW 204	BitteWalletAuth.validateWalletComponentsAreSetup();	×
205
NEW 206	const { message, callbackUrl, meta } = params;	×
207
NEW 208	const wallet = await BitteWalletAuth.walletSelectorComponents.selector.wallet();	×
209
NEW 210	const owner = (await wallet.verifyOwner({	×
211	message: message,
212	callbackUrl: callbackUrl,
213	meta: meta,
214	})) as VerifiedOwner;
215
NEW 216	return owner;	×
217	},
218	signMessage: async (
219	params: VerifyOwnerParams,
NEW 220	): Promise<VerifiedOwner> => {	×
NEW 221	const owner = await BitteWalletAuth.getVerifiedOwner(params);	×
222
NEW 223	return owner;	×
224	},
225	};

Mintbase / mintbase-js / 10143118155

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous