Major refactoring and compatibility with dynamic bundle

[nulllpc]

No description provided.

[alexszolowicz-blockether]

I don't know what has been changed in this MR, but would be nice to have:

1. multiple networks support (not only evm)
2. initializeFromMnemonic does not update "state.activeWalletId" on main branch
3. I had problems with setSecureStorage race condition
4. autoStartWorklet as a boolean (so start when needed/invoked)

my adapters:

export interface WdkAppContextValue extends UpstreamWdkAppContextValue {
  /** Start worklet manually. Idempotent (safe to call multiple times), fire-and-forget. */
  startWorklet: () => void
}

export interface WdkAppProviderProps
  extends Omit<UpstreamWdkAppProviderProps, 'networkConfigs'> {
  networkConfigs: NetworkConfigs
  autoStartWorklet?: boolean
}

const WdkAppContext = createContext<WdkAppContextValue | null>(null)

function WdkAppContextBridge({
  networkConfigs,
  autoStartWorklet,
  children,
}: {
  networkConfigs: NetworkConfigs
  autoStartWorklet: boolean
  children: React.ReactNode
}) {
  const upstreamContext = useUpstreamWdkApp()
  const { isLoading: isWorkletLoading, isWorkletStarted } = useWorklet()

  const startWorklet = useCallback(() => {
    if (isWorkletLoading || isWorkletStarted) return
    WorkletLifecycleService.startWorklet(
      networkConfigs as unknown as UpstreamNetworkConfigs
    ).catch(console.error)
  }, [networkConfigs, isWorkletLoading, isWorkletStarted])

  useEffect(() => {
    if (!autoStartWorklet) return
    if (isWorkletLoading || isWorkletStarted) return
    WorkletLifecycleService.startWorklet(
      networkConfigs as unknown as UpstreamNetworkConfigs
    ).catch(console.error)
  }, [autoStartWorklet, isWorkletLoading, isWorkletStarted, networkConfigs])

  const contextValue: WdkAppContextValue = useMemo(
    () => ({
      ...upstreamContext,
      startWorklet,
    }),
    [upstreamContext, startWorklet]
  )

  return (
    <WdkAppContext.Provider value={contextValue}>
      {children}
    </WdkAppContext.Provider>
  )
}

export function WdkAppProvider({
  autoStartWorklet = false,
  children,
  ...upstreamProps
}: WdkAppProviderProps) {
  // CRITICAL: Set secure storage synchronously before any children mount
  // This prevents "SecureStorage not initialized" race condition
  useMemo(() => {
    const storage = createSecureStorage()
    WalletSetupService.setSecureStorage(storage)
    return storage
  }, [])

  return (
    <UpstreamWdkAppProvider
      {...upstreamProps}
      networkConfigs={
        upstreamProps.networkConfigs as unknown as UpstreamNetworkConfigs
      }
    >
      <WdkAppContextBridge
        networkConfigs={upstreamProps.networkConfigs}
        autoStartWorklet={autoStartWorklet}
      >
        {children}
      </WdkAppContextBridge>
    </UpstreamWdkAppProvider>
  )
}

export function useWdkApp(): WdkAppContextValue {
  const context = useContext(WdkAppContext)
  if (!context) {
    throw new Error('useWdkApp must be used within WdkAppProvider')
  }
  return context
}

export { WdkAppContext }

export function useWalletManager(
  walletId?: string,
  networkConfigs?: Parameters<typeof useUpstreamWalletManager>[1]
): UseWalletManagerResult {
  const upstream = useUpstreamWalletManager(walletId, networkConfigs)
  const walletStore = getWalletStore()

  const initializeFromMnemonic = useCallback(
    async (mnemonic: string, walletIdParam?: string) => {
      const targetWalletId = walletIdParam ?? walletId ?? 'default'

      await upstream.initializeFromMnemonic(mnemonic, walletIdParam)

      walletStore.setState(prev =>
        produce(prev, (state: WalletStoreState) => {
          const existingIndex = state.walletList.findIndex(
            w => w.identifier === targetWalletId
          )

          if (existingIndex >= 0) {
            state.walletList[existingIndex] = {
              identifier: targetWalletId,
              exists: true,
              isActive: true,
            }
          } else {
            state.walletList.push({
              identifier: targetWalletId,
              exists: true,
              isActive: true,
            })
          }

          for (const wallet of state.walletList) {
            if (wallet.identifier !== targetWalletId) {
              wallet.isActive = false
            }
          }

          state.activeWalletId = targetWalletId
        })
      )
    },
    [upstream.initializeFromMnemonic, walletId, walletStore]
  )

  return useMemo(
    () => ({
      ...upstream,
      initializeFromMnemonic,
    }),
    [upstream, initializeFromMnemonic]
  )
}

export type { UseWalletManagerResult }

[alexszolowicz-blockether]

btw please also take note on balance fetching, because right now N tokens = N rpc requests.

You can use ext-provider-multicall on evm and findAssociatedTokenPda + getMultipleAccounts on solana

my implementation

/**
   * @param {string[]} tokenAddresses
   * @returns {Promise<Record<string, bigint>>}
   */
  async getTokenBalances(tokenAddresses) {
    if (!this._provider) {
      throw new Error(
        'The wallet must be connected to a provider to retrieve token balances.'
      )
    }

    const address = await this.getAddress()
    const abi = ['function balanceOf(address owner) view returns (uint256)']

    const multicallProvider = new MulticallProvider(this._provider)

    const balances = await Promise.all(
      tokenAddresses.map(async tokenAddress => {
        const contract = new Contract(tokenAddress, abi, multicallProvider)
        return contract.balanceOf(address)
      })
    )

    return tokenAddresses.reduce((acc, tokenAddress, index) => {
      acc[tokenAddress] = balances[index]
      return acc
    }, {})
  }

  /**
   * Returns the account balances for a list of SPL tokens.
   *
   * @param {string[]} tokenAddresses - The smart contract addresses of the tokens.
   * @returns {Promise<Record<string, bigint>>} The token balances (in base unit).
   */
  async getTokenBalances(tokenAddresses) {
    if (!this._rpc) {
      throw new Error(
        'The wallet must be connected to a provider to retrieve token balances.'
      )
    }

    const addr = await this.getAddress()
    const ownerAddress = address(addr)

    // Deduplicate token addresses
    const uniqueTokenAddresses = [...new Set(tokenAddresses)]
    const mints = uniqueTokenAddresses.map(t => address(t))

    // Calculate ATAs
    const atas = await Promise.all(
      mints.map(mint =>
        findAssociatedTokenPda({
          mint,
          owner: ownerAddress,
          tokenProgram: TOKEN_PROGRAM_ADDRESS,
        }).then(([ata]) => ata)
      )
    )

    // Fetch accounts
    const { value: accounts } = await this._rpc
      .getMultipleAccounts(atas, {
        commitment: this._commitment,
        encoding: 'base64',
      })
      .send()

    const balances = {}
    const base64Encoder = getBase64Encoder()

    for (let i = 0; i < uniqueTokenAddresses.length; i++) {
      const tokenAddress = uniqueTokenAddresses[i]
      const account = accounts[i]

      if (!account) {
        balances[tokenAddress] = 0n
        continue
      }

      // Parse amount from account data
      // Account data is [base64_string, 'base64']
      const dataBase64 = account.data[0]
      const bytes = base64Encoder.encode(dataBase64)

      // Amount is at offset 64, 8 bytes, little endian
      const view = new DataView(
        bytes.buffer,
        bytes.byteOffset,
        bytes.byteLength
      )
      const amount = view.getBigUint64(64, true)
      balances[tokenAddress] = amount
    }

    return balances
  }

[alexszolowicz-blockether]

please update AddressService getAddress check, because now it supports only ERC-20 addresses

[alexszolowicz-blockether]

please allow caip-2 specification

e.g. eip155:1 or eip155:ethereum