@cartridge/controller 0.5.7 → 0.5.9

package/src/__tests__/parseChainId.test.ts

@@ -0,0 +1,60 @@
+import { constants, shortString } from "starknet";
+import { parseChainId } from "../utils";
+
+describe("parseChainId", () => {
+  describe("Starknet chains", () => {
+    test("identifies mainnet", () => {
+      expect(
+        parseChainId(new URL("https://api.cartridge.gg/x/starknet/mainnet")),
+      ).toBe(constants.StarknetChainId.SN_MAIN);
+    });
+
+    test("identifies sepolia", () => {
+      expect(
+        parseChainId(new URL("https://api.cartridge.gg/x/starknet/sepolia")),
+      ).toBe(constants.StarknetChainId.SN_SEPOLIA);
+    });
+  });
+
+  describe("Project-specific chains", () => {
+    test("identifies slot chain", () => {
+      expect(
+        parseChainId(new URL("https://api.cartridge.gg/x/slot/katana")),
+      ).toBe(shortString.encodeShortString("WP_SLOT"));
+    });
+
+    test("identifies slot chain on localhost", () => {
+      expect(parseChainId(new URL("http://localhost:8001/x/slot/katana"))).toBe(
+        shortString.encodeShortString("WP_SLOT"),
+      );
+    });
+
+    test("identifies slot chain with hyphenated name", () => {
+      expect(
+        parseChainId(
+          new URL("https://api.cartridge.gg/x/my-slot-chain/katana"),
+        ),
+      ).toBe(shortString.encodeShortString("WP_MY_SLOT_CHAIN"));
+    });
+
+    test("identifies slot mainnet chain", () => {
+      expect(
+        parseChainId(new URL("https://api.cartridge.gg/x/slot/mainnet")),
+      ).toBe(shortString.encodeShortString("GG_SLOT"));
+    });
+  });
+
+  describe("Error cases", () => {
+    test("throws error for unsupported URL format", () => {
+      expect(() =>
+        parseChainId(new URL("https://api.example.com/unsupported")),
+      ).toThrow("Chain https://api.example.com/unsupported not supported");
+    });
+
+    test("throws error for URLs without proper chain identifiers", () => {
+      expect(() =>
+        parseChainId(new URL("https://api.example.com/v1/starknet")),
+      ).toThrow("Chain https://api.example.com/v1/starknet not supported");
+    });
+  });
+});

package/src/account.ts

@@ -27,12 +27,13 @@ class ControllerAccount extends WalletAccount {
 
   constructor(
     provider: BaseProvider,
+    rpcUrl: string,
     address: string,
     keychain: AsyncMethodReturns<Keychain>,
     options: KeychainOptions,
     modal: Modal,
   ) {
-    super({ nodeUrl: provider.rpc.toString() }, provider);
+    super({ nodeUrl: rpcUrl }, provider);
 
     this.address = address;
     this.keychain = keychain;

package/src/controller.ts

@@ -13,20 +13,52 @@ import {
   Profile,
   IFrames,
   ProfileContextTypeVariant,
+  Chain,
 } from "./types";
 import BaseProvider from "./provider";
 import { WalletAccount } from "starknet";
 import { Policy } from "@cartridge/presets";
+import { AddStarknetChainParameters, ChainId } from "@starknet-io/types-js";
+import { parseChainId } from "./utils";
 
 export default class ControllerProvider extends BaseProvider {
   private keychain?: AsyncMethodReturns<Keychain>;
   private profile?: AsyncMethodReturns<Profile>;
   private options: ControllerOptions;
   private iframes: IFrames;
+  private selectedChain: ChainId;
+  private chains: Map<ChainId, Chain>;
 
   constructor(options: ControllerOptions) {
-    const { rpc } = options;
-    super({ rpc });
+    super();
+
+    const chains = new Map<ChainId, Chain>();
+
+    for (const chain of options.chains) {
+      const url = new URL(chain.rpcUrl);
+      const chainId = parseChainId(url);
+      chains.set(chainId, chain);
+    }
+
+    if (
+      options.policies?.messages?.length &&
+      options.policies.messages.length !== chains.size
+    ) {
+      console.warn(
+        "Each message policy is associated with a specific chain. " +
+          "The number of message policies does not match the number of chains specified - " +
+          "session message signing may not work on some chains.",
+      );
+    }
+
+    this.chains = chains;
+    this.selectedChain = options.defaultChainId;
+
+    if (!this.chains.has(this.selectedChain)) {
+      throw new Error(
+        `Chain ${this.selectedChain} not found in configured chains`,
+      );
+    }
 
     this.iframes = {
       keychain: new KeychainIFrame({
@@ -54,12 +86,11 @@ export default class ControllerProvider extends BaseProvider {
         return;
       }
 
-      const response = (await this.keychain.probe(
-        this.rpc.toString(),
-      )) as ProbeReply;
+      const response = (await this.keychain.probe(this.rpcUrl())) as ProbeReply;
 
       this.account = new ControllerAccount(
         this,
+        this.rpcUrl(),
         response.address,
         this.keychain,
         this.options,
@@ -83,7 +114,7 @@ export default class ControllerProvider extends BaseProvider {
           openPurchaseCredits: () => this.openPurchaseCredits.bind(this),
           openExecute: () => this.openExecute.bind(this),
         },
-        rpcUrl: this.rpc.toString(),
+        rpcUrl: this.rpcUrl(),
         username,
         version: this.version,
       });
@@ -113,8 +144,8 @@ export default class ControllerProvider extends BaseProvider {
 
     try {
       let response = await this.keychain.connect(
-        this.options.policies || [],
-        this.rpc.toString(),
+        this.options.policies || {},
+        this.rpcUrl(),
       );
       if (response.code !== ResponseCodes.SUCCESS) {
         throw new Error(response.message);
@@ -123,6 +154,7 @@ export default class ControllerProvider extends BaseProvider {
       response = response as ConnectReply;
       this.account = new ControllerAccount(
         this,
+        this.rpcUrl(),
         response.address,
         this.keychain,
         this.options,
@@ -137,6 +169,26 @@ export default class ControllerProvider extends BaseProvider {
     }
   }
 
+  async switchStarknetChain(chainId: string): Promise<boolean> {
+    try {
+      this.selectedChain = chainId;
+      this.account = await this.probe();
+      if (!this.account) {
+        this.account = await this.connect();
+      }
+    } catch (e) {
+      console.error(e);
+      return false;
+    }
+
+    this.emitNetworkChanged(chainId);
+    return true;
+  }
+
+  addStarknetChain(_chain: AddStarknetChainParameters): Promise<boolean> {
+    return Promise.resolve(true);
+  }
+
   async disconnect() {
     if (!this.keychain) {
       console.error(new NotReadyToConnect().message);
@@ -197,6 +249,10 @@ export default class ControllerProvider extends BaseProvider {
     return this.keychain.revoke(origin);
   }
 
+  rpcUrl(): string {
+    return this.chains.get(this.selectedChain)!.rpcUrl;
+  }
+
   username() {
     if (!this.keychain) {
       console.error(new NotReadyToConnect().message);
@@ -230,7 +286,7 @@ export default class ControllerProvider extends BaseProvider {
     this.keychain.openPurchaseCredits();
   }
 
-  async openExecute(calls: any) {
+  async openExecute(calls: any, chainId?: string) {
     if (!this.keychain || !this.iframes.keychain) {
       console.error(new NotReadyToConnect().message);
       return;
@@ -239,16 +295,30 @@ export default class ControllerProvider extends BaseProvider {
       console.error("Profile is not ready");
       return;
     }
-    if (this.iframes.profile?.sendBackward) {
-      this.iframes.profile?.sendBackward();
-    } else {
-      this.iframes.profile?.close();
+    // Switch to the chain if provided
+    let currentChainId = this.selectedChain;
+    if (chainId) {
+      this.switchStarknetChain(chainId);
     }
+    // Switch iframes
+    this.iframes.profile?.sendBackward();
     this.iframes.keychain.open();
+    this.iframes.profile?.close();
+    // Invoke execute
     const res = await this.keychain.execute(calls, undefined, undefined, true);
+    // Switch back iframes
+    this.iframes.profile?.open();
     this.iframes.keychain.close();
-    this.iframes.profile?.sendForward?.();
-    return !(res && (res as ConnectError).code === ResponseCodes.NOT_CONNECTED);
+    this.iframes.profile?.sendForward();
+    // Switch back to the original chain
+    if (chainId) {
+      this.switchStarknetChain(currentChainId);
+    }
+    return !(
+      res &&
+      ((res as ConnectError).code === ResponseCodes.NOT_CONNECTED ||
+        (res as ConnectError).code === ResponseCodes.CANCELED)
+    );
   }
 
   async delegateAccount() {

package/src/provider.ts

@@ -1,10 +1,13 @@
 import { WalletAccount } from "starknet";
 import {
   AddInvokeTransactionParameters,
+  AddStarknetChainParameters,
   Errors,
   Permission,
+  RequestAccountsParameters,
   RequestFn,
   StarknetWindowObject,
+  SwitchStarknetChainParameters,
   TypedData,
   WalletEventHandlers,
   WalletEventListener,
@@ -13,7 +16,6 @@ import {
 import manifest from "../package.json";
 
 import { icon } from "./icon";
-import { ProviderOptions } from "./types";
 
 export default abstract class BaseProvider implements StarknetWindowObject {
   public id = "controller";
@@ -21,16 +23,9 @@ export default abstract class BaseProvider implements StarknetWindowObject {
   public version = manifest.version;
   public icon = icon;
 
-  public rpc: URL;
   public account?: WalletAccount;
   public subscriptions: WalletEvents[] = [];
 
-  constructor(options: ProviderOptions) {
-    const { rpc } = options;
-
-    this.rpc = new URL(rpc);
-  }
-
   request: RequestFn = async (call) => {
     switch (call.type) {
       case "wallet_getPermissions":
@@ -47,8 +42,11 @@ export default abstract class BaseProvider implements StarknetWindowObject {
           return [this.account.address];
         }
 
+        const silentMode =
+          call.params && (call.params as RequestAccountsParameters).silent_mode;
+
         this.account = await this.probe();
-        if (!this.account) {
+        if (!this.account && !silentMode) {
           this.account = await this.connect();
         }
 
@@ -66,26 +64,22 @@ export default abstract class BaseProvider implements StarknetWindowObject {
           data: "wallet_watchAsset not implemented",
         } as Errors.UNEXPECTED_ERROR;
 
-      case "wallet_addStarknetChain":
-        throw {
-          code: 63,
-          message: "An unexpected error occurred",
-          data: "wallet_addStarknetChain not implemented",
-        } as Errors.UNEXPECTED_ERROR;
+      case "wallet_addStarknetChain": {
+        let params = call.params as AddStarknetChainParameters;
+        return this.addStarknetChain(params);
+      }
 
-      case "wallet_switchStarknetChain":
-        throw {
-          code: 63,
-          message: "An unexpected error occurred",
-          data: "wallet_switchStarknetChain not implemented",
-        } as Errors.UNEXPECTED_ERROR;
+      case "wallet_switchStarknetChain": {
+        let params = call.params as SwitchStarknetChainParameters;
+        return this.switchStarknetChain(params.chainId);
+      }
 
       case "wallet_requestChainId":
         if (!this.account) {
           throw {
             code: 63,
             message: "An unexpected error occurred",
-            data: "wallet_deploymentData not implemented",
+            data: "Account not initialized",
           } as Errors.UNEXPECTED_ERROR;
         }
 
@@ -103,7 +97,7 @@ export default abstract class BaseProvider implements StarknetWindowObject {
           throw {
             code: 63,
             message: "An unexpected error occurred",
-            data: "wallet_deploymentData not implemented",
+            data: "Account not initialized",
           } as Errors.UNEXPECTED_ERROR;
         }
 
@@ -173,6 +167,26 @@ export default abstract class BaseProvider implements StarknetWindowObject {
     }
   };
 
+  protected emitNetworkChanged(chainId: string) {
+    this.subscriptions
+      .filter((sub) => sub.type === "networkChanged")
+      .forEach((sub) => {
+        (sub.handler as WalletEventHandlers["networkChanged"])(chainId);
+      });
+  }
+
+  protected emitAccountsChanged(accounts: string[]) {
+    this.subscriptions
+      .filter((sub) => sub.type === "accountsChanged")
+      .forEach((sub) => {
+        (sub.handler as WalletEventHandlers["accountsChanged"])(accounts);
+      });
+  }
+
   abstract probe(): Promise<WalletAccount | undefined>;
   abstract connect(): Promise<WalletAccount | undefined>;
+  abstract switchStarknetChain(chainId: string): Promise<boolean>;
+  abstract addStarknetChain(
+    chain: AddStarknetChainParameters,
+  ): Promise<boolean>;
 }

package/src/session/provider.ts

@@ -5,6 +5,7 @@ import { KEYCHAIN_URL } from "../constants";
 import BaseProvider from "../provider";
 import { toWasmPolicies } from "../utils";
 import { SessionPolicies } from "@cartridge/presets";
+import { AddStarknetChainParameters } from "@starknet-io/types-js";
 
 interface SessionRegistration {
   username: string;
@@ -26,14 +27,15 @@ export default class SessionProvider extends BaseProvider {
   public name = "Controller Session";
 
   protected _chainId: string;
-
+  protected _rpcUrl: string;
   protected _username?: string;
   protected _redirectUrl: string;
   protected _policies: SessionPolicies;
 
   constructor({ rpc, chainId, policies, redirectUrl }: SessionOptions) {
-    super({ rpc });
+    super();
 
+    this._rpcUrl = rpc;
     this._chainId = chainId;
     this._redirectUrl = redirectUrl;
     this._policies = policies;
@@ -76,7 +78,7 @@ export default class SessionProvider extends BaseProvider {
       this._redirectUrl
     }&redirect_query_name=startapp&policies=${JSON.stringify(
       this._policies,
-    )}&rpc_url=${this.rpc}`;
+    )}&rpc_url=${this._rpcUrl}`;
 
     localStorage.setItem("lastUsedConnector", this.id);
     window.open(url, "_blank");
@@ -84,6 +86,14 @@ export default class SessionProvider extends BaseProvider {
     return;
   }
 
+  switchStarknetChain(_chainId: string): Promise<boolean> {
+    throw new Error("switchStarknetChain not implemented");
+  }
+
+  addStarknetChain(_chain: AddStarknetChainParameters): Promise<boolean> {
+    throw new Error("addStarknetChain not implemented");
+  }
+
   disconnect(): Promise<void> {
     localStorage.removeItem("sessionSigner");
     localStorage.removeItem("session");
@@ -127,7 +137,7 @@ export default class SessionProvider extends BaseProvider {
 
     this._username = sessionRegistration.username;
     this.account = new SessionAccount(this, {
-      rpcUrl: this.rpc.toString(),
+      rpcUrl: this._rpcUrl,
       privateKey: signer.privKey,
       address: sessionRegistration.address,
       ownerGuid: sessionRegistration.ownerGuid,

package/src/telegram/provider.ts

@@ -11,6 +11,7 @@ import SessionAccount from "../session/account";
 import BaseProvider from "../provider";
 import { toWasmPolicies } from "../utils";
 import { SessionPolicies } from "@cartridge/presets";
+import { AddStarknetChainParameters } from "@starknet-io/types-js";
 
 interface SessionRegistration {
   username: string;
@@ -25,6 +26,7 @@ export default class TelegramProvider extends BaseProvider {
   protected _chainId: string;
   protected _username?: string;
   protected _policies: SessionPolicies;
+  private _rpcUrl: string;
 
   constructor({
     rpc,
@@ -37,10 +39,9 @@ export default class TelegramProvider extends BaseProvider {
     policies: SessionPolicies;
     tmaUrl: string;
   }) {
-    super({
-      rpc,
-    });
+    super();
 
+    this._rpcUrl = rpc;
     this._tmaUrl = tmaUrl;
     this._chainId = chainId;
     this._policies = policies;
@@ -77,7 +78,7 @@ export default class TelegramProvider extends BaseProvider {
       this._tmaUrl
     }&redirect_query_name=startapp&policies=${JSON.stringify(
       this._policies,
-    )}&rpc_url=${this.rpc}`;
+    )}&rpc_url=${this._rpcUrl}`;
 
     localStorage.setItem("lastUsedConnector", this.id);
     openLink(url);
@@ -86,6 +87,14 @@ export default class TelegramProvider extends BaseProvider {
     return;
   }
 
+  switchStarknetChain(_chainId: string): Promise<boolean> {
+    throw new Error("switchStarknetChain not implemented");
+  }
+
+  addStarknetChain(_chain: AddStarknetChainParameters): Promise<boolean> {
+    throw new Error("addStarknetChain not implemented");
+  }
+
   disconnect(): Promise<void> {
     cloudStorage.deleteItem("sessionSigner");
     cloudStorage.deleteItem("session");
@@ -118,7 +127,7 @@ export default class TelegramProvider extends BaseProvider {
 
     this._username = sessionRegistration.username;
     this.account = new SessionAccount(this, {
-      rpcUrl: this.rpc.toString(),
+      rpcUrl: this._rpcUrl,
       privateKey: signer.privKey,
       address: sessionRegistration.address,
       ownerGuid: sessionRegistration.ownerGuid,

package/src/types.ts

@@ -7,16 +7,12 @@ import {
 } from "starknet";
 import {
   AddInvokeTransactionResult,
+  ChainId,
   Signature,
   TypedData,
 } from "@starknet-io/types-js";
 import { KeychainIFrame, ProfileIFrame } from "./iframe";
-import {
-  ColorMode,
-  Policies,
-  Policy,
-  SessionPolicies,
-} from "@cartridge/presets";
+import { ColorMode, Policy, SessionPolicies } from "@cartridge/presets";
 
 export type Session = {
   chainId: constants.StarknetChainId;
@@ -100,7 +96,7 @@ export type ControllerAccounts = Record<ContractAddress, CartridgeID>;
 export interface Keychain {
   probe(rpcUrl: string): Promise<ProbeReply | ConnectError>;
   connect(
-    policies: Policies,
+    policies: SessionPolicies,
     rpcUrl: string,
   ): Promise<ConnectReply | ConnectError>;
   disconnect(): void;
@@ -134,6 +130,7 @@ export interface Keychain {
   openPurchaseCredits(): void;
   openExecute(calls: Call[]): Promise<void>;
 }
+
 export interface Profile {
   navigate(path: string): void;
 }
@@ -161,13 +158,17 @@ export type IFrameOptions = {
   colorMode?: ColorMode;
 };
 
+export type Chain = {
+  rpcUrl: string;
+};
+
 export type ProviderOptions = {
-  /** The URL of the RPC */
-  rpc: string;
+  defaultChainId: ChainId;
+  chains: Chain[];
 };
 
 export type KeychainOptions = IFrameOptions & {
-  policies?: Policies;
+  policies?: SessionPolicies;
   /** The URL of keychain */
   url?: string;
   /** The origin of keychain */
@@ -193,8 +194,6 @@ export type ProfileContextTypeVariant =
   | "achievements"
   | "activity";
 
-export type Prefund = { address: string; min: string };
-
 export type Tokens = {
   erc20?: string[];
 };

package/src/utils.ts

@@ -2,13 +2,16 @@ import {
   addAddressPadding,
   Call,
   CallData,
+  constants,
   getChecksumAddress,
   hash,
+  shortString,
   typedData,
   TypedDataRevision,
 } from "starknet";
 import wasm from "@cartridge/account-wasm/controller";
 import { Policies, SessionPolicies } from "@cartridge/presets";
+import { ChainId } from "@starknet-io/types-js";
 
 // Whitelist of allowed property names to prevent prototype pollution
 const ALLOWED_PROPERTIES = new Set([
@@ -129,3 +132,28 @@ export function humanizeString(str: string): string {
       .replace(/^\w/, (c) => c.toUpperCase())
   );
 }
+
+export function parseChainId(url: URL): ChainId {
+  const parts = url.pathname.split("/");
+
+  if (parts.includes("starknet")) {
+    if (parts.includes("mainnet")) {
+      return constants.StarknetChainId.SN_MAIN;
+    } else if (parts.includes("sepolia")) {
+      return constants.StarknetChainId.SN_SEPOLIA;
+    }
+  } else if (parts.length >= 3) {
+    const projectName = parts[2];
+    if (parts.includes("katana")) {
+      return shortString.encodeShortString(
+        `WP_${projectName.toUpperCase().replace(/-/g, "_")}`,
+      ) as ChainId;
+    } else if (parts.includes("mainnet")) {
+      return shortString.encodeShortString(
+        `GG_${projectName.toUpperCase().replace(/-/g, "_")}`,
+      ) as ChainId;
+    }
+  }
+
+  throw new Error(`Chain ${url.toString()} not supported`);
+}