diff --git a/examples/starknet-react-next/src/components/providers/StarknetProvider.tsx b/examples/starknet-react-next/src/components/providers/StarknetProvider.tsx
index 913f10ec1..9941ed46e 100644
--- a/examples/starknet-react-next/src/components/providers/StarknetProvider.tsx
+++ b/examples/starknet-react-next/src/components/providers/StarknetProvider.tsx
@@ -66,16 +66,16 @@ const cartridge = new CartridgeConnector({
   },
   // theme: "dope-wars",
   // colorMode: "light"
-  // prefunds: [
-  //   {
-  //     address: ETH_TOKEN_ADDRESS,
-  //     min: "300000000000000",
-  //   },
-  //   {
-  //     address: PAPER_TOKEN_ADDRESS,
-  //     min: "100",
-  //   },
-  // ],
+  prefunds: [
+    {
+      address: ETH_TOKEN_ADDRESS,
+      min: "300000000000000",
+    },
+    // {
+    //   address: PAPER_TOKEN_ADDRESS,
+    //   min: "100",
+    // },
+  ],
 });
 
 function provider(chain: Chain) {
diff --git a/packages/account-wasm/pkg/account_wasm.d.ts b/packages/account-wasm/pkg/account_wasm.d.ts
index 5400d6d99..9bc54115d 100644
--- a/packages/account-wasm/pkg/account_wasm.d.ts
+++ b/packages/account-wasm/pkg/account_wasm.d.ts
@@ -4,19 +4,6 @@ export interface JsEstimateFeeDetails {
     nonce: Felt;
 }
 
-export interface JsOutsideExecution {
-    caller: Felt;
-    executeBefore: number;
-    executeAfter: number;
-    calls: JsCall[];
-    nonce: Felt;
-}
-
-export interface JsInvocationsDetails {
-    nonce: Felt;
-    maxFee: Felt;
-}
-
 export type Felts = JsFelt[];
 
 export type JsFelt = Felt;
@@ -31,6 +18,19 @@ export interface JsCredentials {
     privateKey: Felt;
 }
 
+export interface JsInvocationsDetails {
+    nonce: Felt;
+    maxFee: Felt;
+}
+
+export interface JsOutsideExecution {
+    caller: Felt;
+    executeBefore: number;
+    executeAfter: number;
+    calls: JsCall[];
+    nonce: Felt;
+}
+
 export interface JsCall {
     contractAddress: Felt;
     entrypoint: string;
@@ -131,6 +131,15 @@ export class CartridgeAccount {
 * @returns {Promise<JsFelt>}
 */
   delegateAccount(): Promise<JsFelt>;
+/**
+* @param {any} owner
+* @param {any} username
+* @param {(JsPolicy)[]} policies
+* @param {bigint} expires_at
+* @param {bigint} initial_deposit
+* @returns {any}
+*/
+  static externalDeploymentCalls(owner: any, username: any, policies: (JsPolicy)[], expires_at: bigint, initial_deposit: bigint): any;
 }
 /**
 */
diff --git a/packages/account-wasm/pkg/account_wasm_bg.js b/packages/account-wasm/pkg/account_wasm_bg.js
index 3161f8d58..0683b1894 100644
--- a/packages/account-wasm/pkg/account_wasm_bg.js
+++ b/packages/account-wasm/pkg/account_wasm_bg.js
@@ -12,15 +12,6 @@ function getObject(idx) { return heap[idx]; }
 
 let heap_next = heap.length;
 
-function addHeapObject(obj) {
-    if (heap_next === heap.length) heap.push(heap.length + 1);
-    const idx = heap_next;
-    heap_next = heap[idx];
-
-    heap[idx] = obj;
-    return idx;
-}
-
 function dropObject(idx) {
     if (idx < 132) return;
     heap[idx] = heap_next;
@@ -33,7 +24,20 @@ function takeObject(idx) {
     return ret;
 }
 
-let WASM_VECTOR_LEN = 0;
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
+
+let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
 
 let cachedUint8ArrayMemory0 = null;
 
@@ -44,6 +48,13 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+let WASM_VECTOR_LEN = 0;
+
 const lTextEncoder = typeof TextEncoder === 'undefined' ? (0, module.require)('util').TextEncoder : TextEncoder;
 
 let cachedTextEncoder = new lTextEncoder('utf-8');
@@ -113,17 +124,6 @@ function getDataViewMemory0() {
     return cachedDataViewMemory0;
 }
 
-const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
-
-let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-
-cachedTextDecoder.decode();
-
-function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
-}
-
 function debugString(val) {
     // primitive types
     const type = typeof val;
@@ -220,7 +220,7 @@ function makeMutClosure(arg0, arg1, dtor, f) {
     return real;
 }
 function __wbg_adapter_44(arg0, arg1, arg2) {
-    wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hab75a3c637f96005(arg0, arg1, addHeapObject(arg2));
+    wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__ha5780fd1342283cf(arg0, arg1, addHeapObject(arg2));
 }
 
 function passArrayJsValueToWasm0(array, malloc) {
@@ -240,8 +240,8 @@ function handleError(f, args) {
         wasm.__wbindgen_exn_store(addHeapObject(e));
     }
 }
-function __wbg_adapter_185(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures__invoke2_mut__h47b629288504f118(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wbg_adapter_186(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures__invoke2_mut__h11630e69f33a5871(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const CartridgeAccountFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -462,6 +462,31 @@ export class CartridgeAccount {
         const ret = wasm.cartridgeaccount_delegateAccount(this.__wbg_ptr);
         return takeObject(ret);
     }
+    /**
+    * @param {any} owner
+    * @param {any} username
+    * @param {(JsPolicy)[]} policies
+    * @param {bigint} expires_at
+    * @param {bigint} initial_deposit
+    * @returns {any}
+    */
+    static externalDeploymentCalls(owner, username, policies, expires_at, initial_deposit) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayJsValueToWasm0(policies, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.cartridgeaccount_externalDeploymentCalls(retptr, addHeapObject(owner), addHeapObject(username), ptr0, len0, expires_at, initial_deposit);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
 }
 
 const CartridgeSessionAccountFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -577,13 +602,18 @@ export class CartridgeSessionAccount {
     }
 }
 
+export function __wbindgen_object_drop_ref(arg0) {
+    takeObject(arg0);
+};
+
 export function __wbindgen_object_clone_ref(arg0) {
     const ret = getObject(arg0);
     return addHeapObject(ret);
 };
 
-export function __wbindgen_object_drop_ref(arg0) {
-    takeObject(arg0);
+export function __wbindgen_error_new(arg0, arg1) {
+    const ret = new Error(getStringFromWasm0(arg0, arg1));
+    return addHeapObject(ret);
 };
 
 export function __wbindgen_string_get(arg0, arg1) {
@@ -595,11 +625,6 @@ export function __wbindgen_string_get(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
-export function __wbindgen_error_new(arg0, arg1) {
-    const ret = new Error(getStringFromWasm0(arg0, arg1));
-    return addHeapObject(ret);
-};
-
 export function __wbindgen_string_new(arg0, arg1) {
     const ret = getStringFromWasm0(arg0, arg1);
     return addHeapObject(ret);
@@ -1033,7 +1058,7 @@ export function __wbg_new_b85e72ed1bfd57f9(arg0, arg1) {
             const a = state0.a;
             state0.a = 0;
             try {
-                return __wbg_adapter_185(a, state0.b, arg0, arg1);
+                return __wbg_adapter_186(a, state0.b, arg0, arg1);
             } finally {
                 state0.a = a;
             }
@@ -1137,8 +1162,8 @@ export function __wbindgen_memory() {
     return addHeapObject(ret);
 };
 
-export function __wbindgen_closure_wrapper2417(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 474, __wbg_adapter_44);
+export function __wbindgen_closure_wrapper2435(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 471, __wbg_adapter_44);
     return addHeapObject(ret);
 };
 
diff --git a/packages/account-wasm/pkg/account_wasm_bg.wasm b/packages/account-wasm/pkg/account_wasm_bg.wasm
index 7998b32fa..620455955 100644
Binary files a/packages/account-wasm/pkg/account_wasm_bg.wasm and b/packages/account-wasm/pkg/account_wasm_bg.wasm differ
diff --git a/packages/account-wasm/pkg/account_wasm_bg.wasm.d.ts b/packages/account-wasm/pkg/account_wasm_bg.wasm.d.ts
index 9fbaf1306..77999073c 100644
--- a/packages/account-wasm/pkg/account_wasm_bg.wasm.d.ts
+++ b/packages/account-wasm/pkg/account_wasm_bg.wasm.d.ts
@@ -15,6 +15,7 @@ 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_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;
@@ -24,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__hab75a3c637f96005(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__h47b629288504f118(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;
diff --git a/packages/account-wasm/src/deployment.rs b/packages/account-wasm/src/deployment.rs
new file mode 100644
index 000000000..40b2bf0e1
--- /dev/null
+++ b/packages/account-wasm/src/deployment.rs
@@ -0,0 +1,175 @@
+use account_sdk::abigen::controller::{self, Signer as AbigenSigner};
+use account_sdk::account::session::hash::{AllowedMethod, Session};
+use account_sdk::account::session::raw_session::RawSession;
+use account_sdk::constants::{ACCOUNT_CLASS_HASH, ETH_CONTRACT_ADDRESS, UDC_ADDRESS};
+use account_sdk::signers::HashSigner;
+use cainome::cairo_serde::CairoSerde;
+use serde::{Deserialize, Serialize};
+use serde_wasm_bindgen::to_value;
+use serde_with::serde_as;
+use starknet::{
+    core::utils::{get_udc_deployed_address, UdcUniqueness},
+    signers::SigningKey,
+};
+use starknet::core::serde::unsigned_field_element::UfeHex;
+use starknet_types_core::felt::Felt;
+use wasm_bindgen::JsValue;
+
+use crate::types::call::JsCall;
+use crate::Result;
+
+#[serde_as]
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct JsDeployment {
+    #[serde_as(as = "UfeHex")]
+    pub address: Felt,
+    pub calls: Vec<JsCall>,
+    pub session_key: Felt,
+}
+
+
+pub struct JsDeploymentBuilder {
+    owner: Felt,
+    username: Felt,
+    delegate: Felt,
+    allowed_methods: Vec<AllowedMethod>,
+    expires_at: u64,
+    initial_deposit: u64,
+}
+
+impl JsDeploymentBuilder {
+    pub fn new(owner: Felt, username: Felt) -> Self {
+        Self {
+            owner,
+            username,
+            delegate: Felt::ZERO,
+            allowed_methods: Vec::new(),
+            expires_at: 0,
+            initial_deposit: 0,
+        }
+    }
+
+    pub fn with_allowed_methods(mut self, methods: Vec<AllowedMethod>, expires_at: u64) -> Self {
+        self.allowed_methods = methods;
+        self.expires_at = expires_at;
+        self
+    }
+
+    pub fn with_initial_deposit(mut self, initial_deposit: u64) -> Self {
+        self.initial_deposit = initial_deposit;
+        self
+    }
+
+    pub fn with_delegate_account(mut self, delegate: Felt) -> Self {
+        self.delegate = delegate;
+        self
+    }
+
+    pub fn build(self) -> Result<JsValue> {
+        let constructor_calldata = Self::create_constructor_calldata(self.owner);
+        let address = get_udc_deployed_address(
+            self.username,
+            ACCOUNT_CLASS_HASH,
+            &UdcUniqueness::NotUnique,
+            &constructor_calldata,
+        );
+        let session_signer = SigningKey::from_random();
+
+        let mut js_calls = vec![
+            Self::create_udc_deploy_call(self.username, &constructor_calldata),
+            Self::create_register_session_call(
+                address,
+                self.owner,
+                self.allowed_methods,
+                self.expires_at,
+                &session_signer,
+            )?,
+        ];
+
+        if self.initial_deposit > 0 {
+            js_calls.extend(Self::create_initial_deposit_calls(
+                address,
+                self.initial_deposit,
+            ));
+        }
+
+        if self.delegate != Felt::ZERO {
+            js_calls.push(Self::create_set_delegate_call(address, self.owner));
+        }
+
+        let deployment = JsDeployment {
+            address,
+            calls: js_calls,
+            session_key: session_signer.secret_scalar(),
+        };
+
+        Ok(to_value(&deployment)?)
+    }
+
+    fn create_constructor_calldata(owner: Felt) -> Vec<Felt> {
+        let mut calldata =
+            controller::Owner::cairo_serialize(&controller::Owner::Account(owner.into()));
+        calldata.extend(Option::<AbigenSigner>::cairo_serialize(&None));
+        calldata
+    }
+
+    fn create_register_session_call(
+        address: Felt,
+        owner: Felt,
+        methods: Vec<AllowedMethod>,
+        expires_at: u64,
+        session_signer: &SigningKey,
+    ) -> Result<JsCall> {
+        let session = Session::new(methods, expires_at, &session_signer.signer())?;
+
+        Ok(JsCall {
+            contract_address: address,
+            entrypoint: "register_session".to_string(),
+            calldata: [
+                <RawSession as CairoSerde>::cairo_serialize(&session.raw()),
+                vec![owner],
+            ]
+            .concat(),
+        })
+    }
+
+    fn create_udc_deploy_call(salt: Felt, constructor_calldata: &[Felt]) -> JsCall {
+        let mut calldata = vec![
+            ACCOUNT_CLASS_HASH,
+            salt,
+            Felt::ZERO, // unique false
+            Felt::from(constructor_calldata.len()),
+        ];
+        calldata.extend_from_slice(constructor_calldata);
+
+        JsCall {
+            contract_address: UDC_ADDRESS,
+            entrypoint: "deployContract".to_string(),
+            calldata,
+        }
+    }
+
+    fn create_set_delegate_call(address: Felt, delegate: Felt) -> JsCall {
+        JsCall {
+            contract_address: address,
+            entrypoint: "set_delegate_account".to_string(),
+            calldata: vec![delegate],
+        }
+    }
+
+    fn create_initial_deposit_calls(address: Felt, initial_deposit: u64) -> Vec<JsCall> {
+        vec![
+            JsCall {
+                contract_address: ETH_CONTRACT_ADDRESS,
+                entrypoint: "approve".to_string(),
+                calldata: vec![address, initial_deposit.into(), Felt::ZERO],
+            },
+            JsCall {
+                contract_address: ETH_CONTRACT_ADDRESS,
+                entrypoint: "transfer".to_string(),
+                calldata: vec![address, initial_deposit.into(), Felt::ZERO],
+            },
+        ]
+    }
+}
diff --git a/packages/account-wasm/src/lib.rs b/packages/account-wasm/src/lib.rs
index d125947d8..33dc7e9f8 100644
--- a/packages/account-wasm/src/lib.rs
+++ b/packages/account-wasm/src/lib.rs
@@ -1,3 +1,4 @@
+mod deployment;
 mod errors;
 mod signer;
 mod storage;
@@ -19,6 +20,7 @@ use account_sdk::signers::{HashSigner, Signer};
 use base64::engine::general_purpose;
 use base64::Engine;
 use coset::{CborSerializable, CoseKey};
+use deployment::JsDeploymentBuilder;
 use serde_wasm_bindgen::{from_value, to_value};
 use signer::BrowserBackend;
 use starknet::accounts::{Account, ConnectedAccount};
@@ -296,6 +298,28 @@ impl CartridgeAccount {
 
         Ok(JsFelt(res))
     }
+
+    #[wasm_bindgen(js_name = externalDeploymentCalls)]
+    pub fn external_deployment_calls(
+        owner: JsValue,
+        username: JsValue,
+        policies: Vec<JsPolicy>,
+        expires_at: u64,
+        initial_deposit: u64,
+    ) -> Result<JsValue> {
+        let owner = from_value(owner)?;
+        let username = from_value(username)?;
+        let methods = policies
+            .into_iter()
+            .map(TryFrom::try_from)
+            .collect::<std::result::Result<Vec<_>, _>>()?;
+
+        JsDeploymentBuilder::new(owner, username)
+            .with_allowed_methods(methods, expires_at)
+            .with_delegate_account(owner)
+            .with_initial_deposit(initial_deposit)
+            .build()
+    }
 }
 
 #[wasm_bindgen]
diff --git a/packages/account-wasm/src/types/call.rs b/packages/account-wasm/src/types/call.rs
index 87a2b39fa..18b9b1aa7 100644
--- a/packages/account-wasm/src/types/call.rs
+++ b/packages/account-wasm/src/types/call.rs
@@ -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,
+        }
+    }
+}
diff --git a/packages/account_sdk/build.rs b/packages/account_sdk/build.rs
index 9709b354d..1576341af 100644
--- a/packages/account_sdk/build.rs
+++ b/packages/account_sdk/build.rs
@@ -21,6 +21,9 @@ fn generate_class_hashes() {
         r#"use starknet::macros::felt;
 use starknet_crypto::Felt;
 
+pub const UDC_ADDRESS: Felt =
+    felt!("0x041a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf");
+    
 pub const ACCOUNT_CLASS_HASH: Felt =
     felt!("{controller_class_hash:#x}");
 
diff --git a/packages/account_sdk/src/constants.rs b/packages/account_sdk/src/constants.rs
index 648bae6f6..7c585bf60 100644
--- a/packages/account_sdk/src/constants.rs
+++ b/packages/account_sdk/src/constants.rs
@@ -1,6 +1,9 @@
 use starknet::macros::felt;
 use starknet_crypto::Felt;
 
+pub const UDC_ADDRESS: Felt =
+    felt!("0x041a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf");
+
 pub const ACCOUNT_CLASS_HASH: Felt =
     felt!("0x24a9edbfa7082accfceabf6a92d7160086f346d622f28741bf1c651c412c9ab");
 
@@ -9,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");
diff --git a/packages/keychain/src/components/Execute/index.tsx b/packages/keychain/src/components/Execute/index.tsx
index de86e2cde..250eee4f6 100644
--- a/packages/keychain/src/components/Execute/index.tsx
+++ b/packages/keychain/src/components/Execute/index.tsx
@@ -22,8 +22,7 @@ export const CONTRACT_ETH =
   "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7";
 
 export function Execute() {
-  const { controller, context, origin, paymaster, cancel } =
-    useConnection();
+  const { controller, context, origin, paymaster, cancel } = useConnection();
   const ctx = context as ExecuteCtx;
 
   const [maxFee, setMaxFee] = useState<bigint>(0n);
@@ -52,10 +51,7 @@ export function Execute() {
 
     const estimateFees = async () => {
       try {
-        const balance = await getEthBalance(
-          account,
-          controller.address,
-        );
+        const balance = await getEthBalance(account, controller.address);
         setEthBalance(balance);
 
         const maxFee = await calculateMaxFee(ctx, account, calls, balance);
@@ -73,7 +69,7 @@ export function Execute() {
 
   const getEthBalance = async (account, address) => {
     const res = await account.callContract({
-      contractAddress:CONTRACT_ETH,
+      contractAddress: CONTRACT_ETH,
       entrypoint: "balanceOf",
       calldata: [BigInt(address).toString()],
     });
@@ -207,7 +203,7 @@ export function Execute() {
         <Policies title="Transaction Details" policies={policies} />
       </Content>
 
-      <Footer>
+      <Footer hideTxSummary>
         {error ? (
           error.name === "TransferAmountExceedsBalance" ? (
             <ErrorAlert title={error.message} />
diff --git a/packages/keychain/src/components/Funding.tsx b/packages/keychain/src/components/Funding.tsx
index 056527f76..7f1adecfa 100644
--- a/packages/keychain/src/components/Funding.tsx
+++ b/packages/keychain/src/components/Funding.tsx
@@ -324,7 +324,11 @@ function useTokens() {
   const checkFunds = useCallback(async () => {
     setIsFetching(true);
 
-    const checked = await updateBalance(tokens, controller);
+    const checked = await updateBalance(
+      tokens,
+      controller.account.rpc,
+      controller.address,
+    );
     setTokens(checked);
 
     setIsFetching(false);
diff --git a/packages/keychain/src/components/Menu/index.tsx b/packages/keychain/src/components/Menu/index.tsx
index bd5815c68..ae614bde8 100644
--- a/packages/keychain/src/components/Menu/index.tsx
+++ b/packages/keychain/src/components/Menu/index.tsx
@@ -13,7 +13,7 @@ export function Menu({ onLogout }: { onLogout: () => void }) {
       description={<CopyAddress address={controller.address} />}
     >
       <Content h="350px"></Content>
-      <Footer>
+      <Footer hideTxSummary>
         <Button w="full" onClick={onLogout}>
           Log out
         </Button>
diff --git a/packages/keychain/src/components/SetDelegate.tsx b/packages/keychain/src/components/SetDelegate.tsx
index c0a511519..8675b81df 100644
--- a/packages/keychain/src/components/SetDelegate.tsx
+++ b/packages/keychain/src/components/SetDelegate.tsx
@@ -52,7 +52,7 @@ export function SetDelegate({
           </VStack>
         </VStack>
       </Content>
-      <Footer>
+      <Footer hideTxSummary>
         <Button
           colorScheme="colorful"
           w="full"
diff --git a/packages/keychain/src/components/SetExternalOwner.tsx b/packages/keychain/src/components/SetExternalOwner.tsx
index cb2c9bd1e..76ef03e7b 100644
--- a/packages/keychain/src/components/SetExternalOwner.tsx
+++ b/packages/keychain/src/components/SetExternalOwner.tsx
@@ -47,7 +47,7 @@ export function SetExternalOwner() {
           </VStack>
         </VStack>
       </Content>
-      <Footer>
+      <Footer hideTxSummary>
         <Button
           colorScheme="colorful"
           w="full"
diff --git a/packages/keychain/src/components/Settings/index.tsx b/packages/keychain/src/components/Settings/index.tsx
index a29252b4c..f465401d7 100644
--- a/packages/keychain/src/components/Settings/index.tsx
+++ b/packages/keychain/src/components/Settings/index.tsx
@@ -140,7 +140,7 @@ export function Settings({ onLogout }: { onLogout: () => void }) {
           </VStack>
         </VStack>
       </Content>
-      <Footer>
+      <Footer hideTxSummary>
         <Button w="full" onClick={onLogout}>
           Log out
         </Button>
diff --git a/packages/keychain/src/components/SignMessage.tsx b/packages/keychain/src/components/SignMessage.tsx
index c040893c5..88360e245 100644
--- a/packages/keychain/src/components/SignMessage.tsx
+++ b/packages/keychain/src/components/SignMessage.tsx
@@ -97,7 +97,7 @@ export function SignMessage({
         </Flex>
       </Content>
 
-      <Footer>
+      <Footer hideTxSummary>
         <Button colorScheme="colorful" onClick={onConfirm}>
           sign
         </Button>
diff --git a/packages/keychain/src/components/connect/Login.tsx b/packages/keychain/src/components/connect/Login.tsx
index 1e98d9b8a..def5b2336 100644
--- a/packages/keychain/src/components/connect/Login.tsx
+++ b/packages/keychain/src/components/connect/Login.tsx
@@ -13,7 +13,6 @@ import { ErrorAlert } from "components/ErrorAlert";
 
 export function Login(props: LoginProps) {
   const theme = useControllerTheme();
-  console.debug("login render");
 
   return (
     <Container
diff --git a/packages/keychain/src/components/connect/Signup/Argent.tsx b/packages/keychain/src/components/connect/Signup/Argent.tsx
new file mode 100644
index 000000000..9049e02b6
--- /dev/null
+++ b/packages/keychain/src/components/connect/Signup/Argent.tsx
@@ -0,0 +1,434 @@
+import { Container, Content, Footer } from "components/layout";
+import {
+  Button,
+  HStack,
+  Spinner,
+  useInterval,
+  VStack,
+  Text,
+  Spacer,
+  Box,
+  AlertIcon,
+  Tooltip,
+} from "@chakra-ui/react";
+import {
+  PropsWithChildren,
+  useCallback,
+  useEffect,
+  useMemo,
+  useState,
+} from "react";
+import { mainnet, sepolia } from "@starknet-react/chains";
+import {
+  Connector,
+  StarknetConfig,
+  useAccount,
+  useConnect,
+  useInjectedConnectors,
+  useProvider,
+  voyager,
+} from "@starknet-react/core";
+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,
+  getMinStr,
+  isEther,
+  isFunded,
+  updateBalance,
+} from "utils/token";
+import { ErrorAlert } from "../../ErrorAlert";
+import { beginAccountSignup, finalizeAccountSignup } from "hooks/account";
+import base64url from "base64url";
+import {
+  CartridgeAccount,
+  CartridgeSessionAccount,
+} from "@cartridge/account-wasm";
+
+enum SignupState {
+  CONNECT,
+  SIGN_MESSAGE,
+  DEPLOY,
+}
+
+const registerTypedData = (
+  username: string,
+  challenge: { low: string; high: string },
+  chainId: string,
+): TypedData => {
+  return {
+    types: {
+      StarkNetDomain: [
+        { name: "name", type: "felt" },
+        { name: "version", type: "felt" },
+        { name: "chainId", type: "felt" },
+        { name: "revision", type: "felt" },
+      ],
+      Register: [
+        { name: "username", type: "felt" },
+        { name: "challenge", type: "Challenge" },
+      ],
+      Challenge: [
+        { name: "low", type: "felt" },
+        { name: "high", type: "felt" },
+      ],
+    },
+    primaryType: "Register",
+    domain: {
+      name: "Cartridge",
+      chainId: chainId,
+      version: "1",
+      revision: "0",
+    },
+    message: {
+      username: username,
+      challenge: {
+        low: challenge.low,
+        high: challenge.high,
+      },
+    },
+  };
+};
+
+export function SignupArgent({ username }: { username: string }) {
+  return (
+    <ExternalWalletProvider>
+      <SignupArgentInner username={username} />
+    </ExternalWalletProvider>
+  );
+}
+
+function SignupArgentInner({ username }: { username: string }) {
+  const { account: extAccount } = useAccount();
+  const { connectAsync, connectors, isPending: isConnecting } = useConnect();
+  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 [title, setTitle] = useState("");
+
+  const { toast } = useToast();
+
+  const onConnect = useCallback(
+    (c: Connector) => {
+      connectAsync({ connector: c })
+        .then(async () => {
+          const connectedChain = await c.chainId();
+          if (num.toHex(connectedChain) !== chainId) {
+            c.disconnect();
+            toast("Please switch chain to: " + chainName);
+            return;
+          }
+          console.log("connecting!")
+          setState(SignupState.SIGN_MESSAGE);
+        })
+        .catch((e) => {
+          /* user abort */
+          console.log(e);
+        });
+    },
+    [connectAsync, chainId, chainName, toast],
+  );
+
+  const onSignMessage = useCallback(async () => {
+    if (!extAccount) return;
+    try {
+      const challenge = await beginAccountSignup(username);
+      const buffer = base64url.toBuffer(challenge);
+      const high = "0x" + buffer.subarray(0, 16).toString("hex");
+      const low = "0x" + buffer.subarray(16, 32).toString("hex");
+      const typedData = registerTypedData(username, { low, high }, chainId);
+      const sig = await extAccount.signMessage(typedData);
+      await finalizeAccountSignup(extAccount.address, chainId, sig as string[]);
+      setState(SignupState.DEPLOY);
+    } catch (e) {
+      console.log(e);
+      setError(e);
+    }
+  }, [extAccount, username, chainId]);
+
+  const onDeploy = useCallback(async () => {
+    if (!extAccount) return;
+
+    try {
+      setIsDeploying(true);
+
+      const {
+        address: controllerAddress,
+        calls: deploymentCalls,
+        sessionKey,
+      } = CartridgeAccount.externalDeploymentCalls(
+        extAccount.address,
+        shortString.encodeShortString(username),
+        policies.map((p) => {
+          return { target: p.target, method: p.method };
+        }),
+        3000000000n,
+        100000000000000000n,
+      );
+
+      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);
+    }
+  }, [extAccount, policies, tokens, username]);
+
+  // const onCopy = useCallback(() => {
+  //   navigator.clipboard.writeText(controllerAddress);
+  //   toast("Copied");
+  // }, [controllerAddress, toast]);
+
+  useEffect(() => {
+    switch (state) {
+      case SignupState.CONNECT: {
+        setTitle("Connect to ArgentX");
+        break;
+      }
+      case SignupState.SIGN_MESSAGE: {
+        setTitle("Sign Message");
+        break;
+      }
+      case SignupState.DEPLOY: {
+        setTitle(`Create ${username}.gg`);
+        break;
+      }
+    }
+  }, [state, username, setTitle]);
+
+  return (
+    <Container
+      variant="connect"
+      title={title}
+      description={
+        <>
+          {state === SignupState.CONNECT &&
+            "Please connect your ArgentX wallet"}
+          {state === SignupState.SIGN_MESSAGE &&
+            "Sign message to create your controller"}
+          {state === SignupState.DEPLOY && <></>}
+        </>
+      }
+      // TODO: Add line icons
+      icon={<PacmanIcon color="brand.primary" fontSize="5xl" />}
+    >
+      <Content gap={6}>
+        {state === SignupState.DEPLOY && (
+          <>
+            <HStack w="full">
+              <Text color="text.secondary" fontSize="sm">
+                Assets below will be send to your controller address.
+              </Text>
+              <Spacer />
+              {isFetching && <Spinner size="xs" color="text.secondary" />}
+            </HStack>
+
+            <VStack w="full" borderRadius="base" overflow="hidden" gap={0.25}>
+              {tokens.map((t) => (
+                <HStack
+                  key={t.address}
+                  w="full"
+                  align="center"
+                  fontSize="sm"
+                  p={3}
+                  bg="solid.primary"
+                  fontWeight="semibold"
+                >
+                  <HStack>
+                    <HStack>
+                      {t.logo}
+                      <Text>{t.balance}</Text>
+                      {typeof t.balance === "bigint" ? (
+                        <Text>{getBalanceStr(t)}</Text>
+                      ) : !!t.error ? (
+                        // <Text>...</Text>
+                        <DotsIcon />
+                      ) : (
+                        <Spinner size="xs" />
+                      )}
+                      <Text>{t.symbol}</Text>
+                    </HStack>
+                    {isFunded(t) && <CheckIcon color="text.success" />}
+                    {!!t.error && (
+                      <Tooltip
+                        label={t.error.message}
+                        fontSize="xs"
+                        bg="solid.bg"
+                        color="text.primary"
+                      >
+                        <Box>
+                          <AlertIcon color="text.error" />
+                        </Box>
+                      </Tooltip>
+                    )}
+                  </HStack>
+
+                  <Spacer />
+
+                  <HStack gap={isEther(t) ? 2 : 3} color="text.secondary">
+                    <Text color="inherit">send:</Text>
+                    <HStack gap={isEther(t) ? 0 : 1}>
+                      {t.logo}
+                      <Text color="inherit">{getMinStr(t)}</Text>
+                    </HStack>
+                  </HStack>
+                </HStack>
+              ))}
+            </VStack>
+          </>
+        )}
+      </Content>
+
+      <Footer isSignup={!extAccount}>
+        {error && (
+          <ErrorAlert
+            title="Account deployment error"
+            description={error.message}
+          />
+        )}
+        {!isChecked ? (
+          <Button colorScheme="colorful" isLoading />
+        ) : (
+          <>
+            {state === SignupState.CONNECT && (
+              <>
+                {connectors.length ? (
+                  connectors
+                    .filter((c) => ["argentX"].includes(c.id))
+                    .map((c) => (
+                      <Button
+                        key={c.id}
+                        colorScheme="colorful"
+                        onClick={() => onConnect(c)}
+                        isLoading={isConnecting}
+                      >
+                        Connect {c.name}
+                      </Button>
+                    ))
+                ) : (
+                  <Button
+                    colorScheme="colorful"
+                    onClick={() => {
+                      console.log("copy address");
+                    }}
+                  >
+                    copy address
+                  </Button>
+                )}
+              </>
+            )}
+
+            {state === SignupState.SIGN_MESSAGE && (
+              <Button colorScheme="colorful" onClick={onSignMessage}>
+                Sign Message
+              </Button>
+            )}
+
+            {state === SignupState.DEPLOY && (
+              <Button
+                colorScheme="colorful"
+                onClick={() => {
+                  onDeploy();
+                }}
+                isLoading={isDeploying}
+                isDisabled={!(isAllFunded && isChecked && extAccount)}
+              >
+                Create & Play
+              </Button>
+            )}
+          </>
+        )}
+      </Footer>
+    </Container>
+  );
+}
+
+function ExternalWalletProvider({ children }: PropsWithChildren) {
+  const { connectors } = useInjectedConnectors({});
+  const { rpcUrl } = useConnection();
+
+  return (
+    <StarknetConfig
+      chains={[sepolia, mainnet]}
+      provider={() => new RpcProvider({ nodeUrl: rpcUrl })}
+      connectors={connectors}
+      explorer={voyager}
+    >
+      {children}
+    </StarknetConfig>
+  );
+}
+
+function useTokens() {
+  const { account: extAccount } = useAccount();
+  const { provider } = useProvider();
+  const { prefunds } = useConnection();
+  const [tokens, setTokens] = useState<TokenInfo[]>([]);
+  const [isChecked, setIsChecked] = useState(false);
+  const [isFetching, setIsFetching] = useState(true);
+
+  const remaining = useMemo(() => tokens.filter((t) => !isFunded(t)), [tokens]);
+
+  useEffect(() => {
+    fetchTokenInfo(prefunds).then(setTokens);
+  }, [prefunds, extAccount?.address]);
+
+  const checkFunds = useCallback(async () => {
+    setIsFetching(true);
+
+    const checked = await updateBalance(tokens, provider, extAccount?.address);
+    setTokens(checked);
+
+    setIsFetching(false);
+    if (!isChecked) {
+      setIsChecked(true);
+    }
+  }, [tokens, isChecked, extAccount?.address, provider]);
+
+  useInterval(checkFunds, 3000);
+
+  return {
+    tokens,
+    remaining,
+    isAllFunded: remaining.length === 0,
+    isChecked,
+    isFetching,
+  };
+}
diff --git a/packages/keychain/src/components/connect/Signup.tsx b/packages/keychain/src/components/connect/Signup/index.tsx
similarity index 78%
rename from packages/keychain/src/components/connect/Signup.tsx
rename to packages/keychain/src/components/connect/Signup/index.tsx
index 58b8f42be..b4fe58abb 100644
--- a/packages/keychain/src/components/connect/Signup.tsx
+++ b/packages/keychain/src/components/connect/Signup/index.tsx
@@ -1,5 +1,5 @@
-import { Field } from "@cartridge/ui";
-import { Button } from "@chakra-ui/react";
+import { ArgentIcon, Field } from "@cartridge/ui";
+import { Button, HStack } from "@chakra-ui/react";
 import { Container, Footer, Content } from "components/layout";
 import { useCallback, useEffect, useState } from "react";
 import {
@@ -8,14 +8,21 @@ import {
 } from "generated/graphql";
 import Controller from "utils/controller";
 import { PopupCenter } from "utils/url";
-import { SignupProps } from "./types";
-import { validateUsernameFor } from "./utils";
-import { RegistrationLink } from "./RegistrationLink";
+import { SignupProps } from "../types";
+import { validateUsernameFor } from "../utils";
+import { RegistrationLink } from "../RegistrationLink";
 import { doSignup } from "hooks/account";
 import { useControllerTheme } from "hooks/theme";
 import { useConnection } from "hooks/connection";
 import { ErrorAlert } from "components/ErrorAlert";
 import { useDebounce } from "hooks/debounce";
+import { SignupArgent } from "./Argent";
+
+enum SignupMethod {
+  WEBAUTHN,
+  ARGENT,
+  SOCIAL,
+}
 
 export function Signup({
   prefilledName = "",
@@ -33,6 +40,9 @@ export function Signup({
     error: undefined,
   });
   const [isValidating, setIsValidating] = useState(false);
+  const [signupMethod, setSignupMethod] = useState<SignupMethod>(
+    SignupMethod.WEBAUTHN,
+  );
 
   const { origin } = useConnection();
   const { debouncedValue: username, debouncing } = useDebounce(
@@ -40,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(() => {
@@ -66,9 +74,9 @@ export function Signup({
   const initController = useCallback(
     async (
       username: string,
-      address: string,
-      credentialId: string,
-      publicKey: string,
+      address?: string,
+      credentialId?: string,
+      publicKey?: string,
     ) => {
       const controller = new Controller({
         appId: origin,
@@ -173,6 +181,10 @@ export function Signup({
     },
   );
 
+  if (signupMethod === SignupMethod.ARGENT) {
+    return <SignupArgent username={usernameField.value} />;
+  }
+
   return (
     <Container
       variant="connect"
@@ -215,16 +227,36 @@ export function Signup({
             <ErrorAlert title="Login failed" description={error.message} />
           )}
 
-          <Button
-            colorScheme="colorful"
-            isLoading={isRegistering}
-            isDisabled={
-              debouncing || !username || isValidating || !!usernameField.error
-            }
-            onClick={onSubmit}
-          >
-            sign up
-          </Button>
+          <HStack>
+            <Button
+              w="100%"
+              colorScheme="colorful"
+              isLoading={isRegistering}
+              isDisabled={
+                debouncing || !username || isValidating || !!usernameField.error
+              }
+              onClick={onSubmit}
+            >
+              sign up
+            </Button>
+            {typeof window !== "undefined" &&
+              window["starknet_argentX"] &&
+              window.document.cookie.includes("argent") && (
+                <Button
+                  colorScheme="colorful"
+                  isLoading={isRegistering}
+                  isDisabled={
+                    debouncing ||
+                    !username ||
+                    isValidating ||
+                    !!usernameField.error
+                  }
+                  onClick={() => setSignupMethod(SignupMethod.ARGENT)}
+                >
+                  <ArgentIcon />
+                </Button>
+              )}
+          </HStack>
           <RegistrationLink
             description="Already have a Controller?"
             onClick={() => onLogin(usernameField.value)}
diff --git a/packages/keychain/src/components/layout/Container/Header/Banner.tsx b/packages/keychain/src/components/layout/Container/Header/Banner.tsx
index 51fd17ec0..872e2d803 100644
--- a/packages/keychain/src/components/layout/Container/Header/Banner.tsx
+++ b/packages/keychain/src/components/layout/Container/Header/Banner.tsx
@@ -9,6 +9,7 @@ import {
   useColorMode,
   Square,
   HStack,
+  Box,
 } from "@chakra-ui/react";
 import { useControllerTheme } from "hooks/theme";
 import { useMemo } from "react";
@@ -85,11 +86,16 @@ export function Banner({ Icon, icon, title, description }: BannerProps) {
               {title}
             </Text>
 
-            {description && (
+            {description && typeof description === "string" && (
               <Text fontSize="sm" color="text.secondary" align="center">
                 {description}
               </Text>
             )}
+            {description && typeof description !== "string" && (
+              <Box fontSize="sm" color="text.secondary" alignItems="center">
+                {description}
+              </Box>
+            )}
           </VStack>
         </VStack>
       );
@@ -133,7 +139,7 @@ export function Banner({ Icon, icon, title, description }: BannerProps) {
                 {title}
               </Text>
 
-              {description && (
+              {description && typeof description === "string" && (
                 <Text
                   w="full"
                   fontSize="xs"
@@ -143,6 +149,16 @@ export function Banner({ Icon, icon, title, description }: BannerProps) {
                   {description}
                 </Text>
               )}
+              {description && typeof description !== "string" && (
+                <Box
+                  w="full"
+                  fontSize="xs"
+                  color="text.secondary"
+                  overflowWrap="break-word"
+                >
+                  {description}
+                </Box>
+              )}
             </VStack>
           </HStack>
         </VStack>
@@ -187,7 +203,7 @@ export function Banner({ Icon, icon, title, description }: BannerProps) {
                 {title}
               </Text>
 
-              {description && (
+              {description && typeof description === "string" && (
                 <Text
                   w="full"
                   fontSize="xs"
@@ -197,6 +213,16 @@ export function Banner({ Icon, icon, title, description }: BannerProps) {
                   {description}
                 </Text>
               )}
+              {description && typeof description !== "string" && (
+                <Box
+                  w="full"
+                  fontSize="xs"
+                  color="text.secondary"
+                  overflowWrap="break-word"
+                >
+                  {description}
+                </Box>
+              )}
             </VStack>
           </HStack>
         </VStack>
diff --git a/packages/keychain/src/components/layout/Footer/index.tsx b/packages/keychain/src/components/layout/Footer/index.tsx
index 28489ebc1..536ca02b1 100644
--- a/packages/keychain/src/components/layout/Footer/index.tsx
+++ b/packages/keychain/src/components/layout/Footer/index.tsx
@@ -36,8 +36,9 @@ export function Footer({
       !hideTxSummary,
     [origin, policies, variant, isSignup, hideTxSummary],
   );
+
   const maxH = `${
-    (isIframe() ? window.innerHeight : PORTAL_WINDOW_HEIGHT) - TOP_BAR_HEIGHT
+    (isIframe() ? PORTAL_WINDOW_HEIGHT : window.innerHeight) - TOP_BAR_HEIGHT
   }px`;
 
   useEffect(() => {
diff --git a/packages/keychain/src/hooks/account.ts b/packages/keychain/src/hooks/account.ts
index 910ed20af..54c73f125 100644
--- a/packages/keychain/src/hooks/account.ts
+++ b/packages/keychain/src/hooks/account.ts
@@ -18,6 +18,13 @@ type RawAttestation = PublicKeyCredential & {
   response: AuthenticatorAttestationResponse;
 };
 
+type SignedMessage = {
+  type: string;
+  account: string;
+  chain_id: string;
+  signature: string[];
+};
+
 type Credentials = RawAttestation & {
   getPublicKey(): ArrayBuffer | null;
 };
@@ -58,7 +65,7 @@ export const onCreateBegin = async (name: string): Promise<Credentials> => {
     data.beginRegistration,
     hasPlatformAuthenticator,
   );
-
+  console.log({ credentials });
   return credentials;
 };
 
@@ -149,6 +156,27 @@ export const doXHR = async (json: string): Promise<any> => {
   });
 };
 
+export async function beginAccountSignup(username: string): Promise<string> {
+  const { data } = await beginRegistration(username);
+  return data.beginRegistration.publicKey.challenge;
+}
+
+export async function finalizeAccountSignup(
+  address: string,
+  chain_id: string,
+  signature: string[],
+): Promise<FinalizeRegistrationMutation> {
+  const signedMessage: SignedMessage = {
+    type: "starknet_account",
+    account: address,
+    chain_id,
+    signature,
+  };
+  return client.request(FinalizeRegistrationDocument, {
+    credentials: JSON.stringify(signedMessage),
+  });
+}
+
 export async function doSignup(
   name: string,
 ): Promise<FinalizeRegistrationMutation> {
diff --git a/packages/keychain/src/pages/index.tsx b/packages/keychain/src/pages/index.tsx
index a632f0087..7bbd384a7 100644
--- a/packages/keychain/src/pages/index.tsx
+++ b/packages/keychain/src/pages/index.tsx
@@ -35,9 +35,6 @@ function Home() {
   if (!controller) {
     return <CreateController loginMode={LoginMode.Controller} />;
   }
-
-  console.debug({ context_type: context.type });
-
   switch (context.type) {
     case "connect": {
       // TODO: show missing policies if mismatch
diff --git a/packages/keychain/src/utils/controller.ts b/packages/keychain/src/utils/controller.ts
index 28aaf43d7..655e7d819 100644
--- a/packages/keychain/src/utils/controller.ts
+++ b/packages/keychain/src/utils/controller.ts
@@ -18,14 +18,14 @@ import { JsPolicy } from "@cartridge/account-wasm";
 
 type SerializedController = {
   publicKey: string;
-  credentialId: string;
+  credentialId?: string;
   address: string;
   username: string;
 };
 
 export default class Controller {
   public account: Account;
-  public address: string;
+  public address?: string;
   public username: string;
   public chainId: string;
   public rpcUrl: string;
@@ -45,10 +45,10 @@ export default class Controller {
     appId: string;
     chainId: string;
     rpcUrl: string;
-    address: string;
-    username: string;
+    address?: string;
+    username?: string;
     publicKey: string;
-    credentialId: string;
+    credentialId?: string;
   }) {
     this.address = address;
     this.username = username;
diff --git a/packages/keychain/src/utils/token.tsx b/packages/keychain/src/utils/token.tsx
index 16bae2109..e3f19654d 100644
--- a/packages/keychain/src/utils/token.tsx
+++ b/packages/keychain/src/utils/token.tsx
@@ -3,8 +3,7 @@ import { EthereumIcon } from "@cartridge/ui";
 import { Image } from "@chakra-ui/react";
 import { formatEther } from "viem";
 import { formatAddress } from "./contracts";
-import { uint256 } from "starknet";
-import Controller from "./controller";
+import { ProviderInterface, uint256 } from "starknet";
 
 export const ETH_CONTRACT_ADDRESS =
   "0x49d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7";
@@ -50,11 +49,13 @@ export async function fetchTokenInfo(prefunds: Prefund[]) {
     }
 
     const info = data.find(
-      ({ l2_token_address }) => l2_token_address === formatAddress(t.address),
+      ({ l2_token_address }) => BigInt(l2_token_address) === BigInt(t.address),
     );
 
     if (!info) {
-      throw new Error(`Cannot find token info for: ${t.address}`);
+      throw new Error(
+        `Cannot find token info for: ${formatAddress(t.address)}`,
+      );
     }
 
     return {
@@ -77,26 +78,33 @@ export async function fetchTokenInfo(prefunds: Prefund[]) {
 
 export async function updateBalance(
   tokens: TokenInfo[],
-  controller: Controller,
+  provider: ProviderInterface,
+  address: string,
 ) {
+  if (!provider) return tokens;
+
   const res = await Promise.allSettled(
     tokens.map(async (t) => {
       try {
-        const balance = await controller.account.callContract({
+        let balance = await provider.callContract({
           contractAddress: t.address,
           entrypoint: "balanceOf",
-          calldata: [controller.account.address],
+          calldata: [address],
         });
 
+        /* @ts-ignore */
+        balance = "result" in balance ? balance["result"] : balance;
+
+        const balanceBn = uint256.uint256ToBN({
+          low: balance[0],
+          high: balance[1],
+        });
         return {
           ...t,
-          balance: uint256.uint256ToBN({
-            low: balance[0],
-            high: balance[1],
-          }),
+          balance: balanceBn,
           error: undefined,
         };
-      } catch {
+      } catch (e) {
         return {
           ...t,
           error: new Error("Failed to update balance"),