feat: add iota evm

packages/desktop/views/dashboard/send-flow/views/components/EvmTransactionSummary.svelte

@@ -1,14 +1,15 @@
 <script lang="ts">
     import {
         EvmTransactionData,
-        L2_TO_L1_STORAGE_DEPOSIT_BUFFER,
         calculateEstimatedGasFeeFromTransactionData,
         calculateMaxGasFeeFromTransactionData,
+        getL2ToL1StorageDepositBuffer,
     } from '@core/layer-2'
     import { Nft, isIrc27Nft } from '@core/nfts'
     import { SendFlowParameters, SendFlowType, TokenTransferData } from '@core/wallet'
     import { TransactionAssetSection } from '@ui'
     import EvmTransactionDetails from './EvmTransactionDetails.svelte'
+    import { handleError } from '@core/error/handlers'
 
     export let transaction: EvmTransactionData
     export let sendFlowParameters: SendFlowParameters
@@ -27,21 +28,28 @@
     }
 
     $: storageDeposit = getTransactionStorageDeposit(sendFlowParameters) ?? BigInt(0)
-    function getTransactionStorageDeposit(_sendFlowParameters: SendFlowParameters): bigint {
-        if (_sendFlowParameters.type === SendFlowType.TokenTransfer) {
-            if (_sendFlowParameters.destinationNetworkId !== _sendFlowParameters.tokenTransfer.token.networkId) {
-                return BigInt(L2_TO_L1_STORAGE_DEPOSIT_BUFFER[SendFlowType.TokenUnwrap] ?? 0)
-            }
-        } else if (_sendFlowParameters.type === SendFlowType.NftTransfer) {
-            if (
-                _sendFlowParameters.destinationNetworkId !== _sendFlowParameters.nft?.networkId &&
-                isIrc27Nft(_sendFlowParameters.nft)
-            ) {
-                return (
-                    (_sendFlowParameters.nft?.storageDeposit ?? BigInt(0)) +
-                    (L2_TO_L1_STORAGE_DEPOSIT_BUFFER[SendFlowType.NftUnwrap] ?? BigInt(0))
-                )
+    function getTransactionStorageDeposit(_sendFlowParameters: SendFlowParameters): bigint | undefined {
+        try {
+            const { type, destinationNetworkId } = _sendFlowParameters
+            if (type === SendFlowType.TokenTransfer) {
+                if (
+                    destinationNetworkId &&
+                    destinationNetworkId !== _sendFlowParameters?.tokenTransfer?.token.networkId
+                ) {
+                    return getL2ToL1StorageDepositBuffer(SendFlowType.TokenUnwrap, destinationNetworkId)
+                }
+            } else if (type === SendFlowType.NftTransfer) {
+                if (
+                    destinationNetworkId &&
+                    destinationNetworkId !== _sendFlowParameters.nft?.networkId &&
+                    isIrc27Nft(_sendFlowParameters.nft)
+                ) {
+                    const buffer = getL2ToL1StorageDepositBuffer(SendFlowType.NftUnwrap, destinationNetworkId)
+                    return (_sendFlowParameters.nft?.storageDeposit ?? BigInt(0)) + buffer
+                }
             }
+        } catch (err) {
+            handleError(err)
         }
     }
 </script>

packages/shared/src/components/avatars/NetworkAvatar.svelte

@@ -13,6 +13,7 @@
         [SupportedNetworkId.Iota]: '#000000',
         [SupportedNetworkId.Shimmer]: 'shimmer-background',
         [SupportedNetworkId.Testnet]: 'shimmer-background',
+        [SupportedNetworkId.IotaEvm]: '#0A0FB0',
         [SupportedNetworkId.ShimmerEvm]: 'shimmer-background',
         [SupportedNetworkId.TestnetEvm]: 'text-secondary',
     }
@@ -21,6 +22,7 @@
         [SupportedNetworkId.Iota]: '#FFFFFF',
         [SupportedNetworkId.Shimmer]: 'shimmer',
         [SupportedNetworkId.Testnet]: 'text-secondary',
+        [SupportedNetworkId.IotaEvm]: '#FFFFFF',
         [SupportedNetworkId.ShimmerEvm]: 'text-invert',
         [SupportedNetworkId.TestnetEvm]: 'shimmer-background',
     }

packages/shared/src/components/avatars/TokenAvatar.svelte

@@ -23,6 +23,9 @@
         [SupportedNetworkId.Testnet]: {
             [BASE_TOKEN_ID]: 'shimmer',
         },
+        [SupportedNetworkId.IotaEvm]: {
+            [BASE_TOKEN_ID]: '#000000',
+        },
         [SupportedNetworkId.ShimmerEvm]: {
             [BASE_TOKEN_ID]: 'shimmer',
         },
@@ -41,6 +44,9 @@
         [SupportedNetworkId.Testnet]: {
             [BASE_TOKEN_ID]: 'shimmer-background',
         },
+        [SupportedNetworkId.IotaEvm]: {
+            [BASE_TOKEN_ID]: '#FFFFFF',
+        },
         [SupportedNetworkId.ShimmerEvm]: {
             [BASE_TOKEN_ID]: 'shimmer-background',
         },

packages/shared/src/lib/auxiliary/icon/constants/default-network-icon.ts

@@ -5,6 +5,7 @@ export const DEFAULT_NETWORK_ICON: { [id in NetworkId]?: IconName } = {
     [SupportedNetworkId.Iota]: IconName.Iota,
     [SupportedNetworkId.Shimmer]: IconName.Shimmer,
     [SupportedNetworkId.Testnet]: IconName.Shimmer,
+    [SupportedNetworkId.IotaEvm]: IconName.Iota,
     [SupportedNetworkId.ShimmerEvm]: IconName.Shimmer,
     [SupportedNetworkId.TestnetEvm]: IconName.Shimmer,
 }

packages/shared/src/lib/auxiliary/icon/constants/default-token-icon.ts

@@ -12,6 +12,9 @@ export const DEFAULT_TOKEN_ICON: { [networkId in NetworkId]?: { [tokenId: string
     [SupportedNetworkId.Testnet]: {
         [BASE_TOKEN_ID]: IconName.Shimmer,
     },
+    [SupportedNetworkId.IotaEvm]: {
+        [BASE_TOKEN_ID]: IconName.Iota,
+    },
     [SupportedNetworkId.ShimmerEvm]: {
         [BASE_TOKEN_ID]: IconName.Shimmer,
     },

packages/shared/src/lib/core/layer-2/actions/checkForUntrackedTokens.ts

@@ -9,7 +9,7 @@ export function checkForUntrackedTokens(account: IAccountState, addPreviouslyUnt
     const evmNetworks = getEvmNetworks()
     evmNetworks?.forEach(async (evmNetwork) => {
         const evmAddress = account.evmAddresses[evmNetwork.coinType]
-        if (!evmAddress) {
+        if (!evmAddress || !evmNetwork.explorerUrl) {
             return
         }
         const networkId = evmNetwork.id

packages/shared/src/lib/core/layer-2/actions/getGasFeeForLayer1ToLayer2Transaction.ts

@@ -19,23 +19,26 @@ export async function getGasFeeForLayer1ToLayer2Transaction(sendFlowParameters:
     }
 
     try {
-        const gasEstimate = await getGasEstimateForIscCall(destinationNetworkId, sendFlowParameters)
-        return gasEstimate
+        const gasFeeEstimate = await getGasFeeEstimateForIscCall(destinationNetworkId, sendFlowParameters)
+        return gasFeeEstimate
     } catch (err) {
         console.error(err)
         return BigInt(FALLBACK_ESTIMATED_GAS[sendFlowParameters.type])
     }
 }
 
-async function getGasEstimateForIscCall(networkId: NetworkId, sendFlowParameters: SendFlowParameters): Promise<bigint> {
+async function getGasFeeEstimateForIscCall(
+    networkId: NetworkId,
+    sendFlowParameters: SendFlowParameters
+): Promise<bigint> {
     const iscChain = getIscChain(networkId)
     if (!iscChain) {
         return Promise.reject('Invalid network')
     }
     const account = getSelectedAccount()
     const tempOutput = await createStardustOutputFromSendFlowParameters(sendFlowParameters, account)
     const outputBytes = await outputHexBytes(tempOutput)
-    return iscChain.getGasEstimate(outputBytes)
+    return iscChain.getGasFeeEstimate(outputBytes)
 }
 
 function getTransferredAsset(sendFlowParameters: SendFlowParameters): TransferredAsset | undefined {

packages/shared/src/lib/core/layer-2/actions/getLayer2MetadataForTransfer.ts

@@ -16,15 +16,22 @@ export function getLayer2MetadataForTransfer(sendFlowParameters: SendFlowParamet
     const address = sendFlowParameters.recipient?.address ?? ''
     const encodedAddress = encodeAddress(address.toLowerCase(), iscChain)
 
-    const estimatedGas = sendFlowParameters.gasFee ?? BigInt(0)
-    const gasLimit = Math.floor(Number(estimatedGas) * GAS_LIMIT_MULTIPLIER)
+    const gasFee = sendFlowParameters.gasFee ?? BigInt(0)
+    const gasPerToken = iscChain.getMetadata()?.gasFeePolicy.gasPerToken
+    let gasLimit: number
+    if (gasPerToken) {
+        // More information can be found here: https://wiki.iota.org/isc/reference/core-contracts/governance/#ratio32
+        gasLimit = (Number(gasFee) * gasPerToken['a']) / gasPerToken['b']
+    } else {
+        gasLimit = Number(gasFee) * GAS_LIMIT_MULTIPLIER
+    }
 
     metadataStream.writeUInt8('senderContract', EXTERNALLY_OWNED_ACCOUNT)
 
     metadataStream.writeUInt32('targetContract', ACCOUNTS_CONTRACT)
     metadataStream.writeUInt32('contractFunction', TRANSFER_ALLOWANCE)
     // Gas budget is the ISC equivalent of gas limit in ethereum and what we use throughout the code
-    metadataStream.writeUInt64SpecialEncoding('gasLimit', BigInt(gasLimit))
+    metadataStream.writeUInt64SpecialEncoding('gasLimit', BigInt(Math.floor(gasLimit)))
 
     const smartContractParameters = Object.entries({ a: encodedAddress })
     const parameters = encodeSmartContractParameters(smartContractParameters)

packages/shared/src/lib/core/layer-2/constants/index.ts

@@ -10,7 +10,6 @@ export * from './externally-owned-account.constant'
 export * from './fallback-estimated-gas.constant'
 export * from './gas-limit-multiplier.constant'
 export * from './isc-magic-contract-address.constant'
-export * from './l2-to-l1-storage-deposit-buffer.constant'
 export * from './layer2-tokens-poll-interval.constant'
 export * from './target-contracts.constant'
 export * from './transfer-allowance.constant'

packages/shared/src/lib/core/layer-2/utils/calculateEstimatedGasFeeFromTransactionData.ts

@@ -1,11 +1,11 @@
 import { EvmTransactionData } from '../types'
 import { calculateGasFeeInGlow } from '../helpers'
 
-export function calculateEstimatedGasFeeFromTransactionData(transactionData: EvmTransactionData): bigint | undefined {
+export function calculateEstimatedGasFeeFromTransactionData(transactionData: EvmTransactionData): bigint {
     const { estimatedGas, gasPrice } = transactionData
     if (estimatedGas && gasPrice) {
         return calculateGasFeeInGlow(estimatedGas, gasPrice)
     } else {
-        return undefined
+        return BigInt(0)
     }
 }

packages/shared/src/lib/core/layer-2/utils/calculateMaxGasFeeFromTransactionData.ts

@@ -1,11 +1,11 @@
 import { EvmTransactionData } from '../types'
 import { calculateGasFeeInGlow } from '../helpers'
 
-export function calculateMaxGasFeeFromTransactionData(transactionData: EvmTransactionData): bigint | undefined {
+export function calculateMaxGasFeeFromTransactionData(transactionData: EvmTransactionData): bigint {
     const { gasLimit, gasPrice } = transactionData
     if (gasLimit && gasPrice) {
         return calculateGasFeeInGlow(gasLimit, gasPrice)
     } else {
-        return undefined
+        return BigInt(0)
     }
 }

packages/shared/src/lib/core/layer-2/utils/fetchIscAssetsForAccount.ts

@@ -49,6 +49,7 @@ async function getL2NativeTokenBalancesForAddress(evmAddress: string, iscChain:
         nativeTokenResult.items?.forEach((item) => (nativeTokens[item.key] = Converter.bigIntLikeToBigInt(item.value)))
         return nativeTokens
     } catch (e) {
+        console.error(e)
         return {}
     }
 }

packages/shared/src/lib/core/layer-2/utils/getL2ToL1StorageDepositBuffer.ts

@@ -0,0 +1,32 @@
+import { nodeInfo } from '@core/network'
+import { DEFAULT_PROTOCOL } from '@core/network/constants'
+import { NetworkId } from '@core/network/types'
+import { SendFlowType } from '@core/wallet/enums'
+import { get } from 'svelte/store'
+
+const L2_TO_L1_STORAGE_DEPOSIT_BUFFER_BYTES: { [key in UnwrapSendFlow]: bigint } = {
+    [SendFlowType.TokenUnwrap]: BigInt(565),
+    [SendFlowType.NftUnwrap]: BigInt(35),
+}
+
+type UnwrapSendFlow = SendFlowType.TokenUnwrap | SendFlowType.NftUnwrap
+
+export function getL2ToL1StorageDepositBuffer(type: UnwrapSendFlow, network: NetworkId): bigint {
+    const actualVByteCost = get(nodeInfo)?.protocol.rentStructure.vByteCost
+    let expectedVByteCost = DEFAULT_PROTOCOL[network]?.rentStructure.vByteCost
+
+    // TODO: Validate byte cost returned by node
+    if (!expectedVByteCost && !actualVByteCost) {
+        throw new Error(`Virtual byte cost for ${network} is undefined!`)
+        // } else if (!actualVByteCost) {
+        //     throw new Error('Node does not return virtual byte cost')
+    } else if (!expectedVByteCost) {
+        expectedVByteCost = actualVByteCost
+    }
+
+    // if (expectedVByteCost !== actualVByteCost) {
+    //     throw new Error('Virtual byte cost from the node differs from the expected values')
+    // }
+
+    return BigInt(expectedVByteCost) * L2_TO_L1_STORAGE_DEPOSIT_BUFFER_BYTES[type]
+}

packages/shared/src/lib/core/layer-2/utils/index.ts

@@ -13,6 +13,7 @@ export * from './getErc721TransferSmartContractData'
 export * from './getEvmTransactionFromHexString'
 export * from './getHexEncodedTransaction'
 export * from './getMethodForEvmTransaction'
+export * from './getL2ToL1StorageDepositBuffer'
 export * from './isErcAsset'
 export * from './lookupMethodSignature'
 export * from './parseLayer2Metadata'

packages/shared/src/lib/core/network/classes/isc-chain.class.ts

@@ -3,7 +3,6 @@ import { fetchIscAssetsForAccount } from '@core/layer-2/utils'
 import { NetworkType } from '@core/network/enums'
 import { getActiveProfileId } from '@core/profile/stores'
 import { ITokenBalance } from '@core/token/interfaces'
-import { Converter } from '@core/utils'
 import { IIscChain, IIscChainConfiguration, IIscChainMetadata } from '../interfaces'
 import { EvmNetwork } from './evm-network.class'
 
@@ -27,15 +26,18 @@ export class IscChain extends EvmNetwork implements IIscChain {
         this._chainApi = new URL(`v1/chains/${aliasAddress}`, apiEndpoint).href
     }
 
-    getMetadata(): Promise<IIscChainMetadata> {
-        if (this._metadata) {
-            return Promise.resolve(this._metadata)
-        } else {
-            this._metadata = <IIscChainMetadata>{} // await this.fetchChainMetadata()
-            return Promise.resolve(this._metadata)
+    async setMetadata(): Promise<void> {
+        try {
+            this._metadata = await this.fetchChainMetadata()
+        } catch (err) {
+            console.error(err)
         }
     }
 
+    getMetadata(): IIscChainMetadata | undefined {
+        return this._metadata
+    }
+
     /**
      * CAUTION: The API endpoint used by this method is not available
      * with the public ShimmerEVM node URL (b/c it's actually just
@@ -59,9 +61,9 @@ export class IscChain extends EvmNetwork implements IIscChain {
         return { ...tokenBalance, ...iscBalance }
     }
 
-    async getGasEstimate(hex: string): Promise<bigint> {
+    async getGasFeeEstimate(outputBytes: string): Promise<bigint> {
         const URL = `${this._chainApi}/estimategas-onledger`
-        const body = JSON.stringify({ outputBytes: hex })
+        const body = JSON.stringify({ outputBytes })
 
         const requestInit: RequestInit = {
             method: 'POST',
@@ -76,12 +78,12 @@ export class IscChain extends EvmNetwork implements IIscChain {
         const data = await response.json()
 
         if (response.status === 200) {
-            const gasEstimate = Converter.bigIntLikeToBigInt(data.gasFeeCharged)
-            if (gasEstimate === BigInt(0)) {
-                throw new Error(`Gas fee has an invalid value: ${gasEstimate}!`)
+            const gasFee = BigInt(data.gasFeeCharged)
+            if (gasFee === BigInt(0)) {
+                throw new Error(`Gas fee has an invalid value: ${gasFee}!`)
             }
 
-            return gasEstimate
+            return gasFee
         } else {
             throw new Error(data)
         }

packages/shared/src/lib/core/network/constants/default-base-token.constant.ts

@@ -35,6 +35,7 @@ export const DEFAULT_BASE_TOKEN: Readonly<{ [id in NetworkId]?: IBaseToken }> =
     [SupportedNetworkId.Iota]: IOTA_BASE_TOKEN,
     [SupportedNetworkId.Shimmer]: SHIMMER_BASE_TOKEN,
     [SupportedNetworkId.Testnet]: SHIMMER_BASE_TOKEN,
+    [SupportedNetworkId.IotaEvm]: IOTA_BASE_TOKEN,
     [SupportedNetworkId.ShimmerEvm]: SHIMMER_BASE_TOKEN,
     [SupportedNetworkId.TestnetEvm]: SHIMMER_BASE_TOKEN,
     [SupportedNetworkId.Ethereum]: EVM_BASE_TOKEN,

packages/shared/src/lib/core/network/constants/default-coin-type.constant.ts

@@ -6,12 +6,13 @@ export const SHIMMER_COIN_TYPE = 4219
 export const TEST_COIN_TYPE = 1
 export const ETHEREUM_COIN_TYPE = 60
 
-export const DEFAULT_COIN_TYPE: Readonly<{ [id in NetworkId]?: number }> = {
+export const DEFAULT_COIN_TYPE: Readonly<{ [key in NetworkId]: number }> = {
     [SupportedNetworkId.Iota]: IOTA_COIN_TYPE,
     [SupportedNetworkId.Shimmer]: SHIMMER_COIN_TYPE,
     [SupportedNetworkId.Testnet]: TEST_COIN_TYPE,
-    [SupportedNetworkId.Ethereum]: ETHEREUM_COIN_TYPE,
-    [SupportedNetworkId.Sepolia]: ETHEREUM_COIN_TYPE,
+    [SupportedNetworkId.IotaEvm]: ETHEREUM_COIN_TYPE,
     [SupportedNetworkId.ShimmerEvm]: ETHEREUM_COIN_TYPE,
     [SupportedNetworkId.TestnetEvm]: ETHEREUM_COIN_TYPE,
+    [SupportedNetworkId.Ethereum]: ETHEREUM_COIN_TYPE,
+    [SupportedNetworkId.Sepolia]: ETHEREUM_COIN_TYPE,
 }

packages/shared/src/lib/core/network/constants/default-explorer-urls.constant.ts

@@ -5,6 +5,7 @@ export const DEFAULT_EXPLORER_URLS: Readonly<{ [key in NetworkId]?: string }> =
     [SupportedNetworkId.Iota]: 'https://explorer.iota.org',
     [SupportedNetworkId.Shimmer]: 'https://explorer.shimmer.network',
     [SupportedNetworkId.Testnet]: 'https://explorer.shimmer.network',
+    [SupportedNetworkId.IotaEvm]: 'https://explorer.evm.iota.org',
     [SupportedNetworkId.Ethereum]: 'https://eth.blockscout.com',
     [SupportedNetworkId.ShimmerEvm]: 'https://explorer.evm.shimmer.network',
     [SupportedNetworkId.TestnetEvm]: 'https://explorer.evm.testnet.shimmer.network',