@manahippo/aptos-wallet-adapter 1.0.3 → 1.0.6

package/src/WalletAdapters/SpacecyWallet.ts

@@ -0,0 +1,350 @@
+
+
+import { MaybeHexString, Types } from 'aptos';
+import {
+    WalletAccountChangeError,
+    WalletDisconnectionError,
+    WalletGetNetworkError,
+    WalletNetworkChangeError,
+    WalletNotConnectedError,
+    WalletNotReadyError,
+    WalletSignAndSubmitMessageError,
+    WalletSignMessageError,
+    WalletSignTransactionError
+} from '../WalletProviders/errors';
+import {
+    AccountKeys,
+    BaseWalletAdapter,
+    NetworkInfo,
+    scopePollingDetectionStrategy,
+    SignMessagePayload,
+    SignMessageResponse,
+    WalletAdapterNetwork,
+    WalletName,
+    WalletReadyState
+} from './BaseAdapter';
+interface ConnectSpacecyAccount {
+    address: MaybeHexString;
+    method: string;
+    publicKey: MaybeHexString;
+    status: number;
+}
+
+interface SpacecyAccount {
+    address: MaybeHexString;
+    publicKey?: MaybeHexString;
+    authKey?: MaybeHexString;
+    isConnected: boolean;
+}
+export interface ISpacecyWallet {
+    checkIsConnectedAndAccount: () => Promise<{ isConnected: boolean, accountWallet: MaybeHexString }>;
+    connect: () => Promise<ConnectSpacecyAccount>;
+    account(): Promise<MaybeHexString>;
+    publicKey(): Promise<MaybeHexString>;
+    signAndSubmitTransaction(
+        transaction: Types.TransactionPayload,
+        options?: any
+    ): Promise<{
+        status: number;
+        data: Types.HexEncodedBytes;
+        method: 'signAndSubmitTransaction';
+    }>;
+    isConnected(): Promise<boolean>;
+    signTransaction(transaction: Types.TransactionPayload, options?: any): Promise<{
+        status: number;
+        data: Uint8Array;
+        method: 'signTransaction';
+    }>
+    signMessage(message: SignMessagePayload): Promise<{
+        status: number;
+        data: SignMessageResponse;
+        method: 'signMessage';
+    }>;
+    generateTransaction(sender: MaybeHexString, payload: any, options?: any): Promise<any>;
+    disconnect(): Promise<void>;
+    chainId(): Promise<void>;
+    network(): Promise<NetworkInfo>;
+    onAccountChange(listener: (address: string | undefined) => void): Promise<void>;
+    onNetworkChange(listener: (network: NetworkInfo) => void): Promise<void>;
+}
+
+
+
+interface SpacecyWindow extends Window {
+    spacecy?: ISpacecyWallet;
+}
+
+declare const window: SpacecyWindow;
+
+const SpacecyWalletName = 'Spacecy' as WalletName<'Spacecy'>;
+
+export interface SpacecyWalletAdapterConfig {
+    provider?: ISpacecyWallet;
+    // network?: WalletAdapterNetwork;
+    timeout?: number;
+}
+
+export class SpacecyWalletAdapter extends BaseWalletAdapter {
+    name = SpacecyWalletName;
+
+    url = 'https://chrome.google.com/webstore/detail/spacecy-wallet/mkchoaaiifodcflmbaphdgeidocajadp?hl=en-US';
+
+    icon = 'https://spacecywallet.com/favicon.ico';
+
+    protected _provider: ISpacecyWallet | undefined;
+
+    protected _network: WalletAdapterNetwork | undefined;
+
+    protected _chainId: string | undefined;
+
+    protected _api: string | undefined;
+
+    protected _timeout: number;
+
+    protected _readyState: WalletReadyState =
+        typeof window === 'undefined' || typeof document === 'undefined'
+            ? WalletReadyState.Unsupported
+            : WalletReadyState.NotDetected;
+
+    protected _connecting: boolean;
+
+    protected _wallet: SpacecyAccount | null;
+
+    constructor({
+        // provider,
+        // network = WalletAdapterNetwork.Testnet,
+        timeout = 10000
+    }: SpacecyWalletAdapterConfig = {}) {
+        super();
+
+        this._provider = typeof window !== 'undefined' ? window.spacecy : undefined;
+        this._network = undefined;
+        this._timeout = timeout;
+        this._connecting = false;
+        this._wallet = null;
+
+        if (typeof window !== 'undefined' && this._readyState !== WalletReadyState.Unsupported) {
+            scopePollingDetectionStrategy(() => {
+                if (window.spacecy) {
+                    this._readyState = WalletReadyState.Installed;
+                    this.emit('readyStateChange', this._readyState);
+                    return true;
+                }
+                return false;
+            });
+        }
+    }
+
+    get publicAccount(): AccountKeys {
+        return {
+            publicKey: this._wallet?.publicKey || null,
+            address: this._wallet?.address || null,
+            authKey: this._wallet?.authKey || null
+        };
+    }
+
+    get network(): NetworkInfo {
+        return {
+            name: this._network,
+            api: this._api,
+            chainId: this._chainId
+        };
+    }
+
+    get connecting(): boolean {
+        return this._connecting;
+    }
+
+    get connected(): boolean {
+        return !!this._wallet?.isConnected;
+    }
+
+    get readyState(): WalletReadyState {
+        return this._readyState;
+    }
+
+    async connect(): Promise<void> {
+        try {
+            if (this.connected || this.connecting) return;
+            if (
+                !(
+                    this._readyState === WalletReadyState.Loadable ||
+                    this._readyState === WalletReadyState.Installed
+                )
+            )
+                throw new WalletNotReadyError();
+            this._connecting = true;
+            const provider = this._provider || window.spacecy;
+            const response: any = await provider?.connect()
+
+
+
+
+            if (!response) {
+                throw new WalletNotConnectedError('No connect response');
+            }
+            const walletAccount = response.data.address;
+            const publicKey = response.data.publicKey;
+            if (walletAccount) {
+                this._wallet = {
+                    address: walletAccount,
+                    publicKey,
+                    isConnected: true
+                };
+
+                try {
+                    const networkInfo: any = await provider?.chainId();
+                    if (networkInfo) {
+                        this._network = networkInfo.data.networkName;
+                        this._chainId = networkInfo.data.chainId;
+                        this._api = networkInfo.data.rpcProvider
+                    }
+                } catch (error: any) {
+                    const errMsg = error.message;
+                    this.emit('error', new WalletGetNetworkError(errMsg));
+                    throw error;
+                }
+            }
+
+
+            this.emit('connect', this._wallet?.address || '');
+        } catch (error: any) {
+            this.emit('error', new Error('User has rejected the connection'));
+            throw error;
+        } finally {
+            this._connecting = false;
+        }
+    }
+
+    async disconnect(): Promise<void> {
+        const wallet = this._wallet;
+        const provider = this._provider || window.spacecy;
+        if (wallet) {
+            this._wallet = null;
+            try {
+                await provider?.disconnect();
+            } catch (error: any) {
+                this.emit('error', new WalletDisconnectionError(error?.message, error));
+            }
+        }
+        this.emit('disconnect');
+    }
+
+    async signTransaction(
+        transactionPyld: Types.TransactionPayload,
+        options?: any
+    ): Promise<Uint8Array> {
+        try {
+            const wallet = this._wallet;
+            const provider = this._provider || window.spacecy;
+            if (!wallet || !provider) throw new WalletNotConnectedError();
+            const tx = await provider.generateTransaction(wallet.address || '', transactionPyld, options);
+            if (!tx) throw new Error('Cannot generate transaction');
+            const response = await provider?.signTransaction(tx.data);
+            if (!response) {
+                throw new Error('No response');
+            }
+            return response.data;
+        } catch (error: any) {
+            this.emit('error', new WalletSignTransactionError(error));
+            throw error;
+        }
+    }
+    async signAndSubmitTransaction(
+        transactionPyld: Types.TransactionPayload,
+        options?: any
+    ): Promise<{ hash: Types.HexEncodedBytes }> {
+        try {
+            const wallet = this._wallet;
+            const provider = this._provider || window.spacecy;
+            if (!wallet || !provider) throw new WalletNotConnectedError();
+            const response = await provider?.signAndSubmitTransaction(transactionPyld, options);
+
+
+            if (!response || response.status != 200) {
+                throw new Error('No response');
+            }
+            return { hash: response.data };
+        } catch (error: any) {
+            this.emit('error', new WalletSignAndSubmitMessageError(error.message));
+            throw error;
+        }
+    }
+
+
+    async signMessage(msgPayload: SignMessagePayload): Promise<SignMessageResponse> {
+        try {
+            const wallet = this._wallet;
+            const provider = this._provider || window.spacecy;
+            if (!wallet || !provider) throw new WalletNotConnectedError();
+            if (typeof msgPayload !== 'object' || !msgPayload.nonce) {
+                throw new WalletSignMessageError('Invalid signMessage Payload');
+            }
+            const response = await provider?.signMessage(msgPayload);
+            if (response.status == 200) {
+                return response.data;
+            } else {
+                throw new Error('Sign Message failed');
+            }
+        } catch (error: any) {
+            const errMsg = error.message;
+            this.emit('error', new WalletSignMessageError(errMsg));
+            throw error;
+        }
+    }
+
+    async onAccountChange(): Promise<void> {
+        try {
+            const wallet = this._wallet;
+            const provider = this._provider || window.spacecy;
+            if (!wallet || !provider) throw new WalletNotConnectedError();
+            const handleAccountChange = async (newAccount: any) => {
+                // disconnect wallet if newAccount is undefined
+                if (newAccount.data == 'no account') {
+                    if (this.connected) {
+                        await this.disconnect();
+                    }
+                    return;
+                }
+                if (newAccount.data == "") {
+                    this._wallet = { publicKey: "", address: "", authKey: "", isConnected: false }
+                }
+                // const newPublicKey = await provider?.publicKey();
+                if (this._wallet != null) {
+                    this._wallet = {
+                        ...this._wallet,
+                        address: newAccount.data == 'no account' ? undefined : newAccount.data,
+                        publicKey: undefined
+                    };
+                }
+                this.emit('accountChange', newAccount);
+            };
+            await provider?.onAccountChange(handleAccountChange);
+        } catch (error: any) {
+            const errMsg = error.message;
+            this.emit('error', new WalletAccountChangeError(errMsg));
+            throw error;
+        }
+    }
+
+    async onNetworkChange(): Promise<void> {
+        try {
+            const wallet = this._wallet;
+            const provider = this._provider || window.spacecy;
+            if (!wallet || !provider) throw new WalletNotConnectedError();
+            const handleNetworkChange = (network: any) => {
+                this._network = network.data.networkName;
+                this._api = network.data.rpcProvider
+                this._chainId = network.data.chainId;
+                if (this._network) {
+                    this.emit('networkChange', this._network);
+                }
+            };
+            await provider?.onNetworkChange(handleNetworkChange);
+        } catch (error: any) {
+            const errMsg = error.message;
+            this.emit('error', new WalletNetworkChangeError(errMsg));
+            throw error;
+        }
+    }
+}

package/src/WalletAdapters/index.ts

@@ -18,4 +18,7 @@ export * from './BloctoWallet';
 export * from './Coin98Wallet';
 export * from './SafePalWallet';
 export * from './FoxWallet';
-export * from './MsafeWallet';
+// export * from './MsafeWallet';
+export * from './OpenBlockWallet';
+export * from './CloverWallet';
+export * from './SpacecyWallet';

package/src/WalletProviders/WalletProvider.tsx

@@ -58,7 +58,7 @@ export const WalletProvider: FC<WalletProviderProps> = ({
   const readyState = adapter?.readyState || WalletReadyState.Unsupported;
   const [connecting, setConnecting] = useState(false);
   const [disconnecting, setDisconnecting] = useState(false);
-  const isConnecting = useRef(false);
+  // const isConnecting = useRef(false);
   const isDisconnecting = useRef(false);
   const isUnloading = useRef(false);
 
@@ -226,7 +226,7 @@ export const WalletProvider: FC<WalletProviderProps> = ({
   // Connect the adapter to the wallet
   const connect = useCallback(
     async (walletName?) => {
-      if (isConnecting.current || isDisconnecting.current || connected || !walletName) return;
+      if (isDisconnecting.current || connected || !walletName) return;
       let walletToConnect = initialState;
       if (!adapter || walletName !== adapter?.name) {
         const selectedWallet = wallets.find((wAdapter) => wAdapter.adapter.name === walletName);
@@ -266,7 +266,7 @@ export const WalletProvider: FC<WalletProviderProps> = ({
 
         throw handleError(new WalletNotReadyError('Wallet Not Ready'));
       }
-      isConnecting.current = true;
+      // isConnecting.current = true;
       setConnecting(true);
       try {
         const timeout = timeoutPromise(TIMEOUT * 1000);
@@ -282,7 +282,7 @@ export const WalletProvider: FC<WalletProviderProps> = ({
         }
       } finally {
         setConnecting(false);
-        isConnecting.current = false;
+        // isConnecting.current = false;
       }
     },
     [connected, adapter, handleError, wallets, setName, wallet, account, network]
@@ -291,7 +291,6 @@ export const WalletProvider: FC<WalletProviderProps> = ({
   // If autoConnect is enabled, try to connect when the adapter changes and is ready
   useEffect(() => {
     if (
-      isConnecting.current ||
       connected ||
       !autoConnect ||
       !name ||
@@ -300,7 +299,7 @@ export const WalletProvider: FC<WalletProviderProps> = ({
     )
       return;
     connect(name);
-  }, [isConnecting, connected, autoConnect, name, connect, adapter, readyState]);
+  }, [connected, autoConnect, name, connect, adapter, readyState]);
 
   // Disconnect the adapter from the wallet
   const disconnect = useCallback(async () => {