@fourt/sdk 0.1.0

package/README.md

@@ -0,0 +1,86 @@
+# @fourt/sdk
+
+![npm](https://img.shields.io/npm/v/@fourt/sdk)
+
+The Fourt Software Development Kit (SDK) is a TypeScript library that allows you to interact with the Fourt.io services and use them in your projects.
+
+## Installation
+
+```sh
+pnpm add @fourt/sdk
+```
+
+```sh
+npm install @fourt/sdk
+```
+
+```sh
+yarn add @fourt/sdk
+```
+
+## Usage
+
+To initialize the SDK, you will need to pass your API key to the one of the **Signer** constructors. You will also be asked to provide additional options for authentication methods. As of now, the SDK only supports authentication through passkeys (see [Web Authentication](https://developer.mozilla.org/en-US/docs/Web/API/Web_Authentication_API)), and thus only `FourtWebSigner` is available.
+
+```ts
+import { FourtWebSigner } from '@fourt/sdk'
+
+const fourtWebSigner = new FourtWebSigner({
+  auth: {
+    webauthn: {
+      rpId: 'localhost',
+    },
+  },
+  configuration: {
+    apiKey: '<YOUR_API_KEY>',
+  },
+})
+```
+
+### Modules
+
+The SDK is divided into several modules, each one with a specific purpose:
+
+- `AuthModule`: A module that allows you to authenticate users with the Fourt.io services;
+- `UserModule`: A module that allows you to get information about the authenticated user;
+- `ViemModule`: A module that offers utilities to interact with the Ethereum ecosystem using [Viem](https://viem.sh/).
+
+Each module can be accessed through the `auth`, `user` and `viem` properties on the Signer instance, e.g.
+
+```ts
+await fourtWebSigner.auth.passkeys.signIn({
+  email,
+})
+
+// Will print a `User` object, as defined in `@fourt/sdk/types`.
+console.log(fourtWebSigner.user.info)
+
+// Use the Viem module to interact with the Ethereum ecosystem
+const localAccount = await fourtWebSigner.viem.toLocalAccount()
+
+// Sign a message with the local account
+const signature = await localAccount.signMessage({ message })
+console.log(signature)
+
+// Create a smart account instance
+import { createPublicClient, http } from 'viem'
+import { polygonAmoy } from 'viem/chains'
+
+// You will need to create a public client to interact with the Ethereum ecosystem
+const publicClient = createPublicClient({
+  chain: polygonAmoy,
+  transport: http('YOUR_RPC_URL'),
+})
+
+const smartAccount = await fourtWebSigner.viem.toSmartAccount({
+  owner: localAccount,
+  client,
+})
+
+// Take some action based on the smart account state
+if (smartAccount.isDeployed) {
+  console.log('Smart account is deployed')
+} else {
+  console.log('Smart account is not deployed. Airdropping tokens...')
+}
+```

package/dist/index.cjs

@@ -0,0 +1,625 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  FourtWebSigner: () => FourtWebSigner
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/signer/web.ts
+var import_webauthn_stamper = require("@turnkey/webauthn-stamper");
+
+// src/signer/index.ts
+var import_http = require("@turnkey/http");
+
+// src/errors/SDKError.ts
+var SDKError = class extends Error {
+  _props;
+  constructor(message, props) {
+    super(message);
+    this._props = props;
+  }
+  get message() {
+    return this._props.message;
+  }
+};
+
+// src/errors/UnauthorizedError.ts
+var UnauthorizedError = class _UnauthorizedError extends SDKError {
+  constructor(props) {
+    super(_UnauthorizedError.name, props);
+  }
+};
+
+// src/errors/NotFoundError.ts
+var NotFoundError = class _NotFoundError extends SDKError {
+  constructor(props) {
+    super(_NotFoundError.name, props);
+  }
+};
+
+// src/errors/GenericError.ts
+var GenericError = class _GenericError extends SDKError {
+  constructor(props) {
+    super(_GenericError.name, props);
+  }
+};
+
+// src/errors/UnauthenticatedError.ts
+var UnauthenticatedError = class _UnauthenticatedError extends SDKError {
+  constructor(props) {
+    super(_UnauthenticatedError.name, props);
+  }
+};
+
+// src/errors/BadRequestError.ts
+var BadRequestError = class _BadRequestError extends SDKError {
+  constructor(props) {
+    super(_BadRequestError.name, props);
+  }
+};
+
+// src/session/index.ts
+var import_zustand = require("zustand");
+var import_middleware = require("zustand/middleware");
+var SessionStore = class {
+  _store;
+  /**
+   * Initializes a new instance of the `SessionStore` class by creating a new `zustand`store with the initial state.
+   */
+  constructor() {
+    this._store = (0, import_zustand.createStore)()(
+      (0, import_middleware.persist)(this._getInitialState, {
+        name: "fourt.io-signer-session",
+        storage: (0, import_middleware.createJSONStorage)(() => localStorage)
+      })
+    );
+  }
+  /**
+   * Gets the token from the session state.
+   *
+   * @returns {string | undefined} the token.
+   */
+  get token() {
+    return this._store.getState().token;
+  }
+  /**
+   * Sets the token in the session state.
+   *
+   * @param {string} token the token to set.
+   */
+  set token(token) {
+    this._store.setState({ token });
+  }
+  /**
+   * Gets the user from the session state.
+   *
+   * @returns {User | undefined} the user.
+   */
+  get user() {
+    return this._store.getState().user;
+  }
+  /**
+   * Sets the user in the session state.
+   *
+   * @param {User} user the user to set.
+   */
+  set user(user) {
+    this._store.setState({ ...this._store.getState(), user });
+  }
+  /**
+   * Clears the user from the session state.
+   */
+  clearUser() {
+    this._store.setState({ ...this._store.getState(), user: void 0 });
+  }
+  /**
+   * Clears the token from the session state.
+   */
+  clearToken() {
+    this._store.setState({ ...this._store.getState(), token: void 0 });
+  }
+  /**
+   * Clears the token and user from the session state.
+   */
+  clearAll() {
+    this.clearToken();
+    this.clearUser();
+  }
+  _getInitialState() {
+    return {
+      user: void 0,
+      token: void 0
+    };
+  }
+};
+
+// src/types/Routes.ts
+var ROUTE_METHOD_MAP = {
+  "/v1/signup": "POST",
+  "/v1/lookup": "POST",
+  "/v1/signin": "POST",
+  "/v1/sign": "POST"
+};
+
+// src/signer/index.ts
+var import_jwt_decode = require("jwt-decode");
+var import_date_fns = require("date-fns");
+var SignerClient = class {
+  _turnkeyClient;
+  _configuration;
+  _sessionStore;
+  _user;
+  constructor({
+    stamper,
+    configuration: { apiUrl, ...requiredConfiguration }
+  }) {
+    this._turnkeyClient = new import_http.TurnkeyClient(
+      { baseUrl: "https://api.turnkey.com" },
+      stamper
+    );
+    this._configuration = {
+      ...requiredConfiguration,
+      apiUrl: apiUrl ?? "https://auth.dev.api.fourt.io"
+    };
+    this._sessionStore = new SessionStore();
+  }
+  get user() {
+    if (this._user) return this._user;
+    if (!this.sessionStore.token) {
+      this.sessionStore.clearAll();
+      return void 0;
+    }
+    const decodedToken = (0, import_jwt_decode.jwtDecode)(this.sessionStore.token);
+    if (decodedToken.exp && (0, import_date_fns.isPast)(new Date((0, import_date_fns.secondsToMilliseconds)(decodedToken.exp)))) {
+      this.sessionStore.clearAll();
+      return void 0;
+    }
+    if (this.sessionStore.user) this._user = this.sessionStore.user;
+    return this._user;
+  }
+  set user(value) {
+    this._user = value;
+  }
+  set stamper(stamper) {
+    this._turnkeyClient.stamper = stamper;
+  }
+  get stamper() {
+    return this._turnkeyClient.stamper;
+  }
+  get sessionStore() {
+    return this._sessionStore;
+  }
+  async signRawMessage(msg) {
+    if (!this._user) {
+      throw new UnauthorizedError({
+        message: "SignerClient must be authenticated to sign a message"
+      });
+    }
+    const stampedRequest = await this._turnkeyClient.stampSignRawPayload({
+      organizationId: this._user.subOrgId,
+      type: "ACTIVITY_TYPE_SIGN_RAW_PAYLOAD_V2",
+      timestampMs: Date.now().toString(),
+      parameters: {
+        encoding: "PAYLOAD_ENCODING_HEXADECIMAL",
+        hashFunction: "HASH_FUNCTION_NO_OP",
+        payload: msg,
+        signWith: this._user.walletAddress
+      }
+    });
+    const { signature } = await this.request("/v1/sign", {
+      stampedRequest
+    });
+    return signature;
+  }
+  async lookUpUser(email) {
+    try {
+      const { subOrgId } = await this.request("/v1/lookup", { email });
+      return subOrgId;
+    } catch (error) {
+      if (!(error instanceof SDKError)) throw error;
+      const sdkError = error;
+      switch (sdkError.constructor.name) {
+        case NotFoundError.name: {
+          return null;
+        }
+        default: {
+          throw sdkError;
+        }
+      }
+    }
+  }
+  async whoAmI(subOrgId) {
+    const orgId = subOrgId || this._user?.subOrgId;
+    if (!orgId) throw new BadRequestError({ message: "No orgId provided" });
+    const stampedRequest = await this._turnkeyClient.stampGetWhoami({
+      organizationId: orgId
+    });
+    const { user, token } = await this.request("/v1/signin", {
+      stampedRequest
+    });
+    const credentialId = (() => {
+      try {
+        return JSON.parse(stampedRequest?.stamp.stampHeaderValue).credentialId;
+      } catch (e) {
+        return void 0;
+      }
+    })();
+    this._user = {
+      ...user,
+      credentialId
+    };
+    this.sessionStore.user = this.user;
+    this.sessionStore.token = token;
+  }
+  async request(route, body) {
+    const url = new URL(`${route}`, this._configuration.apiUrl);
+    const token = this.sessionStore.token;
+    const headers = {
+      "Content-Type": "application/json",
+      "X-FOURT-KEY": this._configuration.apiKey
+    };
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    const response = await fetch(url, {
+      method: ROUTE_METHOD_MAP[route],
+      body: JSON.stringify(body),
+      headers,
+      credentials: "include"
+    });
+    const { data, error } = await response.json();
+    if (error) {
+      switch (error.kind) {
+        case "UnauthorizedError": {
+          this.user = void 0;
+          this.sessionStore.clearAll();
+          throw new UnauthorizedError({ message: error.message });
+        }
+        case "NotFoundError": {
+          throw new NotFoundError({ message: error.message });
+        }
+        case "BadRequestError": {
+          throw new BadRequestError({ message: error.message });
+        }
+        default: {
+          throw new GenericError({ message: error.message });
+        }
+      }
+    }
+    return { ...data };
+  }
+};
+
+// src/lib/base64.ts
+var import_buffer = require("buffer");
+var LibBase64 = class {
+  static fromBuffer(buffer) {
+    return import_buffer.Buffer.from(buffer).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+  }
+  static toBuffer(base64) {
+    return import_buffer.Buffer.from(base64, "base64");
+  }
+};
+
+// src/lib/bytes.ts
+var LibBytes = class {
+  static generateRandomBuffer = () => {
+    const arr = new Uint8Array(32);
+    crypto.getRandomValues(arr);
+    return arr.buffer;
+  };
+  static takeBytes = (bytes, params = {}) => {
+    const { offset, count } = params;
+    const start = (offset ? offset * 2 : 0) + 2;
+    const end = count ? start + count * 2 : void 0;
+    return `0x${bytes.slice(start, end)}`;
+  };
+};
+
+// src/signer/web.ts
+var import_http2 = require("@turnkey/http");
+var WebSignerClient = class extends SignerClient {
+  _stampers;
+  /**
+   * Initializes a new instance of the `WebSignerClient` class.
+   *
+   * @param {WebSignerClientConstructorParams} params params for the constructor
+   */
+  constructor({ configuration, webauthn }) {
+    const webauthnStamper = new import_webauthn_stamper.WebauthnStamper({ rpId: webauthn.rpId });
+    super({
+      stamper: webauthnStamper,
+      configuration
+    });
+    this._stampers = {
+      webauthn: webauthnStamper
+    };
+  }
+  /**
+   * Signs in a user with webauthn.
+   *
+   * @param {WebauthnSignInParams} params params for the sign in
+   */
+  async webauthnSignIn({ email }) {
+    const existingUserSubOrgId = await this.lookUpUser(email);
+    if (!existingUserSubOrgId) {
+      await this._createAccount({ method: "webauthn", email });
+    } else {
+      await this.whoAmI(existingUserSubOrgId);
+      if (!this.user || !this.user.credentialId) {
+        return;
+      }
+      this.stamper = this._stampers.webauthn;
+      this._stampers.webauthn.allowCredentials = [
+        {
+          id: LibBase64.toBuffer(this.user.credentialId),
+          type: "public-key",
+          transports: ["internal", "usb"]
+        }
+      ];
+    }
+  }
+  async _createAccount(params) {
+    const { challenge, attestation } = await this._webauthnGenerateAttestation(
+      params.email
+    );
+    const {
+      token,
+      user: { id, email, subOrgId, walletAddress, salt, smartAccountAddress }
+    } = await this.request("/v1/signup", {
+      passkey: {
+        challenge: LibBase64.fromBuffer(challenge),
+        attestation
+      },
+      email: params.email
+    });
+    this.user = {
+      id,
+      email,
+      subOrgId,
+      walletAddress,
+      salt,
+      smartAccountAddress,
+      credentialId: attestation.credentialId
+    };
+    this._sessionStore.token = token;
+  }
+  async _webauthnGenerateAttestation(email) {
+    const challenge = LibBytes.generateRandomBuffer();
+    const authenticatorUserId = LibBytes.generateRandomBuffer();
+    const attestation = await (0, import_http2.getWebAuthnAttestation)({
+      publicKey: {
+        authenticatorSelection: {
+          residentKey: "preferred",
+          requireResidentKey: false,
+          userVerification: "preferred"
+        },
+        challenge,
+        rp: {
+          id: window.location.hostname,
+          name: window.location.hostname
+        },
+        pubKeyCredParams: [
+          {
+            type: "public-key",
+            alg: -7
+          },
+          {
+            type: "public-key",
+            alg: -257
+          }
+        ],
+        user: {
+          id: authenticatorUserId,
+          name: email,
+          displayName: email
+        }
+      }
+    });
+    return { challenge, attestation, authenticatorUserId };
+  }
+};
+
+// src/third-party/viem.ts
+var import_viem = require("viem");
+var import_accounts = require("viem/accounts");
+var import_accounts2 = require("permissionless/accounts");
+var import_account_abstraction = require("viem/account-abstraction");
+var ViemModule = class {
+  constructor(_signerClient) {
+    this._signerClient = _signerClient;
+  }
+  async toLocalAccount() {
+    const user = this._signerClient.user;
+    if (!user) {
+      throw new UnauthenticatedError({ message: "Signer not authenticated" });
+    }
+    return (0, import_accounts.toAccount)({
+      address: user.walletAddress,
+      signMessage: (msg) => this.signMessage(msg.message),
+      signTypedData: (typedDataDefinition) => this.signTypedData(typedDataDefinition),
+      signTransaction: this.signTransaction
+    });
+  }
+  async toSmartAccount({
+    client,
+    owner
+  }) {
+    const user = this._signerClient.user;
+    if (!user) {
+      throw new UnauthenticatedError({ message: "Signer not authenticated" });
+    }
+    return (0, import_accounts2.toLightSmartAccount)({
+      client,
+      owner,
+      version: "2.0.0",
+      entryPoint: {
+        address: import_account_abstraction.entryPoint07Address,
+        version: "0.7"
+      },
+      address: user.smartAccountAddress,
+      index: (0, import_viem.hexToBigInt)(user.salt)
+    });
+  }
+  async signMessage(msg) {
+    const messageHash = (0, import_viem.hashMessage)(msg);
+    const result = await this._signerClient.signRawMessage(messageHash);
+    return result;
+  }
+  async signTypedData(params) {
+    const messageHash = (0, import_viem.hashTypedData)(params);
+    return this._signerClient.signRawMessage(messageHash);
+  }
+  async signTransaction(transaction, options) {
+    const serializeFn = options?.serializer ?? import_viem.serializeTransaction;
+    const serializedTx = serializeFn(transaction);
+    const signatureHex = await this._signerClient.signRawMessage(
+      (0, import_viem.keccak256)(serializedTx)
+    );
+    const signature = {
+      r: LibBytes.takeBytes(signatureHex, { count: 32 }),
+      s: LibBytes.takeBytes(signatureHex, { count: 32, offset: 32 }),
+      v: BigInt(LibBytes.takeBytes(signatureHex, { count: 1, offset: 64 }))
+    };
+    return serializeFn(transaction, signature);
+  }
+};
+
+// src/modules/auth/passkeys.ts
+var PasskeysModule = class {
+  constructor(_webSignerClient) {
+    this._webSignerClient = _webSignerClient;
+  }
+  /**
+   * Signs in a user using Passkeys.
+   *
+   * @param params {WebauthnSignInParams} params for the sign-in process.
+   * @returns {Promise<void>} promise that resolves to the result of the sign-in process.
+   */
+  async signIn(params) {
+    return this._webSignerClient.webauthnSignIn(params);
+  }
+};
+
+// src/modules/auth/index.ts
+var AuthModule = class {
+  /**
+   * Initializes a new instance of the `AuthModule` class.
+   *
+   * @param {WebSignerClient} _webSignerClient underlying WebSigner client instance.
+   */
+  constructor(_webSignerClient) {
+    this._webSignerClient = _webSignerClient;
+    this._passkeys = new PasskeysModule(this._webSignerClient);
+  }
+  _passkeys;
+  /**
+   * A module for interacting with the Passkeys authentication methods.
+   */
+  get passkeys() {
+    return this._passkeys;
+  }
+};
+
+// src/modules/user/index.ts
+var UserModule = class {
+  /**
+   * Initializes a new instance of the `UserModule` class.
+   *
+   * @param {WebSignerClient} _webSignerClient underlying WebSigner client instance.
+   */
+  constructor(_webSignerClient) {
+    this._webSignerClient = _webSignerClient;
+  }
+  /**
+   * Gets the user information.
+   *
+   * @returns {User | undefined} user information.
+   */
+  get info() {
+    return this._webSignerClient.user;
+  }
+};
+
+// src/index.ts
+var FourtWebSigner = class {
+  _webSignerClient;
+  _modules;
+  /**
+   * Initializes a new instance of the `FourtWebSigner` class.
+   * Sets up the underlying modules.
+   *
+   *
+   * @example
+   * ```ts
+   * const fourtWebSigner = new FourtWebSigner({
+   * auth: {
+   *   webauthn: {
+   *     rpId: 'localhost',
+   *     },
+   *   },
+   *   configuration: {
+   *     apiKey: '927d603c-6775-4210-8e13-8904ca985e78',
+   *   },
+   * })
+   * ```
+   *
+   * @param {FourtWebSignerConstructorParams} params the required parameters to initialize the client
+   */
+  constructor({
+    configuration,
+    auth: { webauthn }
+  }) {
+    this._webSignerClient = new WebSignerClient({
+      configuration,
+      webauthn
+    });
+    this._modules = {
+      viem: new ViemModule(this._webSignerClient),
+      auth: new AuthModule(this._webSignerClient),
+      user: new UserModule(this._webSignerClient)
+    };
+  }
+  /**
+   * A module for interacting with the Viem library.
+   */
+  get viem() {
+    return this._modules.viem;
+  }
+  /**
+   * A module for interacting with the authentication methods.
+   */
+  get auth() {
+    return this._modules.auth;
+  }
+  /**
+   * A module for interacting with the user methods.
+   */
+  get user() {
+    return this._modules.user;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FourtWebSigner
+});
+//# sourceMappingURL=index.cjs.map