@arthur2079/internal-profile 0.1.2-next.7 → 0.10.1-next.1

package/dist/store/thunks.js

@@ -0,0 +1,223 @@
+import { createAsyncThunk } from '@reduxjs/toolkit';
+import axios from 'axios';
+import { getLoginMessage, getMergeAccountMessage, getProfileDetails, getProfileLeaderboard, getProfileSummary, getPublicLeaderboard, getPublicProfileLeaderboard, getPublicProfileSummary, getSetClaimMessage, logIn, logOut, mergeAccount, setClaimWallet, updateProfileData, UserUnauthorizedError, } from '../api/mod';
+import { extractPublickKeyFromCosmosInstance, getErrorMessage, throwIfAborted } from './helpers';
+import { memoizeThunk } from './utils';
+// To learn more about this pattern, check https://github.com/rango-exchange/app-v2/pull/281
+export function createSignMessage() {
+    const actionType = 'profile/signMessage';
+    const signMessageThunk = memoizeThunk(actionType, () => createAsyncThunk(actionType, async (params, options) => {
+        const { rejectWithValue, getState, dispatch, signal } = options;
+        const { account, getSigners, callback, errorCallback } = params;
+        const { meta: { blockchains }, profile: { profileAuth, isLoggedIn }, } = getState();
+        const { numberOfRetries } = profileAuth;
+        throwIfAborted(signal);
+        const signer = await getSigners(account.walletType);
+        const blockchainMeta = blockchains.find((blockchain) => blockchain.name === account.blockchain);
+        if (!blockchainMeta) {
+            return rejectWithValue('Something went wrong. Please try again.');
+        }
+        let signAction;
+        let saveAction;
+        if (isLoggedIn) {
+            signAction = getMergeAccountMessage;
+            saveAction = mergeAccount;
+        }
+        else {
+            signAction = getLoginMessage;
+            saveAction = logIn;
+        }
+        try {
+            throwIfAborted(signal);
+            const pubKeyBase64 = await extractPublickKeyFromCosmosInstance(account.walletType, {
+                blockchainMeta,
+            });
+            const { message, messageId } = await signAction({
+                address: account.address,
+                blockchain: account.blockchain,
+                pubKeyBase64,
+            }, signal);
+            throwIfAborted(signal);
+            const signature = await signer
+                .getSigner(blockchainMeta.type)
+                .signMessage(message, account.address, blockchainMeta.chainId);
+            throwIfAborted(signal);
+            const { profile } = await saveAction({ messageId, signature, pubKeyBase64 }, signal);
+            if (profile) {
+                callback?.(profile, { actionType: isLoggedIn ? 'merge' : 'login' });
+            }
+            return profile;
+        }
+        catch (error) {
+            if (signal.aborted || axios.isCancel(error)) {
+                return null;
+            }
+            const shouldLogOutAndRetry = !isLoggedIn && error instanceof UserUnauthorizedError && numberOfRetries === 0;
+            if (shouldLogOutAndRetry) {
+                await logOut(signal);
+                // Use a timeout to dispatch signMessage after incrementing the numberOfRetries.
+                setTimeout(async () => dispatch(signMessageThunk()(params)), 0);
+                return null;
+            }
+            errorCallback?.(error);
+            return rejectWithValue(getErrorMessage(error));
+        }
+    }));
+    return signMessageThunk();
+}
+export function createFetchProfileSummary() {
+    const actionType = 'profile/fetchProfileSummary';
+    const fetchProfileSummaryThunk = memoizeThunk(actionType, () => createAsyncThunk(actionType, async (params, options) => {
+        const { rejectWithValue, signal, getState, fulfillWithValue, dispatch } = options;
+        const state = getState().profile;
+        const publicProfile = params.public ||
+            !state.isLoggedIn ||
+            (state.isLoggedIn && state.username !== params.username);
+        const request = publicProfile
+            ? getPublicProfileSummary.bind(null, params.username)
+            : getProfileSummary;
+        try {
+            const profileSummary = await request(signal);
+            return fulfillWithValue(profileSummary.profile);
+        }
+        catch (error) {
+            if (error instanceof UserUnauthorizedError) {
+                dispatch(fetchProfileSummaryThunk()({ username: params.username, public: true }));
+                return rejectWithValue(null);
+            }
+            return rejectWithValue(getErrorMessage(error));
+        }
+    }));
+    return fetchProfileSummaryThunk();
+}
+export function createSetClaim() {
+    const actionType = 'profile/setClaim';
+    const setClaimThunk = memoizeThunk(actionType, () => createAsyncThunk(actionType, async (params, options) => {
+        const { rejectWithValue, getState, dispatch, signal } = options;
+        const { account, getSigners } = params;
+        const { meta: { blockchains }, } = getState();
+        throwIfAborted(signal);
+        const signer = await getSigners(account.walletType);
+        const blockchainMeta = blockchains.find((blockchain) => blockchain.name === account.blockchain);
+        if (!blockchainMeta) {
+            return rejectWithValue(`We couldn't find ${account.blockchain} in our initial data. Please try again.`);
+        }
+        try {
+            throwIfAborted(signal);
+            const { message, messageId } = await getSetClaimMessage({
+                address: account.address,
+                blockchain: account.blockchain,
+            }, signal);
+            throwIfAborted(signal);
+            const signature = await signer
+                .getSigner(blockchainMeta.type)
+                .signMessage(message, account.address, blockchainMeta.chainId);
+            throwIfAborted(signal);
+            const { profile } = await setClaimWallet({ messageId, signature }, signal);
+            return profile;
+        }
+        catch (error) {
+            if (signal.aborted || axios.isCancel(error)) {
+                return null;
+            }
+            return rejectWithValue(getErrorMessage(error));
+        }
+    }));
+    return setClaimThunk();
+}
+export function createRequestLogOutUser() {
+    const actionType = 'profile/logOut';
+    const logOutThunk = memoizeThunk(actionType, () => createAsyncThunk(actionType, async (_, options) => {
+        const { rejectWithValue, signal } = options;
+        try {
+            await logOut(signal);
+        }
+        catch (error) {
+            return rejectWithValue(getErrorMessage(error));
+        }
+    }));
+    return logOutThunk();
+}
+export function createProfileThunks() {
+    const fetchProfileDetails = createAsyncThunk('profile/fetchProfileDetails', async (_, options) => {
+        const { rejectWithValue, signal } = options;
+        try {
+            const profileDetails = await getProfileDetails(signal);
+            return profileDetails.profile;
+        }
+        catch (error) {
+            if (error instanceof UserUnauthorizedError) {
+                return rejectWithValue(null);
+            }
+            return rejectWithValue(getErrorMessage(error));
+        }
+    });
+    const fetchProfileLeaderboard = createAsyncThunk('profile/fetchProfileLeaderboard', async (params, options) => {
+        const { rejectWithValue, signal, getState, dispatch } = options;
+        const state = getState().profile;
+        const publicProfile = params.public ||
+            !state.isLoggedIn ||
+            (state.isLoggedIn && state.username !== params.username);
+        const request = publicProfile
+            ? getPublicProfileLeaderboard.bind(null, params.username)
+            : getProfileLeaderboard;
+        try {
+            const profileLeaderboard = await request(signal);
+            return profileLeaderboard.data;
+        }
+        catch (error) {
+            if (error instanceof UserUnauthorizedError) {
+                dispatch(fetchProfileLeaderboard({ username: params.username, public: true }));
+                return rejectWithValue(null);
+            }
+            return rejectWithValue(getErrorMessage(error));
+        }
+    });
+    const fetchPublicLeaderboard = createAsyncThunk('profile/fetchPublicLeaderboard', async (params, options) => {
+        const { rejectWithValue, signal } = options;
+        try {
+            const leaderboard = await getPublicLeaderboard(params, signal);
+            return { leaderboard: leaderboard.data, totalPages: leaderboard.totalPages };
+        }
+        catch (error) {
+            return rejectWithValue(getErrorMessage(error));
+        }
+    });
+    const fetchTopPublicLeaderboard = createAsyncThunk('profile/fetchTopPublicLeaderboard', async (params, options) => {
+        const { rejectWithValue, signal } = options;
+        try {
+            const leaderboard = await getPublicLeaderboard({ type: params.type, page: 0, offset: 10 }, signal);
+            return leaderboard.data;
+        }
+        catch (error) {
+            return rejectWithValue(getErrorMessage(error));
+        }
+    });
+    const updateUsername = createAsyncThunk('profile/updateUsername', async (params, options) => {
+        const { rejectWithValue, signal } = options;
+        const { userName, callback } = params;
+        const DEFAULT_ERROR_MESSAGE = 'An error occurred while updating the username.';
+        try {
+            const result = await updateProfileData({ userName }, signal);
+            if (result.success) {
+                callback();
+                return { username: userName };
+            }
+            return rejectWithValue(DEFAULT_ERROR_MESSAGE);
+        }
+        catch (error) {
+            return rejectWithValue(error instanceof Error ? error.message : DEFAULT_ERROR_MESSAGE);
+        }
+    });
+    return {
+        signMessage: createSignMessage(),
+        fetchProfileSummary: createFetchProfileSummary(),
+        fetchProfileDetails,
+        fetchProfileLeaderboard,
+        fetchPublicLeaderboard,
+        fetchTopPublicLeaderboard,
+        updateUsername,
+        requestLogOutUser: createRequestLogOutUser(),
+        setClaim: createSetClaim(),
+    };
+}

package/dist/store/types.d.ts

@@ -0,0 +1,67 @@
+import type { ProfileAccount, ProfileDetails, ProfileLeaderboard, ProfileSummary } from '../api/mod';
+import type { useWallets } from '@rango-dev/widget-embedded';
+type ProfileAuth = {
+    numberOfRetries: number;
+    accountMerged: boolean;
+} & ({
+    loading: true;
+    error: null;
+    account: ProfileAccount;
+    accountMerged: false;
+} | {
+    loading: false;
+    error: string | null;
+    account: null;
+});
+type ProfileSummaryState = {
+    loading: boolean;
+    error: string | null;
+    data: ProfileSummary | null;
+};
+export type ProfileState = {
+    isLoggedIn: boolean;
+    username: string | null;
+    profileAuth: ProfileAuth;
+    profileSummary: {
+        private: ProfileSummaryState;
+        public: ProfileSummaryState;
+    };
+    profileDetails: {
+        loading: boolean;
+        error: string | null;
+        data: ProfileDetails | null;
+    };
+    profileLeaderboard: {
+        loading: boolean;
+        error: string | null;
+        data: ProfileLeaderboard[] | null;
+    };
+    publicLeaderboard: {
+        loading: boolean;
+        error: string | null;
+        totalPages: number | null;
+        data: ProfileLeaderboard[] | null;
+    };
+    topPublicLeaderboard: {
+        loading: boolean;
+        error: string | null;
+        data: ProfileLeaderboard[] | null;
+    };
+    updateUsername: {
+        loading: boolean;
+        error: string | null;
+    };
+    logOut: {
+        loading: boolean;
+        error: string | null;
+    };
+};
+export type SignMessageParams = {
+    account: ProfileAccount;
+    getSigners: ReturnType<typeof useWallets>['getSigners'];
+    callback?: (profileSummary: ProfileSummary, meta: {
+        actionType: 'login' | 'merge';
+    }) => void;
+    errorCallback?: (error: unknown) => void;
+};
+export {};

package/dist/store/types.js

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

package/dist/store/utils.d.ts

@@ -0,0 +1 @@
+export declare function memoizeThunk<Result>(key: string, callback: () => Result): () => Result;

package/dist/store/utils.js

@@ -0,0 +1,11 @@
+const memoizedThunks = new Map();
+export function memoizeThunk(key, callback) {
+    return () => {
+        let result = memoizedThunks.get(key);
+        if (!result) {
+            result = callback();
+            memoizedThunks.set(key, result);
+        }
+        return result;
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,3 @@
+export interface Cancellable {
+    abort: () => void;
+}

package/dist/types.js

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

package/dist/utils/mod.d.ts

@@ -0,0 +1 @@
+export { walletAndSupportedChainsNames, getAddedAccountsToProfile, getConciseAddress, } from './wallets';

package/dist/utils/mod.js

@@ -0,0 +1 @@
+export { walletAndSupportedChainsNames, getAddedAccountsToProfile, getConciseAddress, } from './wallets';

package/dist/utils/wallets.d.ts

@@ -0,0 +1,16 @@
+import type { ProfileSummary } from '../api/mod';
+import type { Networks, WalletInfoWithExtra } from '@rango-dev/widget-embedded';
+import type { BlockchainMeta } from 'rango-types';
+export type ExtendedModalWalletInfo = WalletInfoWithExtra & {
+    isHub?: boolean;
+};
+export declare function walletAndSupportedChainsNames(supportedChains: BlockchainMeta[]): Networks[] | null;
+export declare function checkIsWalletPartiallyConnected(wallet: ExtendedModalWalletInfo, namespacesState?: Map<string, {
+    connected: boolean;
+}>): boolean;
+export declare function getAddedAccountsToProfile(profileSummary: ProfileSummary): {
+    address: string;
+    blockchain: string;
+    walletType: null;
+}[];
+export declare const getConciseAddress: (address: string | null, maxChars?: number) => string | null;

package/dist/utils/wallets.js

@@ -0,0 +1,34 @@
+export function walletAndSupportedChainsNames(supportedChains) {
+    if (!supportedChains) {
+        return null;
+    }
+    let walletAndSupportedChainsNames = [];
+    walletAndSupportedChainsNames = supportedChains.map((blockchainMeta) => blockchainMeta.name);
+    return walletAndSupportedChainsNames;
+}
+export function checkIsWalletPartiallyConnected(wallet, namespacesState) {
+    if (!wallet.isHub || !wallet.needsNamespace || wallet.state !== 'connected') {
+        return false;
+    }
+    const namespaces = wallet.needsNamespace.data;
+    const supportedNamespaces = namespaces.filter((namespace) => !namespace.unsupported);
+    return supportedNamespaces.some((namespace) => !namespacesState?.get(namespace.value)?.connected);
+}
+export function getAddedAccountsToProfile(profileSummary) {
+    return profileSummary.wallets.map((account) => ({
+        address: account.address,
+        blockchain: account.blockchain,
+        walletType: null,
+    }));
+}
+// eslint-disable-next-line @typescript-eslint/no-magic-numbers
+export const getConciseAddress = (address, maxChars = 6) => {
+    if (address === undefined || address === null) {
+        return null;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-magic-numbers
+    if (address.length < 2 * maxChars + 3) {
+        return address;
+    }
+    return address.substr(0, maxChars) + '...' + address.substr(address.length - maxChars);
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arthur2079/internal-profile",
   "type": "module",
-  "version": "0.1.2-next.7",
+  "version": "0.10.1-next.1",
   "license": "MIT",
   "private": false,
   "exports": {
@@ -39,23 +39,23 @@
     "dev": "tsc -p ./tsconfig.json --watch"
   },
   "devDependencies": {
-    "@arthur2079/internal-social-wallet": "^0.1.1-next.6",
-    "@rango-dev/widget-embedded": "^0.59.1",
+    "@arthur2079/internal-social-wallet": "^0.10.1-next.1",
+    "@rango-dev/widget-embedded": "^0.60.1",
     "@reduxjs/toolkit": "^1.6.0",
     "@types/node": "^14.14.31",
     "@types/react": "^18.0.26",
     "@types/react-dom": "^18.0.10",
     "axios": "^1.16.0",
     "immer": "*",
-    "rango-types": "^0.1.98"
+    "rango-types": "^0.5.0"
   },
   "peerDependencies": {
-    "@arthur2079/internal-social-wallet": "^0.1.1-next.6",
-    "@rango-dev/widget-embedded": "^0.59.1",
+    "@arthur2079/internal-social-wallet": "^0.10.1-next.1",
+    "@rango-dev/widget-embedded": "^0.60.1",
     "@reduxjs/toolkit": "^1.6.0",
     "axios": "^1.16.0",
     "immer": "*",
-    "rango-types": "^0.1.98"
+    "rango-types": "^0.5.0"
   },
   "publishConfig": {
     "access": "public",