@cartridge/controller 0.6.0 → 0.7.1

package/dist/{telegram/provider.js → node/index.js}

@@ -1,30 +1,11 @@
-// src/telegram/provider.ts
-import {
-  cloudStorage,
-  miniApp,
-  openLink,
-  retrieveLaunchParams
-} from "@telegram-apps/sdk";
-import { ec, stark } from "starknet";
+import { stark, ec, typedData, TypedDataRevision, hash, WalletAccount, addAddressPadding, CallData } from 'starknet';
+import { CartridgeSessionAccount } from '@cartridge/account-wasm/session';
+import { Permission } from '@starknet-io/types-js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as http from 'http';
 
-// src/constants.ts
-var KEYCHAIN_URL = "https://x.cartridge.gg";
-
-// src/session/account.ts
-import { CartridgeSessionAccount } from "@cartridge/account-wasm/session";
-import { WalletAccount } from "starknet";
-
-// src/utils.ts
-import {
-  addAddressPadding,
-  CallData,
-  constants,
-  getChecksumAddress,
-  hash,
-  shortString,
-  typedData,
-  TypedDataRevision
-} from "starknet";
+// src/node/provider.ts
 function normalizeCalls(calls) {
   return toArray(calls).map((call) => {
     return {
@@ -66,7 +47,25 @@ function toArray(val) {
   return Array.isArray(val) ? val : [val];
 }
 
-// src/session/account.ts
+// src/errors.ts
+var NotReadyToConnect = class _NotReadyToConnect extends Error {
+  constructor() {
+    super("Not ready to connect");
+    Object.setPrototypeOf(this, _NotReadyToConnect.prototype);
+  }
+};
+
+// src/types.ts
+var ResponseCodes = /* @__PURE__ */ ((ResponseCodes2) => {
+  ResponseCodes2["SUCCESS"] = "SUCCESS";
+  ResponseCodes2["NOT_CONNECTED"] = "NOT_CONNECTED";
+  ResponseCodes2["ERROR"] = "ERROR";
+  ResponseCodes2["CANCELED"] = "CANCELED";
+  ResponseCodes2["USER_INTERACTION_REQUIRED"] = "USER_INTERACTION_REQUIRED";
+  return ResponseCodes2;
+})(ResponseCodes || {});
+
+// src/node/account.ts
 var SessionAccount = class extends WalletAccount {
   controller;
   constructor(provider, {
@@ -80,7 +79,7 @@ var SessionAccount = class extends WalletAccount {
   }) {
     super({ nodeUrl: rpcUrl }, provider);
     this.address = address;
-    this.controller = CartridgeSessionAccount.new_as_registered(
+    this.controller = CartridgeSessionAccount.newAsRegistered(
       rpcUrl,
       privateKey,
       address,
@@ -100,30 +99,34 @@ var SessionAccount = class extends WalletAccount {
    * - entrypoint - the entrypoint of the contract
    * - calldata - (defaults to []) the calldata
    * - signature - (defaults to []) the signature
-   * @param abis (optional) the abi of the contract for better displaying
    *
    * @returns response from addTransaction
    */
   async execute(calls) {
-    return this.controller.execute(normalizeCalls(calls));
+    try {
+      const res = await this.controller.executeFromOutside(
+        normalizeCalls(calls)
+      );
+      return res;
+    } catch (e) {
+      return this.controller.execute(normalizeCalls(calls));
+    }
   }
 };
 
-// src/provider.ts
-import {
-  Permission
-} from "@starknet-io/types-js";
+// src/constants.ts
+var KEYCHAIN_URL = "https://x.cartridge.gg";
 
 // package.json
 var package_default = {
   name: "@cartridge/controller",
-  version: "0.6.0",
+  version: "0.7.1",
   description: "Cartridge Controller",
   module: "dist/index.js",
   types: "dist/index.d.ts",
   type: "module",
   scripts: {
-    "build:deps": "tsup --dts-resolve",
+    "build:deps": "tsup",
     build: "pnpm build:deps",
     format: 'prettier --write "src/**/*.ts"',
     "format:check": 'prettier --check "src/**/*.ts"',
@@ -133,52 +136,71 @@ var package_default = {
   exports: {
     ".": {
       types: "./dist/index.d.ts",
-      default: "./dist/index.js"
+      import: "./dist/index.js",
+      require: "./dist/index.cjs"
     },
     "./session": {
       types: "./dist/session/index.d.ts",
-      default: "./dist/session/index.js"
+      import: "./dist/session/index.js",
+      require: "./dist/session/index.cjs"
+    },
+    "./session/node": {
+      types: "./dist/node/index.d.ts",
+      import: "./dist/node/index.js",
+      require: "./dist/node/index.cjs"
     },
     "./provider": {
       types: "./dist/provider/index.d.ts",
-      default: "./dist/provider/index.js"
+      import: "./dist/provider/index.js"
     },
     "./types": {
       types: "./dist/types/index.d.ts",
-      default: "./dist/types/index.js"
+      import: "./dist/types/index.js"
     }
   },
   tsup: {
     entry: [
-      "src/**"
+      "src/index.ts",
+      "src/controller.ts",
+      "src/lookup.ts",
+      "src/session/index.ts",
+      "src/node/index.ts"
     ],
     format: [
-      "esm"
+      "esm",
+      "cjs"
     ],
     splitting: false,
     sourcemap: true,
-    clean: true
+    clean: true,
+    dts: true,
+    treeshake: {
+      preset: "recommended"
+    },
+    exports: "named"
   },
   peerDependencies: {
-    starknet: "^6.21.0"
+    starknet: "catalog:",
+    open: "^10.1.0"
   },
   dependencies: {
     "@cartridge/account-wasm": "workspace:*",
-    "@cartridge/penpal": "^6.2.3",
-    "@starknet-io/types-js": "^0.7.7",
+    "@cartridge/penpal": "catalog:",
+    "@starknet-io/types-js": "catalog:",
     "@telegram-apps/sdk": "^2.4.0",
-    base64url: "^3.0.1",
+    base64url: "catalog:",
     "cbor-x": "^1.5.0",
-    "fast-deep-equal": "^3.1.3",
-    "query-string": "^7.1.1"
+    "fast-deep-equal": "catalog:"
   },
   devDependencies: {
     "@cartridge/tsconfig": "workspace:*",
     "@types/jest": "^29.5.14",
-    "@types/node": "^20.6.0",
+    "@types/node": "catalog:",
     jest: "^29.7.0",
+    prettier: "catalog:",
     "ts-jest": "^29.2.5",
-    typescript: "^5.4.5"
+    tsup: "catalog:",
+    typescript: "catalog:"
   }
 };
 
@@ -357,77 +379,311 @@ var BaseProvider = class {
     });
   }
 };
+var CallbackServer = class {
+  server;
+  resolveCallback;
+  rejectCallback;
+  timeoutId;
+  constructor() {
+    this.server = http.createServer(this.handleRequest.bind(this));
+    this.server.on("error", (error) => {
+      console.error("Server error:", error);
+      if (this.rejectCallback) {
+        this.rejectCallback(error);
+      }
+    });
+  }
+  cleanup() {
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId);
+    }
+    this.server.close();
+  }
+  handleRequest(req, res) {
+    if (!req.url?.startsWith("/callback")) {
+      res.writeHead(404);
+      res.end();
+      return;
+    }
+    const params = new URLSearchParams(req.url.split("?")[1]);
+    const session = params.get("startapp");
+    if (!session) {
+      console.warn("Received callback without session data");
+      res.writeHead(400);
+      res.end("Missing session data");
+      return;
+    }
+    if (this.resolveCallback) {
+      this.resolveCallback(session);
+    }
+    res.writeHead(200, { "Content-Type": "text/html" });
+    res.end(
+      "<html><body><script>window.close();</script>Session registered successfully. You can close this window.</body></html>"
+    );
+    this.cleanup();
+  }
+  async listen() {
+    return new Promise((resolve, reject) => {
+      this.server.listen(0, "localhost", () => {
+        const address = this.server.address();
+        const url = `http://localhost:${address.port}/callback`;
+        resolve(url);
+      });
+      this.server.on("error", reject);
+    });
+  }
+  async waitForCallback() {
+    return new Promise((resolve, reject) => {
+      this.resolveCallback = resolve;
+      this.rejectCallback = reject;
+      this.timeoutId = setTimeout(
+        () => {
+          console.warn("Callback timeout reached");
+          reject(new Error("Callback timeout after 5 minutes"));
+          this.cleanup();
+        },
+        5 * 60 * 1e3
+      );
+    });
+  }
+};
 
-// src/policies.ts
-function parsePolicies(policies) {
-  return {
-    verified: false,
-    contracts: policies.contracts ? Object.fromEntries(
-      Object.entries(policies.contracts).map(([address, contract]) => [
-        address,
-        {
-          ...contract,
-          methods: contract.methods.map((method) => ({
-            ...method,
-            authorized: true
-          }))
+// src/node/backend.ts
+var NodeBackend = class {
+  basePath;
+  sessionFile;
+  data = {};
+  callbackServer;
+  constructor(basePath) {
+    if (!basePath) {
+      throw new Error("basePath is required for NodeBackend");
+    }
+    this.basePath = basePath;
+    this.sessionFile = path.join(this.basePath, "session.json");
+  }
+  async ensureDirectoryExists() {
+    try {
+      await fs.access(this.basePath);
+    } catch {
+      try {
+        await fs.mkdir(this.basePath, { recursive: true });
+      } catch (error) {
+        throw new Error(
+          `Failed to create directory ${this.basePath}: ${error.message}`
+        );
+      }
+    }
+  }
+  async loadData() {
+    try {
+      const content = await fs.readFile(this.sessionFile, "utf-8");
+      const parsed = JSON.parse(content);
+      if (typeof parsed !== "object" || parsed === null) {
+        throw new Error("Invalid session data format");
+      }
+      this.data = parsed;
+    } catch (error) {
+      if (error instanceof Error) {
+        if (error.code !== "ENOENT") {
+          throw new Error(`Failed to load session data: ${error.message}`);
         }
-      ])
-    ) : void 0,
-    messages: policies.messages?.map((message) => ({
-      ...message,
-      authorized: true
-    }))
-  };
-}
+      }
+      this.data = {};
+    }
+  }
+  async saveData() {
+    try {
+      await this.ensureDirectoryExists();
+      await fs.writeFile(
+        this.sessionFile,
+        JSON.stringify(this.data, null, 2),
+        "utf-8"
+      );
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Failed to save session data: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+  async get(key) {
+    if (!key) {
+      throw new Error("Key is required");
+    }
+    await this.loadData();
+    return this.data[key] ? JSON.stringify(this.data[key]) : null;
+  }
+  async set(key, value) {
+    if (!key) {
+      throw new Error("Key is required");
+    }
+    if (!value) {
+      throw new Error("Value is required");
+    }
+    await this.loadData();
+    try {
+      this.data[key] = JSON.parse(value);
+      await this.saveData();
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Failed to set ${key}: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+  async delete(key) {
+    if (!key) {
+      throw new Error("Key is required");
+    }
+    await this.loadData();
+    delete this.data[key];
+    await this.saveData();
+  }
+  async getRedirectUri() {
+    try {
+      this.callbackServer = new CallbackServer();
+      return await this.callbackServer.listen();
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Failed to start callback server: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+  async waitForCallback() {
+    if (!this.callbackServer) {
+      throw new Error("Callback server not initialized");
+    }
+    return await this.callbackServer.waitForCallback();
+  }
+  openLink(url) {
+    if (!url) {
+      throw new Error("URL is required");
+    }
+    console.log(`
+	 Open url to authorize session: ${url}`);
+  }
+};
 
-// src/telegram/provider.ts
-var TelegramProvider = class extends BaseProvider {
-  _tmaUrl;
+// src/node/provider.ts
+var SessionProvider = class extends BaseProvider {
+  id = "controller_session";
+  name = "Controller Session";
   _chainId;
+  _rpcUrl;
   _username;
   _policies;
-  _rpcUrl;
+  _keychainUrl;
+  _backend;
   constructor({
     rpc,
     chainId,
     policies,
-    tmaUrl
+    basePath,
+    keychainUrl
   }) {
     super();
+    this._policies = {
+      verified: false,
+      contracts: policies.contracts ? Object.fromEntries(
+        Object.entries(policies.contracts).map(([address, contract]) => [
+          address,
+          {
+            ...contract,
+            methods: contract.methods.map((method) => ({
+              ...method,
+              authorized: true
+            }))
+          }
+        ])
+      ) : undefined,
+      messages: policies.messages?.map((message) => ({
+        ...message,
+        authorized: true
+      }))
+    };
     this._rpcUrl = rpc;
-    this._tmaUrl = tmaUrl;
     this._chainId = chainId;
-    this._policies = parsePolicies(policies);
-    if (typeof window !== "undefined") {
-      window.starknet_controller = this;
+    this._keychainUrl = keychainUrl || KEYCHAIN_URL;
+    this._backend = new NodeBackend(basePath);
+  }
+  async username() {
+    const sessionStr = await this._backend.get("session");
+    if (sessionStr) {
+      const session = JSON.parse(sessionStr);
+      return session.username;
     }
+    return undefined;
   }
   async probe() {
-    await this.tryRetrieveFromQueryOrStorage();
-    return;
+    if (this.account) {
+      return this.account;
+    }
+    const [sessionStr, signerStr] = await Promise.all([
+      this._backend.get("session"),
+      this._backend.get("signer")
+    ]);
+    if (!sessionStr || !signerStr) {
+      return undefined;
+    }
+    const session = JSON.parse(sessionStr);
+    const signer = JSON.parse(signerStr);
+    const expirationTime = parseInt(session.expiresAt) * 1e3;
+    if (Date.now() >= expirationTime) {
+      await this.disconnect();
+      return undefined;
+    }
+    this._username = session.username;
+    this.account = new SessionAccount(this, {
+      rpcUrl: this._rpcUrl,
+      privateKey: signer.privKey,
+      address: session.address,
+      ownerGuid: session.ownerGuid,
+      chainId: this._chainId,
+      expiresAt: parseInt(session.expiresAt),
+      policies: toWasmPolicies(this._policies)
+    });
+    return this.account;
   }
   async connect() {
-    await this.tryRetrieveFromQueryOrStorage();
     if (this.account) {
-      return;
+      return this.account;
+    }
+    const account = await this.probe();
+    if (account) {
+      return account;
     }
     const pk = stark.randomAddress();
     const publicKey = ec.starkCurve.getStarkKey(pk);
-    cloudStorage.setItem(
-      "sessionSigner",
+    await this._backend.set(
+      "signer",
       JSON.stringify({
         privKey: pk,
         pubKey: publicKey
       })
     );
-    const url = `${KEYCHAIN_URL}/session?public_key=${publicKey}&redirect_uri=${this._tmaUrl}&redirect_query_name=startapp&policies=${JSON.stringify(
-      this._policies
-    )}&rpc_url=${this._rpcUrl}`;
-    localStorage.setItem("lastUsedConnector", this.id);
-    openLink(url);
-    miniApp.close();
-    return;
+    const redirectUri = await this._backend.getRedirectUri();
+    const url = `${this._keychainUrl}/session?public_key=${encodeURIComponent(publicKey)}&redirect_uri=${encodeURIComponent(
+      redirectUri
+    )}&redirect_query_name=startapp&policies=${encodeURIComponent(
+      JSON.stringify(this._policies)
+    )}&rpc_url=${encodeURIComponent(this._rpcUrl)}`;
+    this._backend.openLink(url);
+    const sessionData = await this._backend.waitForCallback();
+    if (sessionData) {
+      const sessionRegistration = JSON.parse(atob(sessionData));
+      sessionRegistration.address = sessionRegistration.address.toLowerCase();
+      sessionRegistration.ownerGuid = sessionRegistration.ownerGuid.toLowerCase();
+      await this._backend.set("session", JSON.stringify(sessionRegistration));
+      return this.probe();
+    }
+    return undefined;
+  }
+  async disconnect() {
+    await this._backend.delete("signer");
+    await this._backend.delete("session");
+    this.account = undefined;
+    this._username = undefined;
   }
   switchStarknetChain(_chainId) {
     throw new Error("switchStarknetChain not implemented");
@@ -435,45 +691,8 @@ var TelegramProvider = class extends BaseProvider {
   addStarknetChain(_chain) {
     throw new Error("addStarknetChain not implemented");
   }
-  disconnect() {
-    cloudStorage.deleteItem("sessionSigner");
-    cloudStorage.deleteItem("session");
-    this.account = void 0;
-    this._username = void 0;
-    return Promise.resolve();
-  }
-  async tryRetrieveFromQueryOrStorage() {
-    const signer = JSON.parse(await cloudStorage.getItem("sessionSigner"));
-    let sessionRegistration = null;
-    const launchParams = retrieveLaunchParams();
-    const session = launchParams.startParam;
-    if (session) {
-      sessionRegistration = JSON.parse(atob(session));
-      cloudStorage.setItem("session", JSON.stringify(sessionRegistration));
-    }
-    if (!sessionRegistration) {
-      const session2 = await cloudStorage.getItem("session");
-      if (session2) {
-        sessionRegistration = JSON.parse(session2);
-      }
-    }
-    if (!sessionRegistration) {
-      return;
-    }
-    this._username = sessionRegistration.username;
-    this.account = new SessionAccount(this, {
-      rpcUrl: this._rpcUrl,
-      privateKey: signer.privKey,
-      address: sessionRegistration.address,
-      ownerGuid: sessionRegistration.ownerGuid,
-      chainId: this._chainId,
-      expiresAt: parseInt(sessionRegistration.expiresAt),
-      policies: toWasmPolicies(this._policies)
-    });
-    return this.account;
-  }
-};
-export {
-  TelegramProvider as default
 };
-//# sourceMappingURL=provider.js.map
+
+export { NotReadyToConnect, ResponseCodes, SessionProvider as default };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map