Completely remove auth from sdk

packages/auth/package.json

@@ -38,7 +38,8 @@
     "format": "prettier --write 'src/**/*'",
     "lint": "eslint src/",
     "fix": "eslint src/ --fix",
-    "clean": "rm -rf dist/ && rm -rf node_modules/"
+    "clean": "rm -rf dist/ && rm -rf node_modules/",
+    "test": "mocha --config './test/evm/.mocharc.json' --timeout 30000 --parallel './test/evm/**/*.test.ts'"
   },
   "preconstruct": {
     "entrypoints": [
@@ -62,12 +63,16 @@
     "@microsoft/api-extractor": "^7.29.2",
     "@microsoft/tsdoc": "^0.14.1",
     "@preconstruct/cli": "^2.2.1",
+    "@swc-node/register": "^1.5.4",
     "@thirdweb-dev/sdk": "*",
+    "@types/chai": "^4.3.4",
     "@types/cookie": "^0.5.1",
     "@types/cookie-parser": "^1.4.3",
     "@types/express": "^4.17.13",
+    "@types/mocha": "^10.0.1",
     "@typescript-eslint/eslint-plugin": "^5.33.0",
     "@typescript-eslint/parser": "^5.33.0",
+    "chai": "^4.3.7",
     "eslint": "^8.21.0",
     "eslint-config-prettier": "^8.3.0",
     "eslint-plugin-import": "^2.26.0",
@@ -76,6 +81,7 @@
     "eslint-plugin-tsdoc": "^0.2.16",
     "ethers": "^5.7.2",
     "express": "^4.18.1",
+    "mocha": "^10.2.0",
     "next": "^12.2.0",
     "next-auth": "^4.10.3",
     "prettier": "^2.7.1",
@@ -103,6 +109,8 @@
   },
   "dependencies": {
     "cookie": "^0.5.0",
-    "cookie-parser": "^1.4.6"
+    "cookie-parser": "^1.4.6",
+    "uuid": "^9.0.0",
+    "zod": "^3.20.2"
   }
 }

packages/auth/src/evm/core/auth.ts

@@ -15,64 +15,21 @@ import { WalletSigner } from "./signer";
 import { isBrowser } from "./utils";
 import { MinimalWallet } from "@thirdweb-dev/wallets";
 
-/**
- * Wallet Authenticator
- * @remarks The wallet authenticator enables server-side applications to securely identify the
- * connected wallet address of users on the client-side, and also enables users to authenticate
- * to any backend using just their wallet. It implements the JSON Web Token (JWT) authentication
- * standard.
- *
- * @example
- * ```javascript
- * // We specify the domain of the application to authenticate to
- * const domain = "example.com"
- *
- * // On the client side, we can generate a payload for the connected wallet to login
- * const loginPayload = await sdk.auth.login(domain);
- *
- * // Then on the server side, we can securely verify the connected client-side address
- * const address = sdk.auth.verify(domain, loginPayload);
- *
- * // And we can also generate an authentication token to send to the client
- * const token = sdk.auth.generate(domain, loginPayload);
- *
- * // Finally, the token can be send from the client to the server to make authenticated requests
- * // And the server can use the following function to authenticate a token and verify the associated address
- * const address = sdk.auth.authenticate(domain, token);
- * ```
- * @public
- */
-export class ThirdwebAuth {
-  private wallet: WalletSigner;
-
-  constructor(wallet: MinimalWallet) {
-    this.wallet = new WalletSigner(wallet);
+export class ThirdwebAuth extends WalletSigner {
+  private domain: string;
+
+  constructor(wallet: MinimalWallet, domain: string) {
+    super(wallet);
+    this.domain = domain;
   }
 
-  /**
-   * Login With Connected Wallet
-   * @remarks Client-side function that allows the connected wallet to login to a server-side application.
-   * Generates a login payload that can be sent to the server-side for verification or authentication.
-   *
-   * @param domain - The domain of the server-side application to login to
-   * @param options - Optional configuration options for the login request
-   * @returns Login payload that can be used on the server-side to verify the login request or authenticate
-   *
-   * @example
-   * ```javascript
-   * // Add the domain of the application users will login to, this will be used throughout the login process
-   * const domain = "example.com";
-   * // Generate a signed login payload for the connected wallet to authenticate with
-   * const loginPayload = await sdk.auth.login(domain);
-   * ```
-   */
   public async login(
     domain: string,
     options?: LoginOptions,
   ): Promise<LoginPayload> {
     const parsedOptions = LoginOptionsSchema.parse(options);
 
-    const signerAddress = await this.wallet.getAddress();
+    const signerAddress = await this.getAddress();
     const expirationTime =
       parsedOptions?.expirationTime || new Date(Date.now() + 1000 * 60 * 5);
     const payloadData = LoginPayloadDataSchema.parse({
@@ -84,32 +41,14 @@ export class ThirdwebAuth {
     });
 
     const message = this.generateMessage(payloadData);
-    const signature = await this.wallet.sign(message);
+    const signature = await this.sign(message);
 
     return {
       payload: payloadData,
       signature,
     };
   }
 
-  /**
-   * Verify Logged In Address
-   * @remarks Server-side function to securely verify the address of the logged in client-side wallet
-   * by validating the provided client-side login request.
-   *
-   * @param domain - The domain of the server-side application to verify the login request for
-   * @param payload - The login payload to verify
-   * @returns Address of the logged in wallet
-   *
-   * @example
-   * ```javascript
-   * const domain = "example.com";
-   * const loginPayload = await sdk.auth.login(domain);
-   *
-   * // Verify the login request
-   * const address = sdk.auth.verify(domain, loginPayload);
-   * ```
-   */
   public verify(
     domain: string,
     payload: LoginPayload,
@@ -142,7 +81,7 @@ export class ThirdwebAuth {
 
     // Check that the signing address is the claimed wallet address
     const message = this.generateMessage(payload.payload);
-    const userAddress = this.wallet.recoverAddress(message, payload.signature);
+    const userAddress = this.recoverAddress(message, payload.signature);
     if (userAddress.toLowerCase() !== payload.payload.address.toLowerCase()) {
       throw new Error(
         `Signer address '${userAddress.toLowerCase()}' does not match payload address '${payload.payload.address.toLowerCase()}'`,
@@ -152,25 +91,6 @@ export class ThirdwebAuth {
     return userAddress;
   }
 
-  /**
-   * Generate Authentication Token
-   * @remarks Server-side function that generates a JWT token from the provided login request that the
-   * client-side wallet can use to authenticate to the server-side application.
-   *
-   * @param domain - The domain of the server-side application to authenticate to
-   * @param payload - The login payload to authenticate with
-   * @param options - Optional configuration options for the authentication request
-   * @returns A authentication token that can be used by the client to make authenticated requests
-   *
-   * @example
-   * ```javascript
-   * const domain = "example.com";
-   * const loginPayload = await sdk.auth.login(domain);
-   *
-   * // Generate a JWT token that can be sent to the client-side wallet and used for authentication
-   * const token = await sdk.auth.generateAuthToken(domain, loginPayload);
-   * ```
-   */
   public async generateAuthToken(
     domain: string,
     payload: LoginPayload,
@@ -185,7 +105,7 @@ export class ThirdwebAuth {
     const parsedOptions = AuthenticationOptionsSchema.parse(options);
 
     const userAddress = this.verify(domain, payload);
-    const adminAddress = await this.wallet.getAddress();
+    const adminAddress = await this.getAddress();
     const payloadData = AuthenticationPayloadDataSchema.parse({
       iss: adminAddress,
       sub: userAddress,
@@ -198,7 +118,7 @@ export class ThirdwebAuth {
     });
 
     const message = JSON.stringify(payloadData);
-    const signature = await this.wallet.sign(message);
+    const signature = await this.sign(message);
 
     // Header used for JWT token specifying hash algorithm
     const header = {
@@ -277,15 +197,15 @@ export class ThirdwebAuth {
     }
 
     // Check that the connected wallet matches the token issuer
-    const connectedAddress = await this.wallet.getAddress();
+    const connectedAddress = await this.getAddress();
     if (connectedAddress.toLowerCase() !== payload.iss.toLowerCase()) {
       throw new Error(
         `Expected the connected wallet address '${connectedAddress}' to match the token issuer address '${payload.iss}'`,
       );
     }
 
     // Check that the connected wallet signed the token
-    const adminAddress = this.wallet.recoverAddress(
+    const adminAddress = this.recoverAddress(
       JSON.stringify(payload),
       signature,
     );

packages/auth/src/evm/core/index.ts

@@ -1 +1 @@
-export { WalletAuthenticator } from "./auth";
+export { ThirdwebAuth } from "./auth";

packages/auth/src/evm/core/signer.ts

@@ -25,14 +25,25 @@ export class WalletSigner {
     return ethers.utils.recoverAddress(messageHashBytes, signature);
   }
 
+  public updateWallet(wallet: MinimalWallet): void {
+    this.wallet = wallet;
+    this.signer = undefined;
+  }
+
   // Signer should only be accessed with this function
-  async getSigner(): Promise<ethers.Signer> {
+  private async getSigner(): Promise<ethers.Signer> {
     // First check for the cached signer
-    if (this.signer) {
+    if (!!this.signer) {
       return this.signer;
     }
 
     // Otherwise newly instantiate it and return
-    return (this.signer = await this.wallet.getSigner());
+    this.signer = await this.wallet.getSigner();
+
+    if (!this.signer) {
+      throw new Error("Unable to get a signer!");
+    }
+
+    return this.signer;
   }
 }

packages/auth/test/evm/.mocharc.json

@@ -0,0 +1,8 @@
+{
+  "extension": [
+    "ts"
+  ],
+  "require": [
+    "@swc-node/register"
+  ]
+}