@cartridge/controller 0.6.0 → 0.7.1

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

@@ -1,18 +1,158 @@
-// src/provider.ts
-import {
-  Permission
-} from "@starknet-io/types-js";
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var starknet = require('starknet');
+var session = require('@cartridge/account-wasm/session');
+var typesJs = require('@starknet-io/types-js');
+var fs = require('fs/promises');
+var path = require('path');
+var http = require('http');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var http__namespace = /*#__PURE__*/_interopNamespace(http);
+
+// src/node/provider.ts
+function normalizeCalls(calls) {
+  return toArray(calls).map((call) => {
+    return {
+      entrypoint: call.entrypoint,
+      contractAddress: starknet.addAddressPadding(call.contractAddress),
+      calldata: starknet.CallData.toHex(call.calldata)
+    };
+  });
+}
+function toWasmPolicies(policies) {
+  return [
+    ...Object.entries(policies.contracts ?? {}).flatMap(
+      ([target, { methods }]) => toArray(methods).map((m) => ({
+        target,
+        method: m.entrypoint,
+        authorized: m.authorized
+      }))
+    ),
+    ...(policies.messages ?? []).map((p) => {
+      const domainHash = starknet.typedData.getStructHash(
+        p.types,
+        "StarknetDomain",
+        p.domain,
+        starknet.TypedDataRevision.ACTIVE
+      );
+      const typeHash = starknet.typedData.getTypeHash(
+        p.types,
+        p.primaryType,
+        starknet.TypedDataRevision.ACTIVE
+      );
+      return {
+        scope_hash: starknet.hash.computePoseidonHash(domainHash, typeHash),
+        authorized: p.authorized
+      };
+    })
+  ];
+}
+function toArray(val) {
+  return Array.isArray(val) ? val : [val];
+}
+
+// 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 starknet.WalletAccount {
+  controller;
+  constructor(provider, {
+    rpcUrl,
+    privateKey,
+    address,
+    ownerGuid,
+    chainId,
+    expiresAt,
+    policies
+  }) {
+    super({ nodeUrl: rpcUrl }, provider);
+    this.address = address;
+    this.controller = session.CartridgeSessionAccount.newAsRegistered(
+      rpcUrl,
+      privateKey,
+      address,
+      ownerGuid,
+      chainId,
+      {
+        expiresAt,
+        policies
+      }
+    );
+  }
+  /**
+   * Invoke execute function in account contract
+   *
+   * @param calls the invocation object or an array of them, containing:
+   * - contractAddress - the address of the contract
+   * - entrypoint - the entrypoint of the contract
+   * - calldata - (defaults to []) the calldata
+   * - signature - (defaults to []) the signature
+   *
+   * @returns response from addTransaction
+   */
+  async execute(calls) {
+    try {
+      const res = await this.controller.executeFromOutside(
+        normalizeCalls(calls)
+      );
+      return res;
+    } catch (e) {
+      return this.controller.execute(normalizeCalls(calls));
+    }
+  }
+};
+
+// 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"',
@@ -22,52 +162,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:"
   }
 };
 
@@ -128,7 +287,7 @@ var BaseProvider = class {
       case "wallet_getPermissions":
         await this.safeProbe();
         if (this.account) {
-          return [Permission.ACCOUNTS];
+          return [typesJs.Permission.ACCOUNTS];
         }
         return [];
       case "wallet_requestAccounts": {
@@ -246,7 +405,322 @@ var BaseProvider = class {
     });
   }
 };
-export {
-  BaseProvider as default
+var CallbackServer = class {
+  server;
+  resolveCallback;
+  rejectCallback;
+  timeoutId;
+  constructor() {
+    this.server = http__namespace.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
+      );
+    });
+  }
 };
-//# sourceMappingURL=provider.js.map
+
+// 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__namespace.join(this.basePath, "session.json");
+  }
+  async ensureDirectoryExists() {
+    try {
+      await fs__namespace.access(this.basePath);
+    } catch {
+      try {
+        await fs__namespace.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__namespace.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}`);
+        }
+      }
+      this.data = {};
+    }
+  }
+  async saveData() {
+    try {
+      await this.ensureDirectoryExists();
+      await fs__namespace.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/node/provider.ts
+var SessionProvider = class extends BaseProvider {
+  id = "controller_session";
+  name = "Controller Session";
+  _chainId;
+  _rpcUrl;
+  _username;
+  _policies;
+  _keychainUrl;
+  _backend;
+  constructor({
+    rpc,
+    chainId,
+    policies,
+    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._chainId = chainId;
+    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() {
+    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() {
+    if (this.account) {
+      return this.account;
+    }
+    const account = await this.probe();
+    if (account) {
+      return account;
+    }
+    const pk = starknet.stark.randomAddress();
+    const publicKey = starknet.ec.starkCurve.getStarkKey(pk);
+    await this._backend.set(
+      "signer",
+      JSON.stringify({
+        privKey: pk,
+        pubKey: publicKey
+      })
+    );
+    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");
+  }
+  addStarknetChain(_chain) {
+    throw new Error("addStarknetChain not implemented");
+  }
+};
+
+exports.NotReadyToConnect = NotReadyToConnect;
+exports.ResponseCodes = ResponseCodes;
+exports.default = SessionProvider;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map