@cartridge/controller 0.4.0 → 0.5.0-alpha.1

package/src/telegram/provider.ts

@@ -0,0 +1,131 @@
+import {
+  cloudStorage,
+  miniApp,
+  openLink,
+  retrieveLaunchParams,
+} from "@telegram-apps/sdk";
+import { ec, stark, WalletAccount } from "starknet";
+
+import { KEYCHAIN_URL } from "src/constants";
+import { Policy } from "src/types";
+import SessionAccount from "src/session/account";
+import BaseProvider from "src/provider";
+
+interface SessionRegistration {
+  username: string;
+  address: string;
+  ownerGuid: string;
+  transactionHash?: string;
+  expiresAt: string;
+}
+
+export default class TelegramProvider extends BaseProvider {
+  private _tmaUrl: string;
+  protected _chainId: string;
+  protected _username?: string;
+  protected _policies: Policy[];
+
+  constructor({
+    rpc,
+    chainId,
+    policies,
+    tmaUrl,
+  }: {
+    rpc: string;
+    chainId: string;
+    policies: Policy[];
+    tmaUrl: string;
+  }) {
+    super({
+      rpc,
+    });
+
+    this._tmaUrl = tmaUrl;
+    this._chainId = chainId;
+    this._policies = policies;
+
+    if (typeof window !== "undefined") {
+      (window as any).starknet_controller = this;
+    }
+  }
+
+  async probe(): Promise<WalletAccount | undefined> {
+    await this.tryRetrieveFromQueryOrStorage();
+    return;
+  }
+
+  async connect(): Promise<WalletAccount | undefined> {
+    await this.tryRetrieveFromQueryOrStorage();
+    if (this.account) {
+      return;
+    }
+
+    // Generate a random local key pair
+    const pk = stark.randomAddress();
+    const publicKey = ec.starkCurve.getStarkKey(pk);
+
+    cloudStorage.setItem(
+      "sessionSigner",
+      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.rpc}`;
+
+    localStorage.setItem("lastUsedConnector", this.id);
+    openLink(url);
+    miniApp.close();
+
+    return;
+  }
+
+  disconnect(): Promise<void> {
+    cloudStorage.deleteItem("sessionSigner");
+    cloudStorage.deleteItem("session");
+    this.account = undefined;
+    this._username = undefined;
+    return Promise.resolve();
+  }
+
+  async tryRetrieveFromQueryOrStorage() {
+    const signer = JSON.parse((await cloudStorage.getItem("sessionSigner"))!);
+    let sessionRegistration: SessionRegistration | null = null;
+
+    const launchParams = retrieveLaunchParams();
+    const session = launchParams.startParam;
+    if (session) {
+      sessionRegistration = JSON.parse(atob(session));
+      cloudStorage.setItem("session", JSON.stringify(sessionRegistration));
+    }
+
+    if (!sessionRegistration) {
+      const session = await cloudStorage.getItem("session");
+      if (session) {
+        sessionRegistration = JSON.parse(session);
+      }
+    }
+
+    if (!sessionRegistration) {
+      return;
+    }
+
+    this._username = sessionRegistration.username;
+    this.account = new SessionAccount(this, {
+      rpcUrl: this.rpc.toString(),
+      privateKey: signer.privKey,
+      address: sessionRegistration.address,
+      ownerGuid: sessionRegistration.ownerGuid,
+      chainId: this._chainId,
+      expiresAt: parseInt(sessionRegistration.expiresAt),
+      policies: this._policies,
+    });
+
+    return this.account;
+  }
+}

package/src/types.ts

@@ -1,19 +1,15 @@
 import {
   constants,
-  Abi,
+  BigNumberish,
   Call,
+  Abi,
   InvocationsDetails,
-  TypedData,
-  InvokeFunctionResponse,
-  Signature,
-  EstimateFeeDetails,
-  EstimateFee,
-  DeclareContractPayload,
-  BigNumberish,
-  InvocationsSignerDetails,
-  DeployAccountSignerDetails,
-  DeclareSignerDetails,
 } from "starknet";
+import {
+  AddInvokeTransactionResult,
+  Signature,
+  TypedData,
+} from "@starknet-io/types-js";
 import { KeychainIFrame, ProfileIFrame } from "./iframe";
 import wasm from "@cartridge/account-wasm/controller";
 
@@ -59,7 +55,7 @@ export type ConnectReply = {
 };
 
 export type ExecuteReply =
-  | (InvokeFunctionResponse & {
+  | (AddInvokeTransactionResult & {
       code: ResponseCodes.SUCCESS;
     })
   | {
@@ -97,46 +93,28 @@ export interface Keychain {
   revoke(origin: string): void;
 
   deploy(): Promise<DeployReply | ConnectError>;
-  estimateDeclareFee(
-    payload: DeclareContractPayload,
-    details?: EstimateFeeDetails,
-  ): Promise<EstimateFee>;
-  estimateInvokeFee(
-    calls: Call | Call[],
-    estimateFeeDetails?: EstimateFeeDetails,
-  ): Promise<EstimateFee>;
   execute(
     calls: Call | Call[],
     abis?: Abi[],
     transactionsDetail?: InvocationsDetails,
     sync?: boolean,
-    paymaster?: PaymasterOptions,
+    paymaster?: any,
     error?: ControllerError,
   ): Promise<ExecuteReply | ConnectError>;
+  signMessage(
+    typedData: TypedData,
+    account: string,
+  ): Promise<Signature | ConnectError>;
   logout(): Promise<void>;
   openSettings(): Promise<void | ConnectError>;
   session(): Promise<Session>;
   sessions(): Promise<{
     [key: string]: Session;
   }>;
-  signMessage(
-    typedData: TypedData,
-    account: string,
-  ): Promise<Signature | ConnectError>;
-  signTransaction(
-    transactions: Call[],
-    transactionsDetail: InvocationsSignerDetails,
-    abis?: Abi[],
-  ): Promise<Signature>;
-  signDeployAccountTransaction(
-    transaction: DeployAccountSignerDetails,
-  ): Promise<Signature>;
-  signDeclareTransaction(transaction: DeclareSignerDetails): Promise<Signature>;
   delegateAccount(): string;
   username(): string;
   fetchControllers(contractAddresses: string[]): Promise<ControllerAccounts>;
 }
-
 export interface Profile {
   navigate(tab: ProfileContextTypeVariant): void;
 }
@@ -149,7 +127,9 @@ export interface Modal {
 /**
  * Options for configuring the controller
  */
-export type ControllerOptions = KeychainOptions & ProfileOptions;
+export type ControllerOptions = ProviderOptions &
+  KeychainOptions &
+  ProfileOptions;
 
 export type TokenOptions = {
   tokens: Tokens;
@@ -169,16 +149,17 @@ export type IFrameOptions = {
   };
 };
 
+export type ProviderOptions = {
+  /** The URL of the RPC */
+  rpc: string;
+};
+
 export type KeychainOptions = IFrameOptions & {
   policies?: Policy[];
   /** The URL of keychain */
   url?: string;
-  /** The URL of the RPC */
-  rpc?: string;
   /** The origin of keychain */
   origin?: string;
-  /** Paymaster options for transaction fee management */
-  paymaster?: PaymasterOptions;
   /** Propagate transaction errors back to caller instead of showing modal */
   propagateSessionErrors?: boolean;
 };
@@ -192,22 +173,7 @@ export type ProfileOptions = IFrameOptions & {
   tokens?: Tokens;
 };
 
-export type ProfileContextTypeVariant = "quest" | "inventory" | "history";
-
-/**
- * Options for configuring a paymaster
- */
-export type PaymasterOptions = {
-  /**
-   * The address of the account paying for the transaction.
-   * This should be a valid Starknet address or "ANY_CALLER" short string.
-   */
-  caller: string;
-  /**
-   * The URL of the paymaster. Currently not used.
-   */
-  url?: string;
-};
+export type ProfileContextTypeVariant = "trophies" | "inventory" | "activity";
 
 export type ColorMode = "light" | "dark";
 

package/src/utils.ts

@@ -1,15 +1,5 @@
-import equal from "fast-deep-equal";
-import { Policy } from "./types";
 import { addAddressPadding, Call, CallData } from "starknet";
 
-export function diff(a: Policy[], b: Policy[]): Policy[] {
-  return a.reduce(
-    (prev, policyA) =>
-      b.some((policyB) => equal(policyB, policyA)) ? prev : [...prev, policyA],
-    [] as Policy[],
-  );
-}
-
 export function normalizeCalls(calls: Call | Call[]) {
   return (Array.isArray(calls) ? calls : [calls]).map((call) => {
     return {