@lifi/sdk 3.8.11 → 3.9.0-beta.0

package/src/core/EVM/EVM.ts

@@ -2,8 +2,8 @@ import { ChainType } from '@lifi/types'
 import { isAddress } from 'viem'
 import type { StepExecutorOptions } from '../types.js'
 import { EVMStepExecutor } from './EVMStepExecutor.js'
-import { getENSAddress } from './getENSAddress.js'
 import { getEVMBalance } from './getEVMBalance.js'
+import { resolveEVMAddress } from './resolveEVMAddress.js'
 import type { EVMProvider, EVMProviderOptions } from './types.js'
 
 export function EVM(options?: EVMProviderOptions): EVMProvider {
@@ -16,7 +16,7 @@ export function EVM(options?: EVMProviderOptions): EVMProvider {
       return _options
     },
     isAddress,
-    resolveAddress: getENSAddress,
+    resolveAddress: resolveEVMAddress,
     getBalance: getEVMBalance,
     getWalletClient: _options.getWalletClient,
     async getStepExecutor(

package/src/core/EVM/publicClient.ts

@@ -1,10 +1,11 @@
 import { ChainId, ChainType } from '@lifi/types'
 import type { Client } from 'viem'
-import { createClient, fallback, http, webSocket } from 'viem'
+import { type Address, createClient, fallback, http, webSocket } from 'viem'
 import { type Chain, mainnet } from 'viem/chains'
 import { config } from '../../config.js'
 import { getRpcUrls } from '../rpc.js'
 import type { EVMProvider } from './types.js'
+import { UNS_PROXY_READER_ADDRESSES } from './uns/constants.js'
 
 // cached providers
 const publicClients: Record<number, Client> = {}
@@ -46,6 +47,17 @@ export const getPublicClient = async (chainId: number): Promise<Client> => {
       ...chain.contracts,
     }
   }
+
+  // Add UNS contracts for supported chains
+  if (chain.id === ChainId.ETH || chain.id === ChainId.POL) {
+    const unsProxyAddress = UNS_PROXY_READER_ADDRESSES[chain.id]
+
+    chain.contracts = {
+      ...chain.contracts,
+      unsProxyReader: { address: unsProxyAddress as Address },
+    }
+  }
+
   const provider = config.getProvider(ChainType.EVM) as EVMProvider | undefined
   publicClients[chainId] = createClient({
     chain: chain,

package/src/core/EVM/{getENSAddress.ts → resolveENSAddress.ts}

@@ -2,7 +2,7 @@ import { ChainId } from '@lifi/types'
 import { getEnsAddress, normalize } from 'viem/ens'
 import { getPublicClient } from './publicClient.js'
 
-export const getENSAddress = async (
+export const resolveENSAddress = async (
   name: string
 ): Promise<string | undefined> => {
   try {

package/src/core/EVM/resolveEVMAddress.ts

@@ -0,0 +1,15 @@
+import type { ChainId, CoinKey } from '@lifi/types'
+import { ChainType } from '@lifi/types'
+import { resolveENSAddress } from './resolveENSAddress.js'
+import { resolveUNSAddress } from './uns/resolveUNSAddress.js'
+
+export async function resolveEVMAddress(
+  name: string,
+  chainId?: ChainId,
+  token?: CoinKey
+): Promise<string | undefined> {
+  return (
+    (await resolveENSAddress(name)) ||
+    (await resolveUNSAddress(name, ChainType.EVM, chainId, token))
+  )
+}

package/src/core/EVM/uns/constants.ts

@@ -0,0 +1,81 @@
+import { ChainId, ChainType } from '@lifi/types'
+import type { Address } from 'viem'
+
+export const UNS_PROXY_READER_ADDRESSES: Record<number, Address> = {
+  [ChainId.ETH]: '0x578853aa776Eef10CeE6c4dd2B5862bdcE767A8B',
+  [ChainId.POL]: '0x91EDd8708062bd4233f4Dd0FCE15A7cb4d500091',
+} as const
+
+export const getUNSProxyAddress = (chainId: number): Address | undefined =>
+  UNS_PROXY_READER_ADDRESSES[chainId]
+
+export const UNSProxyReaderABI = [
+  {
+    constant: true,
+    inputs: [
+      {
+        internalType: 'string[]',
+        name: 'keys',
+        type: 'string[]',
+      },
+      {
+        internalType: 'uint256',
+        name: 'tokenId',
+        type: 'uint256',
+      },
+    ],
+    name: 'getData',
+    outputs: [
+      {
+        internalType: 'address',
+        name: 'resolver',
+        type: 'address',
+      },
+      {
+        internalType: 'address',
+        name: 'owner',
+        type: 'address',
+      },
+      {
+        internalType: 'string[]',
+        name: 'values',
+        type: 'string[]',
+      },
+    ],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [{ internalType: 'uint256', name: 'tokenId', type: 'uint256' }],
+    name: 'exists',
+    outputs: [{ internalType: 'bool', name: '', type: 'bool' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+] as const
+
+export const CHAIN_TYPE_UNS_CHAIN_MAP: Record<ChainType, string> = {
+  [ChainType.EVM]: 'ETH',
+  [ChainType.MVM]: 'SUI',
+  [ChainType.SVM]: 'SOL',
+  [ChainType.UTXO]: 'BTC',
+}
+
+export const CHAIN_ID_UNS_CHAIN_MAP: Partial<Record<ChainId, string>> = {
+  [ChainId.ETH]: 'ETH',
+  [ChainId.BTC]: 'BTC',
+  [ChainId.SUI]: 'SUI',
+  [ChainId.SOL]: 'SOL',
+  [ChainId.BAS]: 'BASE',
+  [ChainId.POL]: 'MATIC',
+  [ChainId.ARB]: 'ARB1',
+  [ChainId.AVA]: 'AVAX',
+}
+
+export const CHAIN_TYPE_FAMILY_MAP: Record<ChainType, string> = {
+  [ChainType.EVM]: 'EVM',
+  [ChainType.UTXO]: 'BTC',
+  [ChainType.SVM]: 'SOL',
+  [ChainType.MVM]: 'SUI',
+}

package/src/core/EVM/uns/resolveUNSAddress.ts

@@ -0,0 +1,123 @@
+import { ChainId, type ChainType, type CoinKey } from '@lifi/types'
+import type { Address, Client } from 'viem'
+import { readContract } from 'viem/actions'
+import { namehash } from 'viem/ens'
+import { getAction, trim } from 'viem/utils'
+import { getPublicClient } from '../publicClient.js'
+
+import {
+  CHAIN_ID_UNS_CHAIN_MAP,
+  CHAIN_TYPE_FAMILY_MAP,
+  CHAIN_TYPE_UNS_CHAIN_MAP,
+  getUNSProxyAddress,
+  UNSProxyReaderABI,
+} from './constants.js'
+
+export const resolveUNSAddress = async (
+  name: string,
+  chainType: ChainType,
+  chain?: ChainId,
+  token?: CoinKey
+): Promise<string | undefined> => {
+  try {
+    const L1Client = await getPublicClient(ChainId.ETH)
+    const L2Client = await getPublicClient(ChainId.POL)
+
+    const nameHash = namehash(name)
+    const keys: string[] = []
+
+    // handle token based resolution
+    if (chain) {
+      const family = CHAIN_TYPE_FAMILY_MAP[chainType]
+      const unschain = CHAIN_ID_UNS_CHAIN_MAP[chain]
+
+      if (family) {
+        if (token) {
+          keys.push(`token.${family}.${unschain}.${token}.address`)
+        }
+        if (unschain) {
+          keys.push(`token.${family}.${unschain}.address`)
+        }
+
+        keys.push(`token.${family}.address`)
+      }
+    }
+
+    // fallback to chain based resolution
+    const unschainType = CHAIN_TYPE_UNS_CHAIN_MAP[chainType]
+    keys.push(`crypto.${unschainType}.address`)
+
+    for (const key of keys) {
+      const address =
+        (await getUnsAddress(L2Client, { name: nameHash, key })) ||
+        (await getUnsAddress(L1Client, { name: nameHash, key }))
+      if (address) {
+        return address
+      }
+    }
+    return undefined
+  } catch {
+    return undefined
+  }
+}
+
+type GetUnsAddressParameters = {
+  key: string
+  name: string
+}
+
+type GetUnsAddressReturnType = Address | undefined
+
+async function getUnsAddress(
+  client: Client,
+  params: GetUnsAddressParameters
+): Promise<GetUnsAddressReturnType> {
+  const { name, key } = params
+
+  const chainId = client.chain?.id
+  if (!chainId) {
+    throw new Error('Chain ID not available')
+  }
+
+  const proxyAddress = getUNSProxyAddress(chainId)
+  if (!proxyAddress) {
+    throw new Error(`UNS contracts are not deployed on chain ${chainId}`)
+  }
+
+  const readContractAction = getAction(client, readContract, 'readContract')
+
+  const existsReadContractParameters = {
+    abi: UNSProxyReaderABI,
+    address: proxyAddress,
+    functionName: 'exists',
+    args: [BigInt(name)],
+  } as const
+
+  const exists = await readContractAction(existsReadContractParameters)
+
+  if (!exists) {
+    return undefined
+  }
+
+  const readContractParameters = {
+    abi: UNSProxyReaderABI,
+    address: proxyAddress,
+    functionName: 'getData',
+    args: [[key], BigInt(name)],
+  } as const
+
+  const res = await readContractAction(readContractParameters)
+  const [, , addresses] = res
+
+  const address = addresses[0]
+
+  if (
+    address === '0x' ||
+    address === '' ||
+    trim(address as Address) === '0x00'
+  ) {
+    return undefined
+  }
+
+  return address as Address
+}

package/src/core/Solana/Solana.ts

@@ -1,8 +1,8 @@
 import { ChainType } from '@lifi/types'
 import type { StepExecutorOptions } from '../types.js'
-import { getSNSAddress } from './getSNSAddress.js'
 import { getSolanaBalance } from './getSolanaBalance.js'
 import { isSVMAddress } from './isSVMAddress.js'
+import { resolveSolanaAddress } from './resolveSolanaAddress.js'
 import { SolanaStepExecutor } from './SolanaStepExecutor.js'
 import type { SolanaProvider, SolanaProviderOptions } from './types.js'
 
@@ -13,7 +13,7 @@ export function Solana(options?: SolanaProviderOptions): SolanaProvider {
       return ChainType.SVM
     },
     isAddress: isSVMAddress,
-    resolveAddress: getSNSAddress,
+    resolveAddress: resolveSolanaAddress,
     getBalance: getSolanaBalance,
     async getStepExecutor(
       options: StepExecutorOptions

package/src/core/Solana/resolveSolanaAddress.ts

@@ -0,0 +1,7 @@
+import { getSNSAddress } from './getSNSAddress.js'
+
+export async function resolveSolanaAddress(
+  name: string
+): Promise<string | undefined> {
+  return await getSNSAddress(name)
+}

package/src/core/Sui/Sui.ts

@@ -2,7 +2,7 @@ import { ChainType } from '@lifi/types'
 import { isValidSuiAddress } from '@mysten/sui/utils'
 import type { StepExecutorOptions } from '../types.js'
 import { getSuiBalance } from './getSuiBalance.js'
-import { getSuiNSAddress } from './getSuiNSAddress.js'
+import { resolveSuiAddress } from './resolveSuiAddress.js'
 import { SuiStepExecutor } from './SuiStepExecutor.js'
 import type { SuiProvider, SuiProviderOptions } from './types.js'
 
@@ -13,7 +13,7 @@ export function Sui(options?: SuiProviderOptions): SuiProvider {
       return ChainType.MVM
     },
     isAddress: isValidSuiAddress,
-    resolveAddress: getSuiNSAddress,
+    resolveAddress: resolveSuiAddress,
     getBalance: getSuiBalance,
     async getStepExecutor(
       options: StepExecutorOptions

package/src/core/Sui/resolveSuiAddress.ts

@@ -0,0 +1,7 @@
+import { getSuiNSAddress } from './getSuiNSAddress.js'
+
+export async function resolveSuiAddress(
+  name: string
+): Promise<string | undefined> {
+  return await getSuiNSAddress(name)
+}

package/src/core/UTXO/UTXO.ts

@@ -2,6 +2,7 @@ import { isUTXOAddress } from '@bigmi/core'
 import { ChainType } from '@lifi/types'
 import type { StepExecutorOptions } from '../types.js'
 import { getUTXOBalance } from './getUTXOBalance.js'
+import { resolveUTXOAddress } from './resolveUTXOAddress.js'
 import type { UTXOProvider, UTXOProviderOptions } from './types.js'
 import { UTXOStepExecutor } from './UTXOStepExecutor.js'
 
@@ -12,10 +13,7 @@ export function UTXO(options?: UTXOProviderOptions): UTXOProvider {
       return ChainType.UTXO
     },
     isAddress: isUTXOAddress,
-    async resolveAddress(name) {
-      // Not supported on UTXO yet
-      return name
-    },
+    resolveAddress: resolveUTXOAddress,
     getBalance: getUTXOBalance,
     async getStepExecutor(
       options: StepExecutorOptions

package/src/core/UTXO/UTXOStepExecutor.ts

@@ -1,7 +1,15 @@
 import type { Client, ReplacementReason } from '@bigmi/core'
-import { signPsbt, waitForTransaction, withTimeout } from '@bigmi/core'
+import {
+  AddressType,
+  getAddressInfo,
+  hexToUnit8Array,
+  signPsbt,
+  waitForTransaction,
+  withTimeout,
+} from '@bigmi/core'
+import * as ecc from '@bitcoinerlab/secp256k1'
 import { ChainId } from '@lifi/types'
-import { address, networks, Psbt } from 'bitcoinjs-lib'
+import { address, initEccLib, networks, Psbt } from 'bitcoinjs-lib'
 import { config } from '../../config.js'
 import { LiFiErrorCode } from '../../errors/constants.js'
 import { TransactionError } from '../../errors/errors.js'
@@ -17,7 +25,7 @@ import type {
 import { waitForDestinationChainTransaction } from '../waitForDestinationChainTransaction.js'
 import { getUTXOPublicClient } from './getUTXOPublicClient.js'
 import { parseUTXOErrors } from './parseUTXOErrors.js'
-import { isPsbtFinalized } from './utils.js'
+import { isPsbtFinalized, toXOnly } from './utils.js'
 
 export interface UTXOStepExecutorOptions extends StepExecutorOptions {
   client: Client
@@ -143,8 +151,44 @@ export class UTXOStepExecutor extends BaseStepExecutor {
 
           const psbtHex = transactionRequest.data
 
+          // Initialize ECC library required for Taproot operations
+          // https://github.com/bitcoinjs/bitcoinjs-lib?tab=readme-ov-file#using-taproot
+          initEccLib(ecc)
+
           const psbt = Psbt.fromHex(psbtHex, { network: networks.bitcoin })
 
+          psbt.data.inputs.forEach((input, index) => {
+            const accountAddress = input.witnessUtxo
+              ? address.fromOutputScript(
+                  input.witnessUtxo.script,
+                  networks.bitcoin
+                )
+              : (this.client.account?.address as string)
+            const addressInfo = getAddressInfo(accountAddress)
+            if (addressInfo.type === AddressType.p2tr) {
+              // Taproot (P2TR) addresses require specific PSBT fields for proper signing
+
+              // tapInternalKey: Required for Taproot key-path spending
+              // Most wallets  / libraries usually handle this already
+              if (!input.tapInternalKey) {
+                const pubKey = this.client.account?.publicKey
+                if (pubKey) {
+                  const tapInternalKey = toXOnly(hexToUnit8Array(pubKey))
+                  psbt.updateInput(index, {
+                    tapInternalKey,
+                  })
+                }
+              }
+              // sighashType: Required by bitcoinjs-lib even though the bitcoin protocol allows defaults
+              // check if sighashType is default (0) or not set (undefined)
+              if (!input.sighashType) {
+                psbt.updateInput(index, {
+                  sighashType: 1, // Default to Transaction.SIGHASH_ALL - 1
+                })
+              }
+            }
+          })
+
           const inputsToSign = Array.from(
             psbt.data.inputs
               .reduce((map, input, index) => {
@@ -172,7 +216,7 @@ export class UTXOStepExecutor extends BaseStepExecutor {
           const signedPsbtHex = await withTimeout(
             () =>
               signPsbt(this.client, {
-                psbt: psbtHex,
+                psbt: psbt.toHex(),
                 inputsToSign: inputsToSign,
                 finalize: false,
               }),

package/src/core/UTXO/resolveUTXOAddress.ts

@@ -0,0 +1,6 @@
+export async function resolveUTXOAddress(
+  name: string
+): Promise<string | undefined> {
+  // Not supported on UTXO yet
+  return name
+}

package/src/core/UTXO/utils.ts

@@ -8,3 +8,7 @@ export function isPsbtFinalized(psbt: Psbt): boolean {
     return false
   }
 }
+
+// helper function to convert full public key (33 bytes) to x-only compressed format (32 bytes) required after taproot update
+export const toXOnly = (pubKey: Uint8Array) =>
+  pubKey.length === 32 ? pubKey : pubKey.subarray(1, 33)

package/src/core/types.ts

@@ -1,5 +1,7 @@
 import type {
+  ChainId,
   ChainType,
+  CoinKey,
   FeeCost,
   GasCost,
   LiFiStep,
@@ -14,7 +16,11 @@ import type { Client } from 'viem'
 export interface SDKProvider {
   readonly type: ChainType
   isAddress(address: string): boolean
-  resolveAddress(name: string): Promise<string | undefined>
+  resolveAddress(
+    name: string,
+    chainId?: ChainId,
+    token?: CoinKey
+  ): Promise<string | undefined>
   getStepExecutor(options: StepExecutorOptions): Promise<StepExecutor>
   getBalance(walletAddress: string, tokens: Token[]): Promise<TokenAmount[]>
 }

package/src/version.ts

@@ -1,2 +1,2 @@
 export const name = '@lifi/sdk'
-export const version = '3.8.11'
+export const version = '3.9.0-beta.0'

package/src/_cjs/core/EVM/getENSAddress.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getENSAddress.js","sourceRoot":"","sources":["../../../core/EVM/getENSAddress.ts"],"names":[],"mappings":";;;AAAA,uCAAqC;AACrC,kCAAmD;AACnD,uDAAmD;AAE5C,MAAM,aAAa,GAAG,KAAK,EAChC,IAAY,EACiB,EAAE;IAC/B,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,IAAA,iCAAe,EAAC,eAAO,CAAC,GAAG,CAAC,CAAA;QACjD,MAAM,OAAO,GAAG,MAAM,IAAA,mBAAa,EAAC,MAAM,EAAE;YAC1C,IAAI,EAAE,IAAA,eAAS,EAAC,IAAI,CAAC;SACtB,CAAC,CAAA;QACF,OAAO,OAA6B,CAAA;IACtC,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QAEX,OAAM;IACR,CAAC;AACH,CAAC,CAAA;AAbY,QAAA,aAAa,iBAazB"}

package/src/_esm/core/EVM/getENSAddress.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getENSAddress.js","sourceRoot":"","sources":["../../../core/EVM/getENSAddress.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AACrC,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAEnD,MAAM,CAAC,MAAM,aAAa,GAAG,KAAK,EAChC,IAAY,EACiB,EAAE;IAC/B,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,eAAe,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;QACjD,MAAM,OAAO,GAAG,MAAM,aAAa,CAAC,MAAM,EAAE;YAC1C,IAAI,EAAE,SAAS,CAAC,IAAI,CAAC;SACtB,CAAC,CAAA;QACF,OAAO,OAA6B,CAAA;IACtC,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,SAAS;QACT,OAAM;IACR,CAAC;AACH,CAAC,CAAA"}

package/src/_types/core/EVM/getENSAddress.d.ts

@@ -1,2 +0,0 @@
-export declare const getENSAddress: (name: string) => Promise<string | undefined>;
-//# sourceMappingURL=getENSAddress.d.ts.map

package/src/_types/core/EVM/getENSAddress.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getENSAddress.d.ts","sourceRoot":"","sources":["../../../core/EVM/getENSAddress.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,aAAa,GACxB,MAAM,MAAM,KACX,OAAO,CAAC,MAAM,GAAG,SAAS,CAW5B,CAAA"}