@manahippo/aptos-wallet-adapter 0.4.2 → 0.4.4

package/src/WalletAdapters/HyperPayWallet.ts

@@ -0,0 +1,237 @@
+import { MaybeHexString } from 'aptos';
+import { TransactionPayload, HexEncodedBytes } from 'aptos/src/generated';
+import {
+  WalletDisconnectionError,
+  WalletNotConnectedError,
+  WalletNotReadyError,
+  WalletSignAndSubmitMessageError,
+  WalletSignMessageError,
+  WalletSignTransactionError
+} from '../WalletProviders/errors';
+import {
+  AccountKeys,
+  BaseWalletAdapter,
+  scopePollingDetectionStrategy,
+  WalletName,
+  WalletReadyState
+} from './BaseAdapter';
+
+interface ConnectHyperPayAccount {
+  address: MaybeHexString;
+  method: string;
+  publicKey: MaybeHexString;
+  status: number;
+}
+
+interface HyperPayAccount {
+  address: MaybeHexString;
+  publicKey: MaybeHexString;
+  authKey: MaybeHexString;
+  isConnected: boolean;
+}
+interface IHyperPayWallet {
+  connect: () => Promise<ConnectHyperPayAccount>;
+  account(): Promise<HyperPayAccount>;
+  isConnected(): Promise<boolean>;
+  generateTransaction(sender: MaybeHexString, payload: any, options?: any): Promise<any>;
+  signAndSubmitTransaction(transaction: TransactionPayload): Promise<HexEncodedBytes>;
+  signTransaction(transaction: TransactionPayload): Promise<Uint8Array>;
+  signMessage(message: string): Promise<{ signature: string }>;
+  disconnect(): Promise<void>;
+}
+
+interface HyperPayWindow extends Window {
+  hyperpay?: IHyperPayWallet;
+}
+
+declare const window: HyperPayWindow;
+
+export const HyperPayWalletName = 'HyperPay' as WalletName<'HyperPay'>;
+
+export interface HyperPayWalletAdapterConfig {
+  provider?: IHyperPayWallet;
+  // network?: WalletAdapterNetwork;
+  timeout?: number;
+}
+
+export class HyperPayWalletAdapter extends BaseWalletAdapter {
+  name = HyperPayWalletName;
+
+  url = 'https://www.hyperpay.tech/';
+
+  icon =
+    'data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAxMjE1IDEyMTUiPjxwYXRoIGQ9Ik02MDcuNSAwQzk0My4wMTMgMCAxMjE1IDI3MS45ODcgMTIxNSA2MDcuNVM5NDMuMDEzIDEyMTUgNjA3LjUgMTIxNSAwIDk0My4wMTMgMCA2MDcuNSAyNzEuOTg3IDAgNjA3LjUgMHpNMzUxLjY4IDM3MS4zMTVzMy43MDgtNzIuOSA3Ny43Ni03Mi45aDIwNC4xMnMxMTkuNDM3LS4xIDIwNC4xMiA3NS4zM2MwIDAgMTExLjg0MyA5My42MTIgMTE2LjY0IDIzNS43MSAwIDAgMS45NjIgMTE5LjA0NS03Mi45IDIxMS40MSAwIDAtNzcuOTMxIDEyMS41LTI2Mi40NCAxMjEuNUg0NDEuNTlzLTg5LjkxIDExLjA0OS04OS45MS04NS4wNXYtNDg2ek0xMTkuMzQ0IDU1My42NTlzLjkwNi0xNy44MiAxOS4wMDgtMTcuODJoNDkuOXMyOS4yLS4wMjMgNDkuOSAxOC40MTRjMCAwIDI3LjMzOSAyMi44ODMgMjguNTEyIDU3LjYxOCAwIDAgLjQ4IDI5LjEtMTcuODIgNTEuNjc4IDAgMC0xOS4wNSAyOS43LTY0LjE1MiAyOS43aC00My4zN3MtMjEuOTc4IDIuNy0yMS45NzgtMjAuNzl2LTExOC44eiIgZmlsbD0iIzE1N0VGQiIgZmlsbC1ydWxlPSJldmVub2RkIi8+PC9zdmc+';
+
+  protected _provider: IHyperPayWallet | undefined;
+
+  // protected _network: WalletAdapterNetwork;
+  protected _timeout: number;
+
+  protected _readyState: WalletReadyState =
+    typeof window === 'undefined' || typeof document === 'undefined'
+      ? WalletReadyState.Unsupported
+      : WalletReadyState.NotDetected;
+
+  protected _connecting: boolean;
+
+  protected _wallet: HyperPayAccount | null;
+
+  constructor({
+    // provider,
+    // network = WalletAdapterNetwork.Mainnet,
+    timeout = 10000
+  }: HyperPayWalletAdapterConfig = {}) {
+    super();
+
+    this._provider = typeof window !== 'undefined' ? window.hyperpay : undefined;
+    // this._network = network;
+    this._timeout = timeout;
+    this._connecting = false;
+    this._wallet = null;
+
+    if (typeof window !== 'undefined' && this._readyState !== WalletReadyState.Unsupported) {
+      scopePollingDetectionStrategy(() => {
+        if (window.hyperpay) {
+          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 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.hyperpay;
+      const isConnected = await provider?.isConnected();
+      if (isConnected) {
+        await provider?.disconnect();
+      }
+      const response = await provider?.connect();
+
+      if (!response) {
+        throw new WalletNotConnectedError('No connect response');
+      }
+
+      const walletAccount = await provider?.account();
+      if (walletAccount) {
+        this._wallet = {
+          ...walletAccount,
+          isConnected: true
+        };
+      }
+      this.emit('connect', this._wallet?.address || '');
+    } catch (error: any) {
+      this.emit('error', new Error(error));
+      throw error;
+    } finally {
+      this._connecting = false;
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    const wallet = this._wallet;
+    const provider = this._provider || window.hyperpay;
+    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: TransactionPayload, options?: any): Promise<Uint8Array> {
+    try {
+      const wallet = this._wallet;
+      const provider = this._provider || window.hyperpay;
+      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);
+
+      if (!response) {
+        throw new Error('No response');
+      }
+      return response;
+    } catch (error: any) {
+      this.emit('error', new WalletSignTransactionError(error));
+      throw error;
+    }
+  }
+
+  async signAndSubmitTransaction(
+    transactionPyld: TransactionPayload,
+    options?: any
+  ): Promise<{ hash: HexEncodedBytes }> {
+    try {
+      const wallet = this._wallet;
+      const provider = this._provider || window.hyperpay;
+      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?.signAndSubmitTransaction(tx);
+
+      if (!response) {
+        throw new Error('No response');
+      }
+      return { hash: response };
+    } catch (error: any) {
+      this.emit('error', new WalletSignAndSubmitMessageError(error));
+      throw error;
+    }
+  }
+
+  async signMessage(message: string): Promise<string> {
+    try {
+      const wallet = this._wallet;
+      const provider = this._provider || window.hyperpay;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+      const response = await provider?.signMessage(message);
+      if (response?.signature) {
+        return response?.signature;
+      } else {
+        throw new Error('Sign Message failed');
+      }
+    } catch (error: any) {
+      const errMsg = error.message;
+      this.emit('error', new WalletSignMessageError(errMsg));
+      throw error;
+    }
+  }
+}

package/src/WalletAdapters/PetraWallet.ts

@@ -53,7 +53,8 @@ export interface AptosWalletAdapterConfig {
 export class AptosWalletAdapter extends BaseWalletAdapter {
   name = AptosWalletName;
 
-  url = 'https://aptos.dev/guides/building-wallet-extension';
+  url =
+    'https://chrome.google.com/webstore/detail/petra-aptos-wallet/ejjladinnckdgjemekebdpeokbikhfci';
 
   icon = 'https://miro.medium.com/fit/c/176/176/1*Gf747eyRywU8Img0tK5wvw.png';
 

package/src/WalletAdapters/PontemWallet.ts

@@ -12,6 +12,8 @@ import {
   AccountKeys,
   BaseWalletAdapter,
   scopePollingDetectionStrategy,
+  SignMessagePayload,
+  SignMessageResponse,
   WalletName,
   WalletReadyState
 } from './BaseAdapter';
@@ -45,11 +47,9 @@ interface IPontemWallet {
   }>;
   isConnected(): Promise<boolean>;
   signTransaction(transaction: TransactionPayload, options?: any): Promise<Uint8Array>;
-  signMessage(message: string): Promise<{
+  signMessage(message: SignMessagePayload): Promise<{
     success: boolean;
-    result: {
-      hexString: HexEncodedBytes;
-    };
+    result: SignMessageResponse;
   }>;
   disconnect(): Promise<void>;
 }
@@ -221,20 +221,19 @@ export class PontemWalletAdapter extends BaseWalletAdapter {
       }
       return { hash: response.result.hash };
     } catch (error: any) {
-      this.emit('error', new WalletSignAndSubmitMessageError(error.error.message));
+      this.emit('error', new WalletSignAndSubmitMessageError(error.message));
       throw error;
     }
   }
 
-  async signMessage(message: string): Promise<string> {
+  async signMessage(messagePayload: SignMessagePayload): Promise<SignMessageResponse> {
     try {
       const wallet = this._wallet;
       const provider = this._provider || window.pontem;
       if (!wallet || !provider) throw new WalletNotConnectedError();
-      const response = await provider?.signMessage(message);
-      console.log('MEMEM>>>', response);
+      const response = await provider?.signMessage(messagePayload);
       if (response.success) {
-        return response.result.hexString;
+        return response.result;
       } else {
         throw new Error('Sign Message failed');
       }

package/src/WalletAdapters/RiseWallet.ts

@@ -0,0 +1,238 @@
+import { HexEncodedBytes, TransactionPayload } from 'aptos/src/generated';
+import {
+  WalletDisconnectionError,
+  WalletNotConnectedError,
+  WalletNotReadyError,
+  WalletSignMessageError,
+  WalletSignTransactionError
+} from '../WalletProviders';
+import {
+  AccountKeys,
+  BaseWalletAdapter,
+  scopePollingDetectionStrategy,
+  SignMessagePayload,
+  SignMessageResponse,
+  WalletName,
+  WalletReadyState
+} from './BaseAdapter';
+import { MaybeHexString } from 'aptos';
+
+interface RiseAccount {
+  address: MaybeHexString;
+  publicKey: MaybeHexString;
+  authKey: MaybeHexString;
+  isConnected: boolean;
+}
+
+interface IRiseWallet {
+  connect: () => Promise<{ address: string }>;
+  account(): Promise<RiseAccount>;
+  isConnected: () => Promise<boolean>;
+  signAndSubmitTransaction(transaction: any): Promise<{ hash: HexEncodedBytes }>;
+  signTransaction(transaction: any, options?: any): Promise<Uint8Array>;
+  signMessage(message: SignMessagePayload): Promise<SignMessageResponse>;
+  disconnect(): Promise<void>;
+}
+
+interface RiseWindow extends Window {
+  rise?: IRiseWallet;
+}
+
+declare const window: RiseWindow;
+
+export const RiseWalletName = 'Rise Wallet' as WalletName<'Rise Wallet'>;
+
+export interface RiseWalletAdapterConfig {
+  provider?: IRiseWallet;
+  // network?: WalletAdapterNetwork;
+  timeout?: number;
+}
+
+export class RiseWalletAdapter extends BaseWalletAdapter {
+  name = RiseWalletName;
+
+  url = 'https://chrome.google.com/webstore/detail/hbbgbephgojikajhfbomhlmmollphcad';
+
+  icon = 'https://static.risewallet.io/logo.png';
+
+  protected _provider: IRiseWallet | undefined;
+
+  // protected _network: WalletAdapterNetwork;
+  protected _timeout: number;
+
+  protected _readyState: WalletReadyState =
+    typeof window === 'undefined' || typeof document === 'undefined'
+      ? WalletReadyState.Unsupported
+      : WalletReadyState.NotDetected;
+
+  protected _connecting: boolean;
+
+  protected _wallet: any | null;
+
+  constructor({
+    // provider,
+    // network = WalletAdapterNetwork.Mainnet,
+    timeout = 10000
+  }: RiseWalletAdapterConfig = {}) {
+    super();
+
+    this._provider = typeof window !== 'undefined' ? window.rise : undefined;
+    // this._network = network;
+    this._timeout = timeout;
+    this._connecting = false;
+    this._wallet = null;
+
+    if (typeof window !== 'undefined' && this._readyState !== WalletReadyState.Unsupported) {
+      scopePollingDetectionStrategy(() => {
+        if (window.rise) {
+          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 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.rise;
+      const isConnected = await this._provider?.isConnected();
+      if (isConnected === true) {
+        await provider?.disconnect();
+      }
+
+      const response = await provider?.connect();
+
+      if (!response) {
+        throw new WalletNotConnectedError('User has rejected the request');
+      }
+
+      const account = await provider?.account();
+      if (account) {
+        const { publicKey, address, authKey } = account;
+
+        this._wallet = {
+          publicKey,
+          address,
+          authKey,
+          isConnected: true
+        };
+
+        this.emit('connect', this._wallet.publicKey);
+      }
+    } catch (error: any) {
+      this.emit('error', error);
+      throw error;
+    } finally {
+      this._connecting = false;
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    const wallet = this._wallet;
+    if (wallet) {
+      this._wallet = null;
+
+      try {
+        const provider = this._provider || window.rise;
+        await provider?.disconnect();
+      } catch (error: any) {
+        this.emit('error', new WalletDisconnectionError(error?.message, error));
+      }
+    }
+
+    this.emit('disconnect');
+  }
+
+  async signTransaction(transaction: TransactionPayload): Promise<Uint8Array> {
+    try {
+      const wallet = this._wallet;
+      const provider = this._provider || window.rise;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+
+      const response = await provider?.signTransaction(transaction);
+      if (response) {
+        return response;
+      } else {
+        throw new Error('Sign Transaction failed');
+      }
+    } catch (error: any) {
+      const errMsg = error.message;
+      this.emit('error', new WalletSignTransactionError(errMsg));
+      throw error;
+    }
+  }
+
+  async signAndSubmitTransaction(
+    transaction: TransactionPayload
+  ): Promise<{ hash: HexEncodedBytes }> {
+    try {
+      const wallet = this._wallet;
+      const provider = this._provider || window.rise;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+
+      const response = await provider?.signAndSubmitTransaction(transaction);
+      if (response) {
+        return response;
+      } else {
+        throw new Error('Transaction failed');
+      }
+    } catch (error: any) {
+      const errMsg = error.message;
+      this.emit('error', new WalletSignTransactionError(errMsg));
+      throw error;
+    }
+  }
+
+  async signMessage(msgPayload: SignMessagePayload): Promise<SignMessageResponse> {
+    try {
+      const wallet = this._wallet;
+      const provider = this._provider || window.rise;
+      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) {
+        return response;
+      } else {
+        throw new Error('Sign Message failed');
+      }
+    } catch (error: any) {
+      const errMsg = error.message;
+      this.emit('error', new WalletSignMessageError(errMsg));
+      throw error;
+    }
+  }
+}

package/src/WalletAdapters/index.ts

@@ -6,4 +6,8 @@ export * from './MartianWallet';
 export * from './FewchaWallet';
 export * from './PontemWallet';
 // export * from './NightlyWallet';
+export * from './RiseWallet';
 export * from './SpikaWallet';
+export * from './HyperPayWallet';
+export * from './FletchWallet';
+export * from './AptosSnap';

package/src/WalletProviders/WalletProvider.tsx

@@ -105,6 +105,7 @@ export const WalletProvider: FC<WalletProviderProps> = ({
   useEffect(() => {
     const selectedWallet = wallets.find((wAdapter) => wAdapter.adapter.name === name);
     if (selectedWallet) {
+      console.log('selectedWallets', selectedWallet);
       setState({
         wallet: selectedWallet,
         adapter: selectedWallet.adapter,
@@ -180,14 +181,20 @@ 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 ||
-      !adapter ||
-      !(readyState === WalletReadyState.Installed || readyState === WalletReadyState.Loadable)
-    )
+    if (isConnecting.current || connected || !autoConnect || !adapter) return;
+
+    // Handle wallet not installed in Auto-connect mode
+    if (!(readyState === WalletReadyState.Installed || readyState === WalletReadyState.Loadable)) {
+      // Clear the selected wallet
+      setName(null);
+
+      if (typeof window !== 'undefined') {
+        window.open(adapter.url, '_blank');
+      }
+
+      handleError(new WalletNotReadyError());
       return;
+    }
 
     (async function () {
       isConnecting.current = true;