Refactor session registration / deployment

Author: broody

packages/account-wasm/pkg/account_wasm.d.ts

@@ -1,10 +1,5 @@
 /* tslint:disable */
 /* eslint-disable */
-export interface JsInvocationsDetails {
-    nonce: Felt;
-    maxFee: Felt;
-}
-
 export interface JsOutsideExecution {
     caller: Felt;
     executeBefore: number;
@@ -13,24 +8,29 @@ export interface JsOutsideExecution {
     nonce: Felt;
 }
 
-export interface JsPolicy {
-    target: string;
-    method: string;
-}
+export type Felts = JsFelt[];
+
+export type JsFelt = Felt;
 
 export interface JsCall {
     contractAddress: Felt;
     entrypoint: string;
     calldata: Felt[];
 }
 
-export interface JsEstimateFeeDetails {
+export interface JsInvocationsDetails {
     nonce: Felt;
+    maxFee: Felt;
 }
 
-export type Felts = JsFelt[];
+export interface JsPolicy {
+    target: string;
+    method: string;
+}
 
-export type JsFelt = Felt;
+export interface JsEstimateFeeDetails {
+    nonce: Felt;
+}
 
 export interface JsSession {
     policies: JsPolicy[];
@@ -115,13 +115,6 @@ export class CartridgeAccount {
 */
   sessionJson(): any;
 /**
-* @param {(JsPolicy)[]} policies
-* @param {bigint} expires_at
-* @param {any} external_account
-* @returns {any}
-*/
-  static registerSessionCalldata(policies: (JsPolicy)[], expires_at: bigint, external_account: any): any;
-/**
 */
   revokeSession(): void;
 /**
@@ -139,19 +132,14 @@ export class CartridgeAccount {
 */
   delegateAccount(): Promise<JsFelt>;
 /**
-* @param {any} salt
-* @param {any} external_owner
-* @returns {any}
-*/
-  static getUdcDeployedAddress(salt: any, external_owner: any): any;
-/**
-* @returns {any}
-*/
-  static getAccountClassHash(): any;
-/**
+* @param {any} owner
+* @param {any} username
+* @param {bigint} initial_deposit
+* @param {(JsPolicy)[]} policies
+* @param {bigint} expires_at
 * @returns {any}
 */
-  static getUdcAddress(): any;
+  static externalDeploymentCalls(owner: any, username: any, initial_deposit: bigint, policies: (JsPolicy)[], expires_at: bigint): any;
 }
 /**
 */

packages/account-wasm/pkg/account_wasm.js

@@ -1,3 +1,4 @@
+
 import * as wasm from "./account_wasm_bg.wasm";
 import { __wbg_set_wasm } from "./account_wasm_bg.js";
 __wbg_set_wasm(wasm);

packages/account-wasm/pkg/account_wasm_bg.js

@@ -1,7 +1,7 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
-export function __wbg_cartridgeaccount_free(a: number): void;
+export function __wbg_cartridgeaccount_free(a: number, b: number): void;
 export function cartridgeaccount_new(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number): void;
 export function cartridgeaccount_ownerGuid(a: number): number;
 export function cartridgeaccount_registerSession(a: number, b: number, c: number, d: number, e: number): number;
@@ -11,15 +11,12 @@ export function cartridgeaccount_execute(a: number, b: number, c: number, d: num
 export function cartridgeaccount_executeFromOutside(a: number, b: number, c: number, d: number): number;
 export function cartridgeaccount_hasSession(a: number, b: number, c: number, d: number): void;
 export function cartridgeaccount_sessionJson(a: number, b: number): void;
-export function cartridgeaccount_registerSessionCalldata(a: number, b: number, c: number, d: number, e: number): void;
 export function cartridgeaccount_revokeSession(a: number, b: number): void;
 export function cartridgeaccount_signMessage(a: number, b: number, c: number): number;
 export function cartridgeaccount_deploySelf(a: number, b: number): number;
 export function cartridgeaccount_delegateAccount(a: number): number;
-export function cartridgeaccount_getUdcDeployedAddress(a: number, b: number, c: number): void;
-export function cartridgeaccount_getAccountClassHash(): number;
-export function cartridgeaccount_getUdcAddress(): number;
-export function __wbg_cartridgesessionaccount_free(a: number): void;
+export function cartridgeaccount_externalDeploymentCalls(a: number, b: number, c: number, d: number, e: number, f: number, g: number): void;
+export function __wbg_cartridgesessionaccount_free(a: number, b: number): void;
 export function cartridgesessionaccount_new(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number): void;
 export function cartridgesessionaccount_new_as_registered(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number): void;
 export function cartridgesessionaccount_sign(a: number, b: number, c: number, d: number): number;
@@ -28,7 +25,7 @@ export function cartridgesessionaccount_execute_from_outside(a: number, b: numbe
 export function __wbindgen_malloc(a: number, b: number): number;
 export function __wbindgen_realloc(a: number, b: number, c: number, d: number): number;
 export const __wbindgen_export_2: WebAssembly.Table;
-export function _dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h3f3a3deef6344805(a: number, b: number, c: number): void;
+export function _dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__ha5780fd1342283cf(a: number, b: number, c: number): void;
 export function __wbindgen_add_to_stack_pointer(a: number): number;
 export function __wbindgen_exn_store(a: number): void;
-export function wasm_bindgen__convert__closures__invoke2_mut__hbcb2218b5bd12b96(a: number, b: number, c: number, d: number): void;
+export function wasm_bindgen__convert__closures__invoke2_mut__h11630e69f33a5871(a: number, b: number, c: number, d: number): void;

packages/account-wasm/pkg/account_wasm_bg.wasm

@@ -13,11 +13,11 @@ use account_sdk::account::session::hash::Session;
 use account_sdk::account::session::raw_session::RawSession;
 use account_sdk::account::session::SessionAccount;
 use account_sdk::account::{AccountHashAndCallsSigner, MessageSignerAccount};
-use account_sdk::constants::{ACCOUNT_CLASS_HASH, UDC_ADDRESS};
+use account_sdk::constants::{ACCOUNT_CLASS_HASH, ETH_CONTRACT_ADDRESS, UDC_ADDRESS};
 use account_sdk::controller::Controller;
 use account_sdk::provider::{CartridgeJsonRpcProvider, CartridgeProvider};
 use account_sdk::signers::webauthn::{CredentialID, WebauthnSigner};
-use account_sdk::signers::{HashSigner, Signer};
+use account_sdk::signers::{HashSigner, Signer, SignerTrait};
 use base64::engine::general_purpose;
 use base64::Engine;
 use cainome::cairo_serde::{CairoSerde, ContractAddress};
@@ -37,6 +37,7 @@ use types::session::JsSession;
 use types::{Felts, JsFelt};
 use url::Url;
 use wasm_bindgen::prelude::*;
+use web_sys::console;
 
 use crate::errors::OperationError;
 use crate::types::invocation::JsInvocationsDetails;
@@ -256,28 +257,6 @@ impl CartridgeAccount {
             .map_or_else(|| Ok(JsValue::NULL), Ok)
     }
 
-    #[wasm_bindgen(js_name = registerSessionCalldata)]
-    pub fn register_session_calldata(
-        policies: Vec<JsPolicy>,
-        expires_at: u64,
-        external_account: JsValue,
-    ) -> Result<JsValue> {
-        let methods = policies
-            .into_iter()
-            .map(TryFrom::try_from)
-            .collect::<std::result::Result<Vec<_>, _>>()?;
-
-        let signer = SigningKey::from_random();
-        let session = Session::new(methods, expires_at, &signer.signer())?;
-
-        let calldata = [
-            <RawSession as CairoSerde>::cairo_serialize(&session.raw()),
-            vec![from_value(external_account)?],
-        ]
-        .concat();
-        Ok(to_value(&calldata)?)
-    }
-
     #[wasm_bindgen(js_name = revokeSession)]
     pub fn revoke_session(&self) -> Result<()> {
         unimplemented!("Revoke Session not implemented");
@@ -324,39 +303,90 @@ impl CartridgeAccount {
         Ok(JsFelt(res))
     }
 
-    #[wasm_bindgen(js_name = getUdcDeployedAddress)]
-    pub fn get_udc_deployed_address(salt: JsValue, external_owner: JsValue) -> Result<JsValue> {
-        set_panic_hook();
-
-        let salt = from_value::<Felt>(salt)?;
-        let external_owner = from_value::<ContractAddress>(external_owner)?;
+    #[wasm_bindgen(js_name = externalDeploymentCalls)]
+    pub fn external_deployment_calls(
+        owner: JsValue,
+        username: JsValue,
+        initial_deposit: u64,
+        policies: Vec<JsPolicy>,
+        expires_at: u64,
+    ) -> Result<JsValue> {
+        let mut js_calls: Vec<JsCall> = vec![];
+        let salt = from_value::<Felt>(username)?;
+        let owner = from_value::<ContractAddress>(owner)?;
 
         let mut constructor_calldata =
-            controller::Owner::cairo_serialize(&controller::Owner::Account(external_owner));
+            controller::Owner::cairo_serialize(&controller::Owner::Account(owner));
         constructor_calldata.extend(Option::<AbigenSigner>::cairo_serialize(&None));
 
-        let res = get_udc_deployed_address(
+        let address = get_udc_deployed_address(
             salt,
             ACCOUNT_CLASS_HASH,
             &UdcUniqueness::NotUnique,
             &constructor_calldata,
         );
 
+        let mut udc_deploy_calldata = vec![
+            ACCOUNT_CLASS_HASH,
+            salt,
+            Felt::ZERO, // unique false
+        ];
+        udc_deploy_calldata.push(constructor_calldata.len().into());
+        udc_deploy_calldata.extend(constructor_calldata);
+
+        // Universal Deployer Contract calldata
+        js_calls.push(JsCall {
+            contract_address: UDC_ADDRESS,
+            entrypoint: "deployContract".to_string(),
+            calldata: udc_deploy_calldata,
+        });
+
+        // Set Delegate account
+        js_calls.push(JsCall {
+            contract_address: address,
+            entrypoint: "set_delegate_account".to_string(),
+            calldata: vec![owner.into()],
+        });
+
+        // Register new session
+        let methods = policies
+            .into_iter()
+            .map(TryFrom::try_from)
+            .collect::<std::result::Result<Vec<_>, _>>()?;
+        let session_signer = SigningKey::from_random();
+        let session = Session::new(methods, expires_at, &session_signer.signer())?;
+
+        js_calls.push(JsCall {
+            contract_address: address,
+            entrypoint: "register_session".to_string(),
+            calldata: [
+                <RawSession as CairoSerde>::cairo_serialize(&session.raw()),
+                vec![owner.into()],
+            ]
+            .concat(),
+        });
+
+        // Transfer ETH calldata
+        if initial_deposit > 0 {
+            js_calls.push(JsCall {
+                contract_address: ETH_CONTRACT_ADDRESS,
+                entrypoint: "approve".to_string(),
+                calldata: vec![address, initial_deposit.into(), Felt::ZERO],
+            });
+
+            js_calls.push(JsCall {
+                contract_address: ETH_CONTRACT_ADDRESS,
+                entrypoint: "transfer".to_string(),
+                calldata: vec![address, initial_deposit.into(), Felt::ZERO],
+            });
+        }
+
         Ok(to_value(&JsDeployment {
-            address: res,
-            calldata: constructor_calldata,
+            address: address,
+            calls: js_calls,
+            session_key: session_signer.secret_scalar(),
         })?)
     }
-
-    #[wasm_bindgen(js_name = getAccountClassHash)]
-    pub fn get_account_class_hash() -> JsValue {
-        to_value(&ACCOUNT_CLASS_HASH).unwrap()
-    }
-
-    #[wasm_bindgen(js_name = getUdcAddress)]
-    pub fn get_udc_address() -> JsValue {
-        to_value(&UDC_ADDRESS).unwrap()
-    }
 }
 
 #[wasm_bindgen]

packages/account-wasm/pkg/account_wasm_bg.wasm.d.ts

@@ -45,3 +45,13 @@ impl TryFrom<JsCall> for types::Call {
         })
     }
 }
+
+impl From<types::Call> for JsCall {
+    fn from(value: types::Call) -> Self {
+        JsCall {
+            contract_address: value.to.into(),
+            entrypoint: value.selector.to_string(),
+            calldata: value.calldata,
+        }
+    }
+}

packages/account-wasm/src/lib.rs

@@ -3,13 +3,14 @@ use serde_with::serde_as;
 use starknet::core::serde::unsigned_field_element::UfeHex;
 use starknet::core::types::Felt;
 
+use super::call::JsCall;
+
 #[serde_as]
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct JsDeployment {
     #[serde_as(as = "UfeHex")]
     pub address: Felt,
-
-    #[serde_as(as = "Vec<UfeHex>")]
-    pub calldata: Vec<Felt>,
+    pub calls: Vec<JsCall>,
+    pub session_key: Felt,
 }

packages/account-wasm/src/types/call.rs

@@ -12,3 +12,6 @@ pub const ACCOUNT_COMPILED_CLASS_HASH: Felt =
 
 pub const ERC_20_COMPILED_CLASS_HASH: Felt =
     felt!("0x732654ca6baa90ff202d2fcc35fb39766eb34842a7e5ac6dbf7714af71f1dab");
+
+pub const ETH_CONTRACT_ADDRESS: Felt = 
+    felt!("0x49d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7");

packages/account-wasm/src/types/deployment.rs

@@ -13,7 +13,6 @@ import { ErrorAlert } from "components/ErrorAlert";
 
 export function Login(props: LoginProps) {
   const theme = useControllerTheme();
-  console.debug("login render");
 
   return (
     <Container

packages/account_sdk/src/constants.rs

@@ -28,18 +28,12 @@ import {
   useProvider,
   voyager,
 } from "@starknet-react/core";
-import {
-  CallData,
-  RpcProvider,
-  TypedData,
-  cairo,
-  num,
-  shortString,
-} from "starknet";
-import { CheckIcon, CopyAddress, DotsIcon, PacmanIcon } from "@cartridge/ui";
+import { RpcProvider, TypedData, num, shortString } from "starknet";
+import { CheckIcon, DotsIcon, PacmanIcon } from "@cartridge/ui";
 import { useConnection } from "hooks/connection";
 import { useToast } from "hooks/toast";
 import {
+  ETH_CONTRACT_ADDRESS,
   TokenInfo,
   fetchTokenInfo,
   getBalanceStr,
@@ -51,7 +45,10 @@ import {
 import { ErrorAlert } from "../../ErrorAlert";
 import { beginAccountSignup, finalizeAccountSignup } from "hooks/account";
 import base64url from "base64url";
-import { CartridgeAccount } from "@cartridge/account-wasm";
+import {
+  CartridgeAccount,
+  CartridgeSessionAccount,
+} from "@cartridge/account-wasm";
 
 enum SignupState {
   CONNECT,
@@ -109,13 +106,11 @@ export function SignupArgent({ username }: { username: string }) {
 function SignupArgentInner({ username }: { username: string }) {
   const { account: extAccount } = useAccount();
   const { connectAsync, connectors, isPending: isConnecting } = useConnect();
-  const { chainId, chainName, policies } = useConnection();
+  const { chainId, chainName, policies, rpcUrl } = useConnection();
   const { isChecked, tokens, isFetching, isAllFunded } = useTokens();
   const [isDeploying, setIsDeploying] = useState(false);
   const [error, setError] = useState<Error>();
   const [state, setState] = useState<SignupState>(SignupState.CONNECT);
-  const [controllerAddress, setControllerAddress] = useState("");
-  const [controllerCalldata, setControllerCalldata] = useState([]);
 
   const [title, setTitle] = useState("");
 
@@ -152,17 +147,6 @@ function SignupArgentInner({ username }: { username: string }) {
       const typedData = registerTypedData(username, { low, high }, chainId);
       const sig = await extAccount.signMessage(typedData);
       await finalizeAccountSignup(extAccount.address, chainId, sig as string[]);
-
-      // set controller address & calldata
-      const salt = shortString.encodeShortString(username);
-      const { address, calldata } = CartridgeAccount.getUdcDeployedAddress(
-        salt,
-        extAccount.address,
-      );
-
-      setControllerAddress(address);
-      setControllerCalldata(calldata);
-
       setState(SignupState.DEPLOY);
     } catch (e) {
       console.log(e);
@@ -173,83 +157,59 @@ function SignupArgentInner({ username }: { username: string }) {
   const onDeploy = useCallback(async () => {
     if (!extAccount) return;
 
-    const calls = tokens.flatMap((t) => {
-      const amount = cairo.uint256(t.min);
-      return [
-        {
-          contractAddress: t.address,
-          entrypoint: "approve",
-          calldata: CallData.compile({
-            recipient: controllerAddress,
-            amount,
-          }),
-        },
-        {
-          contractAddress: t.address,
-          entrypoint: "transfer",
-          calldata: CallData.compile({
-            recipient: controllerAddress,
-            amount,
-          }),
-        },
-      ];
-    });
-
-    // deployContract
-    const salt = shortString.encodeShortString(username);
-    calls.push({
-      contractAddress: CartridgeAccount.getUdcAddress(),
-      entrypoint: "deployContract",
-      calldata: CallData.compile({
-        classHash: CartridgeAccount.getAccountClassHash(),
-        salt,
-        unique: false,
-        calldata: controllerCalldata,
-      }),
-    });
-
-    // registerSession
-    calls.push({
-      contractAddress: controllerAddress,
-      entrypoint: "register_session",
-      calldata: CartridgeAccount.registerSessionCalldata(
+    try {
+      setIsDeploying(true);
+
+      const {
+        address: controllerAddress,
+        calls: deploymentCalls,
+        sessionKey,
+      } = CartridgeAccount.externalDeploymentCalls(
+        extAccount.address,
+        shortString.encodeShortString(username),
+        100000000000000000n,
         policies.map((p) => {
           return { target: p.target, method: p.method };
         }),
         3000000000n,
-        extAccount.address,
-      ),
-    });
-
-    console.log(
-      calls
-        .map((call) => {
-          return CallData.compile(call)
-            .map((i) => `0x${BigInt(i).toString(16)}`)
-            .join(" ");
-        })
-        .join(" / "),
-    );
+      );
 
-    try {
-      setIsDeploying(true);
-      const res = await extAccount.execute(calls);
+      const res = await extAccount.execute(deploymentCalls);
       await extAccount.waitForTransaction(res.transaction_hash, {
         retryInterval: 1000,
       });
+
+      // Test session account
+      const sessionAccount = CartridgeSessionAccount.new_as_registered(
+        rpcUrl,
+        sessionKey,
+        controllerAddress,
+        extAccount.address,
+        chainId,
+        {
+          policies: policies.map((p) => {
+            return { target: p.target, method: p.method };
+          }),
+          expiresAt: 3000000000,
+        },
+      );
+
+      const res2 = await sessionAccount.execute([
+        {
+          contractAddress: ETH_CONTRACT_ADDRESS,
+          entrypoint: "transfer",
+          calldata: [extAccount.address, "0x2386F26FC10000", "0"],
+        },
+      ]);
+
+      console.log(res2);
     } catch (e) {
       console.log(e);
       setError(e);
+    } finally {
+      setIsDeploying(false);
     }
-    setIsDeploying(false);
-  }, [
-    extAccount,
-    controllerAddress,
-    controllerCalldata,
-    policies,
-    tokens,
-    username,
-  ]);
+  }, [extAccount, policies, tokens, username]);
 
   // const onCopy = useCallback(() => {
   //   navigator.clipboard.writeText(controllerAddress);
@@ -283,9 +243,7 @@ function SignupArgentInner({ username }: { username: string }) {
             "Please connect your ArgentX wallet"}
           {state === SignupState.SIGN_MESSAGE &&
             "Sign message to create your controller"}
-          {state === SignupState.DEPLOY && (
-            <CopyAddress address={controllerAddress} />
-          )}
+          {state === SignupState.DEPLOY && <></>}
         </>
       }
       // TODO: Add line icons
@@ -407,7 +365,6 @@ function SignupArgentInner({ username }: { username: string }) {
               <Button
                 colorScheme="colorful"
                 onClick={() => {
-                  console.log("deploy");
                   onDeploy();
                 }}
                 isLoading={isDeploying}

packages/keychain/src/components/connect/Login.tsx

@@ -50,8 +50,6 @@ export function Signup({
     1000,
   );
 
-  console.debug("signup render");
-
   // In order for Safari to open "Create Passkey" modal successfully, submit handler has to be async.
   // The workaround is to call async validation function every time when username input changes
   useEffect(() => {