refactor: replace WASM dependency in SessionProvider with pure TypeScript

examples/capacitor/capacitor.config.ts

@@ -4,6 +4,11 @@ const config: CapacitorConfig = {
   appId: "gg.cartridge.controller.capacitor",
   appName: "Cartridge Session",
   webDir: "dist",
+  plugins: {
+    CapacitorHttp: {
+      enabled: true,
+    },
+  },
   server: {
     hostname: "controller-capacitor", // Recommended: Set a custom hostname for production
     androidScheme: "https",

examples/capacitor/ios/App/Podfile.lock

@@ -24,9 +24,9 @@ EXTERNAL SOURCES:
     :path: "../../../../node_modules/.pnpm/@capacitor+ios@6.2.1_@capacitor+core@6.2.1/node_modules/@capacitor/ios"
 
 SPEC CHECKSUMS:
-  Capacitor: c95400d761e376be9da6be5a05f226c0e865cebf
-  CapacitorApp: a19ccb4f5f32d2534be5c6f524d5a9b614a1e8a7
-  CapacitorBrowser: 825163a1d6adce944ac7b9e3cab101146b5a9df8
+  Capacitor: 1e0d0e7330dea9f983b50da737d8918abcf273f8
+  CapacitorApp: 22c94146dfaae1159ab7059cbd51e76d9f2d45ec
+  CapacitorBrowser: 9e9a268445f9472b04b68320930c59bdc4d360fa
   CapacitorCordova: 8d93e14982f440181be7304aa9559ca631d77fff
 
 PODFILE CHECKSUM: f6877332d3ea075bd6f7d8f89d3ecbc9a0bb06a3

packages/controller/package.json

@@ -36,7 +36,6 @@
     }
   },
   "dependencies": {
-    "@cartridge/controller-wasm": "catalog:",
     "@cartridge/penpal": "catalog:",
     "micro-sol-signer": "^0.5.0",
     "bs58": "^6.0.0",

packages/controller/src/__tests__/account.test.ts

@@ -0,0 +1,186 @@
+import { hash } from "starknet";
+import { CartridgeSessionAccount } from "../session/internal/account";
+import { isSnip9CompatibilityError } from "../session/internal/errors";
+import type { CallPolicy, Session } from "../session/internal/types";
+import { normalizeFelt } from "../session/internal/utils";
+
+// Mock global fetch
+const mockFetch = jest.fn();
+(global as any).fetch = mockFetch;
+
+beforeEach(() => {
+  mockFetch.mockReset();
+});
+
+const TRANSFER_SELECTOR = normalizeFelt(hash.getSelectorFromName("transfer"));
+const TEST_RPC = "https://rpc.test";
+const TEST_PRIVATE_KEY = "0x1";
+const TEST_ADDRESS = "0x1234";
+const TEST_OWNER_GUID = "0x5678";
+const TEST_CHAIN_ID = "SN_SEPOLIA";
+const STRK_CONTRACT_ADDRESS =
+  "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7";
+
+const TEST_POLICIES: CallPolicy[] = [
+  {
+    target: STRK_CONTRACT_ADDRESS,
+    method: TRANSFER_SELECTOR,
+    authorized: true,
+  },
+];
+
+const TEST_SESSION: Session = {
+  policies: TEST_POLICIES,
+  expiresAt: 9999999999,
+  metadataHash: "0x0",
+  sessionKeyGuid: "0x0",
+  guardianKeyGuid: "0x0",
+};
+
+describe("CartridgeSessionAccount", () => {
+  test("executeFromOutside sends correct RPC request", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({
+        jsonrpc: "2.0",
+        id: 1,
+        result: { transaction_hash: "0xtxhash" },
+      }),
+    });
+
+    const account = CartridgeSessionAccount.newAsRegistered(
+      TEST_RPC,
+      TEST_PRIVATE_KEY,
+      TEST_ADDRESS,
+      TEST_OWNER_GUID,
+      TEST_CHAIN_ID,
+      TEST_SESSION,
+    );
+
+    const result = await account.executeFromOutside([
+      {
+        contractAddress: STRK_CONTRACT_ADDRESS,
+        entrypoint: "transfer",
+        calldata: ["0x1", "0x2", "0x0"],
+      },
+    ]);
+
+    expect(result.transaction_hash).toBe("0xtxhash");
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+
+    const [url, options] = mockFetch.mock.calls[0];
+    expect(url).toBe(TEST_RPC);
+    const body = JSON.parse(options.body);
+    expect(body.method).toBe("cartridge_addExecuteOutsideTransaction");
+    expect(body.params.address).toBe(TEST_ADDRESS);
+    expect(body.params.outside_execution).toBeDefined();
+    expect(body.params.signature).toBeDefined();
+    expect(Array.isArray(body.params.signature)).toBe(true);
+  });
+
+  test("executeFromOutside throws on RPC error", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({
+        jsonrpc: "2.0",
+        id: 1,
+        error: { code: -32000, message: "execution failed" },
+      }),
+    });
+
+    const account = CartridgeSessionAccount.newAsRegistered(
+      TEST_RPC,
+      TEST_PRIVATE_KEY,
+      TEST_ADDRESS,
+      TEST_OWNER_GUID,
+      TEST_CHAIN_ID,
+      TEST_SESSION,
+    );
+
+    await expect(
+      account.executeFromOutside([
+        {
+          contractAddress: STRK_CONTRACT_ADDRESS,
+          entrypoint: "transfer",
+          calldata: [],
+        },
+      ]),
+    ).rejects.toThrow("execution failed");
+  });
+
+  test("internal CartridgeSessionAccount only exposes executeFromOutside, not execute", () => {
+    const account = CartridgeSessionAccount.newAsRegistered(
+      TEST_RPC,
+      TEST_PRIVATE_KEY,
+      TEST_ADDRESS,
+      TEST_OWNER_GUID,
+      TEST_CHAIN_ID,
+      TEST_SESSION,
+    );
+    expect((account as any).execute).toBeUndefined();
+    expect(account.executeFromOutside).toBeDefined();
+  });
+
+  test("executeFromOutside propagates non-SNIP-9 errors without swallowing", async () => {
+    const networkError = new Error("network timeout");
+    mockFetch.mockRejectedValueOnce(networkError);
+
+    const account = CartridgeSessionAccount.newAsRegistered(
+      TEST_RPC,
+      TEST_PRIVATE_KEY,
+      TEST_ADDRESS,
+      TEST_OWNER_GUID,
+      TEST_CHAIN_ID,
+      TEST_SESSION,
+    );
+
+    await expect(
+      account.executeFromOutside([
+        {
+          contractAddress: STRK_CONTRACT_ADDRESS,
+          entrypoint: "transfer",
+          calldata: [],
+        },
+      ]),
+    ).rejects.toThrow("network timeout");
+  });
+
+  describe("isSnip9CompatibilityError", () => {
+    test("returns true for OUTSIDE_EXECUTION_NOT_SUPPORTED code", () => {
+      const err = Object.assign(new Error("failed"), {
+        code: "OUTSIDE_EXECUTION_NOT_SUPPORTED",
+      });
+      expect(isSnip9CompatibilityError(err)).toBe(true);
+    });
+
+    test("returns true for snip-9 message patterns", () => {
+      expect(
+        isSnip9CompatibilityError(
+          new Error("account is not compatible with snip-9"),
+        ),
+      ).toBe(true);
+      expect(
+        isSnip9CompatibilityError(new Error("entrypoint does not exist")),
+      ).toBe(true);
+    });
+
+    test("returns false for generic errors", () => {
+      expect(isSnip9CompatibilityError(new Error("network timeout"))).toBe(
+        false,
+      );
+    });
+
+    test("returns false for null/undefined", () => {
+      expect(isSnip9CompatibilityError(null)).toBe(false);
+      expect(isSnip9CompatibilityError(undefined)).toBe(false);
+    });
+
+    test("checks nested cause for error code", () => {
+      const cause = Object.assign(new Error("inner"), {
+        code: "OUTSIDE_EXECUTION_UNSUPPORTED",
+      });
+      const err = Object.assign(new Error("outer"), { cause });
+      expect(isSnip9CompatibilityError(err)).toBe(true);
+    });
+  });
+});