rise-wallet 0.3.3 → 0.3.5

package/src/core/Dialog.ts

@@ -224,6 +224,26 @@ export function iframe(options: iframe.Options = {}) {
         }
       })
 
+      // Safari ITP workaround: When accounts are set in the parent's store
+      // (after wallet_connect via popup), sync them to the iframe via postMessage.
+      // This is necessary because Safari's ITP partitions storage between windows
+      // opened from different origins, preventing the iframe from reading accounts
+      // stored by the popup even though they share the same origin.
+      if (UserAgent.isSafari()) {
+        internal.store.subscribe(
+          (state) => state.accounts,
+          (accounts, prevAccounts) => {
+            // Only sync when accounts are added (not when cleared)
+            if (accounts.length > 0 && prevAccounts.length === 0) {
+              messenger.send('__internal', {
+                accounts,
+                type: 'sync-accounts',
+              })
+            }
+          },
+        )
+      }
+
       let bodyStyle: CSSStyleDeclaration | null = null
 
       // store the opening element to restore the focus
@@ -988,16 +1008,21 @@ export function requiresConfirmation(
   const { methodPolicies, targetOrigin } = options
   const policy = methodPolicies?.find((x) => x.method === request.method)
   if (!policy) return true
-  if (policy.modes?.headless) {
+  if (policy.modes && typeof policy.modes.headless === 'object') {
+    if (
+      policy.modes.headless.sameOrigin &&
+      targetOrigin === window.location.origin
+    )
+      return false
     if (
-      typeof policy.modes.headless === 'object' &&
-      ((policy.modes.headless.sameOrigin &&
-        targetOrigin === window.location.origin) ||
-        policy.modes.headless.privilegedOrigins?.some((origin) =>
-          window.location.origin.endsWith(origin),
-        ))
+      policy.modes.headless.privilegedOrigins?.some((origin) =>
+        window.location.origin.endsWith(origin),
+      )
     )
       return false
+    return true
+  }
+  if (policy.modes?.headless !== undefined) {
     return false
   }
   return true

package/src/core/Messenger.ts

@@ -118,6 +118,11 @@ export type Schema = [
           type: 'dialog-lifecycle'
           action: 'request:close' | 'done:close'
         }
+      | {
+          // Sync accounts from popup to iframe (Safari ITP workaround)
+          type: 'sync-accounts'
+          accounts: Porto.State['accounts']
+        }
     response: undefined
   },
 ]
@@ -176,10 +181,8 @@ export function fromWindow(
     },
     async send(topic, payload, target) {
       const id = Utils.uuidv4()
-      w.postMessage(
-        Utils.normalizeValue({ id, payload, topic }),
-        target ?? targetOrigin ?? '*',
-      )
+      const normalizedPayload = Utils.normalizeValue({ id, payload, topic })
+      w.postMessage(normalizedPayload, target ?? targetOrigin ?? '*')
       return { id, payload, topic } as never
     },
     async sendAsync(topic, payload, target) {
@@ -210,13 +213,15 @@ export function bridge(parameters: bridge.Parameters): Bridge {
   let pending = false
 
   const ready = promise.withResolvers<ReadyOptions>()
+  // Prevent unhandled rejection if ready is rejected during destroy
+  ready.promise.catch(() => {})
   from_.on('ready', ready.resolve)
 
   const messenger = from({
     destroy() {
       from_.destroy()
       to.destroy()
-      if (pending) ready.reject()
+      if (pending) ready.reject(new Error('Messenger destroyed'))
     },
     on(topic, listener, id) {
       return from_.on(topic, listener, id)

package/src/core/internal/modes/dialog.ts

@@ -975,7 +975,7 @@ export function dialog(parameters: dialog.Parameters = {}) {
           const requests = requestQueue
             .map((x) => (x.status === 'pending' ? x : undefined))
             .filter(Boolean) as readonly QueuedRequest[]
-          dialog.syncRequests(requests).catch(() => {})
+          if (requests.length > 0) dialog.syncRequests(requests).catch(() => {})
           if (requests.length === 0) dialog.close()
         },
       )

package/src/core/internal/modes/relay.ts

@@ -15,6 +15,7 @@ import * as ContractActions from '../../../viem/ContractActions.js'
 import * as RelayActions_internal from '../../../viem/internal/relayActions.js'
 import * as Key from '../../../viem/Key.js'
 import * as RelayActions from '../../../viem/RelayActions.js'
+import { localStorage } from '../../Storage.js'
 import * as Erc8010 from '../erc8010.js'
 import * as Mode from '../mode.js'
 import * as PermissionsRequest from '../permissionsRequest.js'
@@ -548,6 +549,7 @@ export function relay(parameters: relay.Parameters = {}) {
           return await Key.sign(adminKey, {
             address: account.address,
             payload: digest,
+            storage: localStorage(),
           })
         })()
 
@@ -563,6 +565,7 @@ export function relay(parameters: relay.Parameters = {}) {
             address: null,
             payload: digest,
             typedData,
+            verificationOptional: true,
           })
           await RelayActions.sendPreparedCalls(client, {
             context,

package/src/remote/Events.ts

@@ -86,17 +86,16 @@ export function onDialogRequest(
         if (!request) return false
 
         const rule = policy?.modes?.headless
-        if (rule) {
-          if (
-            typeof rule === 'object' &&
-            ((rule.sameOrigin && event.origin === window.location.origin) ||
-              rule.privilegedOrigins?.some((origin) =>
-                event.origin.endsWith(origin),
-              ))
-          ) {
-            return true
-          }
-          return true
+        if (typeof rule === 'object') {
+          return (
+            (rule.sameOrigin && event.origin === window.location.origin) ||
+            rule.privilegedOrigins?.some((origin) =>
+              event.origin.endsWith(origin),
+            )
+          )
+        }
+        if (rule !== undefined) {
+          return rule
         }
 
         return false