From 824ffe149ad90279868f58aae114e5b30f2f598f Mon Sep 17 00:00:00 2001 From: Meng Date: Tue, 3 Mar 2026 10:05:51 +0800 Subject: [PATCH 01/27] feat(key-storage): add independent key storage decoupled from Account Co-Authored-By: Claude Sonnet 4.6 --- app/build.gradle | 2 +- .../wallet/manager/account/AccountManager.kt | 64 ++++-- .../manager/key/CryptoProviderManager.kt | 92 +++++++- .../manager/key/storage/KeyStorageManager.kt | 196 ++++++++++++++++++ .../key/storage/KeyStorageMigration.kt | 134 ++++++++++++ .../manager/wallet/WalletCreationHelper.kt | 43 ++++ .../viewmodel/KeyStoreRestoreViewModel.kt | 34 +++ .../reactnative/bridge/NativeFRWBridge.kt | 7 + .../bridge/handlers/AuthBridgeHandler.kt | 3 + 9 files changed, 546 insertions(+), 29 deletions(-) create mode 100644 app/src/main/java/com/flowfoundation/wallet/manager/key/storage/KeyStorageManager.kt create mode 100644 app/src/main/java/com/flowfoundation/wallet/manager/key/storage/KeyStorageMigration.kt diff --git a/app/build.gradle b/app/build.gradle index dd524b01..40028dd7 100644 --- a/app/build.gradle +++ b/app/build.gradle @@ -352,7 +352,7 @@ dependencies { api fileTree(dir: "libs", include: ["*.aar", "*.jar"], exclude: ["trustwalletcore.aar"]) // Fetch Flow Wallet Kit from GitHub Packages - implementation 'com.github.onflow.flow-wallet-kit:flow-wallet-android:0.2.3' + implementation 'com.github.onflow.flow-wallet-kit:flow-wallet-android:0.2.4' implementation "org.jetbrains.kotlin:kotlin-stdlib:1.9.22" /** Android Architecture **/ implementation 'androidx.core:core-ktx:1.13.1' diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt index 5d3691f8..fc28608e 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt @@ -56,7 +56,10 @@ import com.flowfoundation.wallet.utils.storeWalletPassword import com.flowfoundation.wallet.manager.walletdata.WalletDataManager import com.flowfoundation.wallet.manager.walletdata.MainWallet +import com.flowfoundation.wallet.manager.key.storage.KeyStorageManager +import com.flowfoundation.wallet.manager.key.storage.KeyStorageMigration import com.flowfoundation.wallet.page.restore.keystore.model.KeystoreAddress +import com.flowfoundation.wallet.utils.safeRun import kotlin.text.isNullOrEmpty object AccountManager { @@ -66,7 +69,6 @@ object AccountManager { private val listeners = CopyOnWriteArrayList>() private val listListeners = CopyOnWriteArrayList>() private val userPrefixes = mutableListOf() - private val switchAccounts = mutableListOf() private var currentAccount: Account? = null private var isInitialized = false @@ -84,7 +86,6 @@ object AccountManager { logd(TAG, "Starting AccountManager initialization") accounts.clear() userPrefixes.clear() - switchAccounts.clear() currentAccount = null ioScope { @@ -129,6 +130,9 @@ object AccountManager { } logd(TAG, "AccountManager initialization completed successfully") + // Migrate key material to independent storage now that accounts are loaded. + // This must run inside the ioScope block so accounts list is fully populated. + safeRun { KeyStorageMigration.runMigrationIfNeeded() } // Update Accounts info with WalletDataManager WalletDataManager.updateWalletData() @@ -144,7 +148,6 @@ object AccountManager { // Clear potentially corrupted state accounts.clear() userPrefixes.clear() - switchAccounts.clear() currentAccount = null // Initialization failed - user needs to login/restore @@ -155,29 +158,50 @@ object AccountManager { fun getSwitchAccountList(): List { logd(TAG, "getSwitchAccountList() called") logd(TAG, "Current accounts: $accounts") - logd(TAG, "Current switchAccounts: $switchAccounts") val list = mutableListOf() list.addAll(accounts) - // Collect all FlowWallet addresses for the current network from walletNodes - val currentNetwork = chainNetWorkString() - val addressSet = accounts.flatMap { account -> - account.walletNodes.filterIsInstance() - .filter { it.chainIdString == currentNetwork } - .map { it.address } - }.toSet() + val keyOnlyAccounts = buildLocalKeyAccounts() + logd(TAG, "Key-only accounts (no Account object): $keyOnlyAccounts") - logd(TAG, "Address set from accounts (current network): $addressSet") - - val filteredSwitchAccounts = switchAccounts.filter { it.address !in addressSet } - logd(TAG, "Filtered switch accounts: $filteredSwitchAccounts") - - list.addAll(filteredSwitchAccounts) + list.addAll(keyOnlyAccounts) logd(TAG, "Final list size: ${list.size}") return list } + /** + * Builds a list of [LocalSwitchAccount] entries for UIDs that have key material stored + * in [KeyStorageManager] but no matching [Account] in [accounts] (i.e. the account cache + * was lost while the key survived). + * + * The returned list is computed fresh on each call and is not stored persistently. + */ + private fun buildLocalKeyAccounts(): List { + // Collect all UIDs known to the accounts list + val knownUids = accounts.mapNotNull { it.wallet?.id }.toSet() + + // Union of all UIDs present in any of the three key stores + val allKeyUids = ( + KeyStorageManager.getAllSeedPhraseUids() + + KeyStorageManager.getAllPrivateKeyUids() + + KeyStorageManager.getAllAndroidKeystoreUids() + ).toSet() + + // Only keep UIDs that have a key but no account + val orphanUids = allKeyUids - knownUids + + return orphanUids.map { uid -> + val akPrefix = KeyStorageManager.getAndroidKeystorePrefix(uid) + LocalSwitchAccount( + username = uid, + address = "", + userId = uid, + prefix = akPrefix + ) + } + } + fun add(account: Account, uid: String? = null) { // Clear WalletManager state before setting new account WalletManager.clear() @@ -195,6 +219,8 @@ object AccountManager { userPrefixes.removeAll { it.userId == uid} userPrefixes.add(UserPrefix(uid, prefix)) UserPrefixCacheManager.cache(UserPrefixes().apply { addAll(userPrefixes) }) + // Write to independent key storage so prefix survives account-cache loss + KeyStorageManager.saveAndroidKeystorePrefix(uid, prefix) } AccountEmojiManager.init() @@ -492,7 +518,9 @@ object AccountManager { switchAccount(switchAccount) { isSuccess -> if (isSuccess) { isSwitching = false - switchAccounts.remove(switchAccount) + // localKeyAccounts is computed dynamically from KeyStorageManager; once the + // account is re-added via the login flow the UID will appear in accounts and + // will be excluded from buildLocalKeyAccounts() automatically. uiScope { clearUserCache() MainActivity.relaunch(Env.getApp(), true) diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/key/CryptoProviderManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/key/CryptoProviderManager.kt index d5bd195a..4d9d15f2 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/key/CryptoProviderManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/key/CryptoProviderManager.kt @@ -28,9 +28,11 @@ import com.flowfoundation.wallet.utils.readWalletPassword import com.flow.wallet.storage.StorageProtocol import com.flowfoundation.wallet.manager.account.HardwareBackedKeyException import com.flowfoundation.wallet.manager.account.firstFlowWalletAddress +import com.flowfoundation.wallet.manager.key.storage.KeyStorageManager import com.flowfoundation.wallet.manager.wallet.WalletManager import com.flowfoundation.wallet.wallet.DERIVATION_PATH import com.flowfoundation.wallet.wallet.Wallet +import com.flow.wallet.keys.PrivateKey import org.onflow.flow.models.toHexString object CryptoProviderManager { @@ -101,6 +103,25 @@ object CryptoProviderManager { logd(TAG, "generateAccountCryptoProvider: Generating for account: ${account.userInfo.username}, isActive: ${account.isActive}, hasKeystore: ${!account.keyStoreInfo.isNullOrBlank()}") return try { + // --- New independent key storage (checked first) --- + val uid = account.wallet?.id + if (!uid.isNullOrBlank()) { + // SeedPhraseKey object retrieved directly – no intermediate string reconstruction + val seedPhraseKey = KeyStorageManager.getSeedPhraseKey(uid) + if (seedPhraseKey != null) { + logd(TAG, "New storage: found seed phrase key for uid: $uid") + return HDWalletCryptoProvider(seedPhraseKey) + } + // PrivateKey object retrieved directly – no intermediate string reconstruction + val privateKey = KeyStorageManager.getPrivateKeyObject(uid) + if (privateKey != null) { + logd(TAG, "New storage: found private key object for uid: $uid") + val keyWallet = WalletFactory.createKeyWallet(privateKey, setOf(ChainId.Mainnet, ChainId.Testnet), storage) as KeyWallet + return PrivateKeyCryptoProvider(privateKey, keyWallet) + } + // AKP prefix from new storage falls through to prefix-based branch below + } + // Handle keystore-based accounts if (!account.keyStoreInfo.isNullOrBlank()) { logd(TAG, " Branch: Keystore-based account. Info (first 100 chars): ${account.keyStoreInfo!!.take(100)}") @@ -125,15 +146,24 @@ object CryptoProviderManager { return HDWalletCryptoProvider(seedPhraseKey) } // Handle prefix-based accounts (legacy or hardware-backed) - else if (!account.prefix.isNullOrBlank()) { - logd(TAG, " Branch: Prefix-based account") + // Also check new AKP storage when account.prefix is absent + else if (!account.prefix.isNullOrBlank() || (!uid.isNullOrBlank() && KeyStorageManager.hasAndroidKeystorePrefix(uid))) { + val effectivePrefix = account.prefix?.takeIf { it.isNotBlank() } + ?: uid?.let { KeyStorageManager.getAndroidKeystorePrefix(it) } + + logd(TAG, " Branch: Prefix-based account (effectivePrefix from ${if (account.prefix.isNullOrBlank()) "new storage" else "account"})") + + if (effectivePrefix.isNullOrBlank()) { + loge(TAG, " Prefix-based: resolved prefix is blank, skipping") + return null + } // Standard prefix-based account handling (for non-multi-restore accounts) logd(TAG, " Standard prefix-based account handling") // Try to get the private key, handling hardware-backed keys val privateKey = try { - KeyCompatibilityManager.getPrivateKeyWithFallback(account.prefix!!, storage) + KeyCompatibilityManager.getPrivateKeyWithFallback(effectivePrefix, storage) } catch (e: HardwareBackedKeyException) { loge(TAG, "Hardware-backed key detected") return AndroidKeystoreCryptoProvider(e.prefix!!) @@ -189,7 +219,7 @@ object CryptoProviderManager { // Create the provider with the correct algorithms return PrivateKeyCryptoProvider(privateKey, wallet, determinedSigningAlgorithm, matchedKey.hashingAlgorithm) } else { - logd(TAG, " Prefix-based: Could NOT find matching on-chain key for ${account.prefix}. Using default signing algorithm: $determinedSigningAlgorithm") + logd(TAG, " Prefix-based: Could NOT find matching on-chain key for $effectivePrefix. Using default signing algorithm: $determinedSigningAlgorithm") } } else { logd(TAG, " Prefix-based: No account address available for on-chain key lookup") @@ -234,6 +264,22 @@ object CryptoProviderManager { val storage = getStorage() return try { + // --- New independent key storage (checked first) --- + val switchUid = account.wallet?.id + if (!switchUid.isNullOrBlank()) { + val seedPhraseKey = KeyStorageManager.getSeedPhraseKey(switchUid) + if (seedPhraseKey != null) { + logd("CryptoProviderManager", "Switch account new storage: seed phrase key for uid: $switchUid") + return HDWalletCryptoProvider(seedPhraseKey) + } + val privateKey = KeyStorageManager.getPrivateKeyObject(switchUid) + if (privateKey != null) { + logd("CryptoProviderManager", "Switch account new storage: private key object for uid: $switchUid") + val keyWallet = WalletFactory.createKeyWallet(privateKey, setOf(ChainId.Mainnet, ChainId.Testnet), storage) as KeyWallet + return PrivateKeyCryptoProvider(privateKey, keyWallet) + } + } + // Handle keystore-based accounts if (account.keyStoreInfo.isNullOrBlank().not()) { PrivateKeyStoreCryptoProvider(account.keyStoreInfo!!) @@ -256,10 +302,17 @@ object CryptoProviderManager { } // Handle prefix-based accounts (legacy or hardware-backed) - else if (account.prefix.isNullOrBlank().not()) { + // Also check new AKP storage when account.prefix is absent + else if (!account.prefix.isNullOrBlank() || (!switchUid.isNullOrBlank() && KeyStorageManager.hasAndroidKeystorePrefix(switchUid))) { + val switchEffectivePrefix = account.prefix?.takeIf { it.isNotBlank() } + ?: switchUid?.let { KeyStorageManager.getAndroidKeystorePrefix(it) } + if (switchEffectivePrefix.isNullOrBlank()) { + loge("CryptoProviderManager", "Switch account: resolved prefix is blank") + return null + } // Load the stored private key using the prefix-based ID with backward compatibility val privateKey = try { - KeyCompatibilityManager.getPrivateKeyWithFallback(account.prefix!!, storage) + KeyCompatibilityManager.getPrivateKeyWithFallback(switchEffectivePrefix, storage) } catch (e: HardwareBackedKeyException) { loge("CryptoProviderManager", "Hardware-backed key detected for switch account") loge("CryptoProviderManager", "Creating AndroidKeystoreCryptoProvider for hardware-backed key") @@ -362,13 +415,32 @@ object CryptoProviderManager { val storage = getStorage() return try { + // --- New independent key storage (checked first for LocalSwitchAccount) --- + val localUid = switchAccount.userId + if (!localUid.isNullOrBlank()) { + val seedPhraseKey = KeyStorageManager.getSeedPhraseKey(localUid) + if (seedPhraseKey != null) { + logd("CryptoProviderManager", "LocalSwitchAccount new storage: seed phrase key for uid: $localUid") + return HDWalletCryptoProvider(seedPhraseKey) + } + val privateKey = KeyStorageManager.getPrivateKeyObject(localUid) + if (privateKey != null) { + logd("CryptoProviderManager", "LocalSwitchAccount new storage: private key object for uid: $localUid") + val keyWallet = WalletFactory.createKeyWallet(privateKey, setOf(ChainId.Mainnet, ChainId.Testnet), storage) as KeyWallet + return PrivateKeyCryptoProvider(privateKey, keyWallet) + } + } + // Handle prefix-based accounts - if (switchAccount.prefix.isNullOrBlank().not()) { + // Also check new AKP storage when switchAccount.prefix is absent + val localEffectivePrefix = switchAccount.prefix?.takeIf { it.isNotBlank() } + ?: localUid?.let { KeyStorageManager.getAndroidKeystorePrefix(it) } + if (!localEffectivePrefix.isNullOrBlank()) { // Load the stored private key using the prefix-based ID with backward compatibility val privateKey = try { - KeyCompatibilityManager.getPrivateKeyWithFallback(switchAccount.prefix, storage) + KeyCompatibilityManager.getPrivateKeyWithFallback(localEffectivePrefix, storage) } catch (e: HardwareBackedKeyException) { - loge("CryptoProviderManager", "Hardware-backed key detected for local switch account prefix ${switchAccount.prefix}") + loge("CryptoProviderManager", "Hardware-backed key detected for local switch account prefix $localEffectivePrefix") loge("CryptoProviderManager", "Creating AndroidKeystoreCryptoProvider for hardware-backed key") // For LocalSwitchAccount, we use defaults since we don't have wallet address @@ -376,7 +448,7 @@ object CryptoProviderManager { } if (privateKey == null) { - loge("CryptoProviderManager", "CRITICAL ERROR: Failed to load stored private key for local switch account prefix ${switchAccount.prefix} from both new and old storage") + loge("CryptoProviderManager", "CRITICAL ERROR: Failed to load stored private key for local switch account prefix $localEffectivePrefix from both new and old storage") loge("CryptoProviderManager", "Cannot proceed without the stored key as it would create a different account") return null } diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/key/storage/KeyStorageManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/key/storage/KeyStorageManager.kt new file mode 100644 index 00000000..1a9de3e9 --- /dev/null +++ b/app/src/main/java/com/flowfoundation/wallet/manager/key/storage/KeyStorageManager.kt @@ -0,0 +1,196 @@ +package com.flowfoundation.wallet.manager.key.storage + +import android.content.Context +import android.content.SharedPreferences +import androidx.security.crypto.EncryptedSharedPreferences +import androidx.security.crypto.MasterKey +import com.flow.wallet.keys.CryptoProviderKey +import com.flow.wallet.keys.PrivateKey +import com.flow.wallet.keys.SeedPhraseKey +import com.flow.wallet.storage.FileSystemStorage +import com.flow.wallet.storage.StorageProtocol +import com.flowfoundation.wallet.utils.Env +import com.flowfoundation.wallet.utils.logd +import com.flowfoundation.wallet.utils.loge +import com.flowfoundation.wallet.wallet.DERIVATION_PATH +import kotlinx.coroutines.runBlocking +import org.onflow.flow.models.bytesToHex +import org.onflow.flow.models.hexToBytes +import java.io.File +import java.security.SecureRandom +import androidx.core.content.edit + +/** + * Independent key storage manager that decouples key material from the Account object. + * + * Mirrors the original three-bucket layout but uses [FileSystemStorage] directories + * instead of SharedPreferences files, and delegates encryption to FlowWalletKit primitives. + * + * Physical storage layout: + * filesDir/frw_sp_storage/{uid} – SeedPhraseKey JSON encrypted with ChaCha20 + * filesDir/frw_pk_storage/{uid} – raw PrivateKey bytes encrypted with ChaCha20 + * filesDir/frw_akp_storage/{uid} – Android Keystore prefix string encrypted with ChaCha20 + * + * Each key type lives in its own dedicated directory (one-type-per-directory), exactly + * matching the old SharedPreferences-per-type separation: + * frw_sp_storage.xml → filesDir/frw_sp_storage/ + * frw_pk_storage.xml → filesDir/frw_pk_storage/ + * frw_akp_storage.xml → filesDir/frw_akp_storage/ + * + * The ChaCha20 password is a random hex string generated once and stored in + * [EncryptedSharedPreferences] under `frw_key_master_password` (hardware-backed AES-256-GCM). + */ +object KeyStorageManager { + + private const val TAG = "KeyStorageManager" + + // Storage directory names – intentionally match the old SharedPreferences names + private const val SP_STORAGE_NAME = "frw_sp_storage" + private const val PK_STORAGE_NAME = "frw_pk_storage" + private const val AKP_STORAGE_NAME = "frw_akp_storage" + + private const val MASTER_PASSWORD_PREFS = "frw_key_master_password" + private const val MASTER_PASSWORD_KEY = "password" + + // ─── Independent per-type StorageProtocol instances ────────────────────── + + /** One FileSystemStorage per key type – mirrors the old one-SharedPreferences-per-type design. */ + private val spStorage: StorageProtocol by lazy { + FileSystemStorage(File(Env.getApp().filesDir, SP_STORAGE_NAME)) + } + private val pkStorage: StorageProtocol by lazy { + FileSystemStorage(File(Env.getApp().filesDir, PK_STORAGE_NAME)) + } + private val akpStorage: StorageProtocol by lazy { + FileSystemStorage(File(Env.getApp().filesDir, AKP_STORAGE_NAME)) + } + + // ─── Master password (EncryptedSharedPreferences) ──────────────────────── + + private val masterPasswordPrefs: SharedPreferences by lazy { + createEncryptedPreference(MASTER_PASSWORD_PREFS) + } + + private fun createEncryptedPreference(name: String): SharedPreferences = try { + EncryptedSharedPreferences.create( + Env.getApp(), + name, + MasterKey.Builder(Env.getApp()) + .setKeyScheme(MasterKey.KeyScheme.AES256_GCM) + .build(), + EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV, + EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM + ) + } catch (e: Exception) { + logd(TAG, "EncryptedSharedPreferences creation failed, using fallback: ${e.message}") + Env.getApp().getSharedPreferences("${name}_backup", Context.MODE_PRIVATE) + } + + /** Returns the persistent master password, generating it once on first call. */ + @Synchronized + fun getOrCreateMasterPassword(): String { + var password = masterPasswordPrefs.getString(MASTER_PASSWORD_KEY, null) + if (password.isNullOrBlank()) { + password = ByteArray(32).also { SecureRandom().nextBytes(it) }.bytesToHex() + masterPasswordPrefs.edit { putString(MASTER_PASSWORD_KEY, password) } + logd(TAG, "Generated new master password") + } + return password + } + + private fun password() = getOrCreateMasterPassword() + + // ─── Seed Phrase (filesDir/frw_sp_storage/{uid}) ──────────────────────── + + /** + * Encrypts and stores [mnemonic] in the dedicated seed-phrase directory. + * The stored entry also includes derivation path and passphrase for full reconstruction. + */ + fun saveSeedPhrase(uid: String, mnemonic: String) { + try { + val key = SeedPhraseKey( + mnemonicString = mnemonic, + passphrase = "", + derivationPath = DERIVATION_PATH, + storage = spStorage + ) + runBlocking { key.store(uid, password()) } + logd(TAG, "Saved seed phrase for uid: $uid") + } catch (e: Exception) { + loge(TAG, "Failed to save seed phrase for uid $uid: ${e.message}") + } + } + + /** + * Returns a fully initialised [SeedPhraseKey] ready for signing / wallet creation. + * Returns null if nothing was stored for [uid] or if decryption fails. + */ + fun getSeedPhraseKey(uid: String): SeedPhraseKey? = + SeedPhraseKey.load(uid, password(), spStorage) + + /** Convenience: returns the raw mnemonic string. Prefer [getSeedPhraseKey] where possible. */ + fun getSeedPhrase(uid: String): String? = + getSeedPhraseKey(uid)?.mnemonic?.joinToString(" ") + + fun hasSeedPhrase(uid: String): Boolean = spStorage.get(uid) != null + + /** Returns all UIDs that have a stored seed phrase. */ + fun getAllSeedPhraseUids(): List = spStorage.allKeys + + // ─── Private Key (filesDir/frw_pk_storage/{uid}) ──────────────────────── + + /** + * Encrypts and stores the private key in the dedicated private-key directory. + * [privateKeyHex] must be a 64-char lowercase hex string (32 bytes, no "0x" prefix). + */ + fun savePrivateKey(uid: String, privateKeyHex: String) { + try { + val key = PrivateKey.restore(privateKeyHex.hexToBytes(), pkStorage) + runBlocking { key.store(uid, password()) } + logd(TAG, "Saved private key for uid: $uid") + } catch (e: Exception) { + loge(TAG, "Failed to save private key for uid $uid: ${e.message}") + } + } + + /** + * Returns a fully initialised [PrivateKey] object ready for wallet creation. + * Returns null if nothing was stored for [uid] or if decryption fails. + */ + fun getPrivateKeyObject(uid: String): PrivateKey? = try { + PrivateKey.get(uid, password(), pkStorage) + } catch (e: Exception) { null } + + /** Convenience: returns the raw private key as a lowercase hex string. */ + fun getPrivateKey(uid: String): String? = + getPrivateKeyObject(uid)?.secret?.bytesToHex() + + fun hasPrivateKey(uid: String): Boolean = pkStorage.get(uid) != null + + /** Returns all UIDs that have a stored private key. */ + fun getAllPrivateKeyUids(): List = pkStorage.allKeys + + // ─── Android Keystore Prefix (filesDir/frw_akp_storage/{uid}) ─────────── + + /** + * Encrypts and stores the Android Keystore [prefix] string in the dedicated AKP directory. + * The provider is reconstructed from the prefix at the app layer when the wallet is created. + */ + fun saveAndroidKeystorePrefix(uid: String, prefix: String) { + try { + CryptoProviderKey.saveProviderIdentifier(uid, prefix, password(), akpStorage) + logd(TAG, "Saved Android Keystore prefix for uid: $uid") + } catch (e: Exception) { + loge(TAG, "Failed to save AK prefix for uid $uid: ${e.message}") + } + } + + fun getAndroidKeystorePrefix(uid: String): String? = + CryptoProviderKey.getProviderIdentifier(uid, password(), akpStorage) + + fun hasAndroidKeystorePrefix(uid: String): Boolean = + CryptoProviderKey.hasProviderIdentifier(uid, akpStorage) + + /** Returns all UIDs that have a stored Android Keystore prefix. */ + fun getAllAndroidKeystoreUids(): List = akpStorage.allKeys +} diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/key/storage/KeyStorageMigration.kt b/app/src/main/java/com/flowfoundation/wallet/manager/key/storage/KeyStorageMigration.kt new file mode 100644 index 00000000..70ae570e --- /dev/null +++ b/app/src/main/java/com/flowfoundation/wallet/manager/key/storage/KeyStorageMigration.kt @@ -0,0 +1,134 @@ +package com.flowfoundation.wallet.manager.key.storage + +import com.flowfoundation.wallet.manager.account.Account +import com.flowfoundation.wallet.manager.account.AccountManager +import com.flowfoundation.wallet.manager.account.AccountWalletManager +import com.flowfoundation.wallet.page.restore.keystore.model.KeystoreAddress +import com.flowfoundation.wallet.utils.logd +import com.flowfoundation.wallet.utils.loge +import com.flowfoundation.wallet.utils.secret.EncryptedMnemonicUtils +import com.google.gson.Gson + +/** + * One-time, idempotent migration that copies key material from Account-bound storage + * into the independent [KeyStorageManager] stores. + * + * This is safe to call on every app start because each account is only written once + * (we skip accounts whose keys are already present in the new stores). + * + * Migration rules (per account, uid = account.wallet?.id): + * 1. keyStoreInfo != null AND encryptedMnemonic != null + * → decrypt mnemonic and write to SP store + * 2. keyStoreInfo != null AND privateKey != null (no encrypted mnemonic) + * → write raw private key hex to PK store + * 3. prefix != null (Android Keystore / legacy prefix key) + * → write prefix to AKP store + * 4. None of the above (plain mnemonic account) + * → fetch mnemonic from AccountWalletManager and write to SP store + */ +object KeyStorageMigration { + + private const val TAG = "KeyStorageMigration" + + fun runMigrationIfNeeded() { + try { + val accounts = AccountManager.list() + if (accounts.isEmpty()) { + logd(TAG, "No accounts found, skipping migration") + return + } + logd(TAG, "Starting key storage migration for ${accounts.size} account(s)") + for (account in accounts) { + val uid = account.wallet?.id + if (uid.isNullOrBlank()) { + logd(TAG, "Skipping account ${account.userInfo.username}: no wallet ID") + continue + } + try { + migrateAccount(uid, account) + } catch (e: Exception) { + loge(TAG, "Failed to migrate account $uid: ${e.message}") + } + } + logd(TAG, "Key storage migration completed") + } catch (e: Exception) { + loge(TAG, "Migration failed: ${e.message}") + } + } + + private fun migrateAccount(uid: String, account: Account) { + val keyStoreInfo = account.keyStoreInfo + val prefix = account.prefix + + when { + // Case 1 & 2: account has keyStoreInfo + !keyStoreInfo.isNullOrBlank() -> migrateFromKeyStoreInfo(uid, keyStoreInfo) + + // Case 3: prefix-based Android Keystore / legacy key + !prefix.isNullOrBlank() -> { + if (!KeyStorageManager.hasAndroidKeystorePrefix(uid)) { + KeyStorageManager.saveAndroidKeystorePrefix(uid, prefix) + logd(TAG, "Migrated prefix → AKP for uid: $uid") + } else { + logd(TAG, "AKP already exists for uid: $uid, skipping") + } + } + + // Case 4: plain HD-wallet mnemonic account + else -> migrateFromAccountWalletManager(uid) + } + } + + private fun migrateFromKeyStoreInfo(uid: String, keyStoreInfo: String) { + val ks = try { + Gson().fromJson(keyStoreInfo, KeystoreAddress::class.java) + } catch (e: Exception) { + loge(TAG, "Failed to parse keyStoreInfo for uid $uid: ${e.message}") + return + } + + when { + // encryptedMnemonic present → seed-phrase restore + !ks.encryptedMnemonic.isNullOrBlank() -> { + if (!KeyStorageManager.hasSeedPhrase(uid)) { + val mnemonic = EncryptedMnemonicUtils.decrypt(ks.encryptedMnemonic, uid) + if (!mnemonic.isNullOrBlank()) { + KeyStorageManager.saveSeedPhrase(uid, mnemonic) + logd(TAG, "Migrated encryptedMnemonic → SP for uid: $uid") + } else { + loge(TAG, "Failed to decrypt mnemonic for uid: $uid") + } + } else { + logd(TAG, "SP already exists for uid: $uid, skipping") + } + } + + // privateKey present → private-key import + !ks.privateKey.isNullOrBlank() -> { + if (!KeyStorageManager.hasPrivateKey(uid)) { + val hex = ks.privateKey.removePrefix("0x") + KeyStorageManager.savePrivateKey(uid, hex) + logd(TAG, "Migrated privateKey → PK for uid: $uid") + } else { + logd(TAG, "PK already exists for uid: $uid, skipping") + } + } + + else -> logd(TAG, "keyStoreInfo for uid $uid has neither encryptedMnemonic nor privateKey") + } + } + + private fun migrateFromAccountWalletManager(uid: String) { + if (!KeyStorageManager.hasSeedPhrase(uid)) { + val mnemonic = AccountWalletManager.getHDWalletMnemonicByUID(uid) + if (!mnemonic.isNullOrBlank()) { + KeyStorageManager.saveSeedPhrase(uid, mnemonic) + logd(TAG, "Migrated AccountWalletManager mnemonic → SP for uid: $uid") + } else { + logd(TAG, "No mnemonic found in AccountWalletManager for uid: $uid") + } + } else { + logd(TAG, "SP already exists for uid: $uid, skipping") + } + } +} diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletCreationHelper.kt b/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletCreationHelper.kt index 607a2abf..91da2345 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletCreationHelper.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletCreationHelper.kt @@ -13,6 +13,7 @@ import com.flowfoundation.wallet.manager.account.AccountWalletManager import com.flowfoundation.wallet.manager.account.HardwareBackedKeyException import com.flowfoundation.wallet.manager.key.AndroidKeystoreCryptoProvider import com.flowfoundation.wallet.manager.key.KeyCompatibilityManager +import com.flowfoundation.wallet.manager.key.storage.KeyStorageManager import com.flowfoundation.wallet.network.ApiService import com.flowfoundation.wallet.network.retrofitApi import com.flowfoundation.wallet.page.restore.keystore.model.KeystoreAddress @@ -47,6 +48,28 @@ object WalletCreationHelper { logd(TAG, "Creating wallet from account: ${account.userInfo.username}") val userId = account.wallet?.id + // --- New independent key storage (checked first, avoids Account dependency) --- + if (!userId.isNullOrBlank()) { + // SeedPhraseKey object retrieved directly → no intermediate string reconstruction + val seedPhraseKey = KeyStorageManager.getSeedPhraseKey(userId) + if (seedPhraseKey != null) { + logd(TAG, "New storage: seed phrase key found for uid: $userId") + return createWalletFromSeedPhraseKey(seedPhraseKey, isCurrentAccount) + } + // PrivateKey object retrieved directly → no intermediate string reconstruction + val privateKey = KeyStorageManager.getPrivateKeyObject(userId) + if (privateKey != null) { + logd(TAG, "New storage: private key object found for uid: $userId") + return createWalletFromPrivateKey(privateKey, isCurrentAccount) + } + // Android Keystore prefix → reconstruct provider at app layer + val akPrefix = KeyStorageManager.getAndroidKeystorePrefix(userId) + if (!akPrefix.isNullOrBlank()) { + logd(TAG, "New storage: AK prefix found for uid: $userId") + return createWalletFromPrefix(akPrefix, isCurrentAccount) + } + } + // Create wallet based on account's key information only val wallet = when { // Handle keystore-based accounts @@ -219,6 +242,26 @@ object WalletCreationHelper { } } + /** + * Create wallet from a [SeedPhraseKey] object loaded directly from key storage. + * Avoids reconstructing the key from a mnemonic string. + */ + private fun createWalletFromSeedPhraseKey(seedPhraseKey: SeedPhraseKey, isCurrentAccount: Boolean): Wallet { + val storage = getStorage() + if (isCurrentAccount) WalletManager.setEoaDisabled(false) + return WalletFactory.createKeyWallet(seedPhraseKey, setOf(ChainId.Mainnet, ChainId.Testnet), storage) + } + + /** + * Create wallet from a [PrivateKey] object loaded directly from key storage. + * Cannot derive EOA addresses (no mnemonic available). + */ + private fun createWalletFromPrivateKey(privateKey: PrivateKey, isCurrentAccount: Boolean): Wallet { + val storage = getStorage() + if (isCurrentAccount) WalletManager.setEoaDisabled(true) + return WalletFactory.createKeyWallet(privateKey, setOf(ChainId.Mainnet, ChainId.Testnet), storage) + } + /** * Create wallet from keystore private key * Private key imports cannot derive EOA addresses (no mnemonic available). diff --git a/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/viewmodel/KeyStoreRestoreViewModel.kt b/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/viewmodel/KeyStoreRestoreViewModel.kt index 5ac7231a..28b2a356 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/viewmodel/KeyStoreRestoreViewModel.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/viewmodel/KeyStoreRestoreViewModel.kt @@ -52,6 +52,7 @@ import com.flowfoundation.wallet.firebase.auth.firebaseUid import com.flowfoundation.wallet.manager.account.containsFlowWalletAddress import com.flowfoundation.wallet.manager.app.chainNetWorkString import com.flowfoundation.wallet.manager.key.CryptoProviderManager +import com.flowfoundation.wallet.manager.key.storage.KeyStorageManager import com.flowfoundation.wallet.utils.secret.EncryptedMnemonicUtils import com.flowfoundation.wallet.utils.RandomUsernameGenerator import wallet.core.jni.StoredKey @@ -818,6 +819,8 @@ class KeyStoreRestoreViewModel : ViewModel() { wallet = walletData ) ) + // Persist key material in independent storage + saveKeyToNewStorage(userId, keyStoreInfo) logd("KeyStoreRestoreViewModel", "Account added successfully") logd("KeyStoreRestoreViewModel", "Import process completed successfully") callback.invoke(true) @@ -983,6 +986,8 @@ class KeyStoreRestoreViewModel : ViewModel() { ) clearUserCache() AccountManager.add(userAccount) + // Persist key material in independent storage + saveKeyToNewStorage(userId, Gson().toJson(keystoreAddress)) MixpanelManager.accountRestore(finalWalletAddress, restoreType) accountSuccessfullyAdded = true logd("KeyStoreRestoreViewModel", "Post-login process completed successfully.") @@ -1123,6 +1128,8 @@ class KeyStoreRestoreViewModel : ViewModel() { ) ) ) + // Persist key material in independent storage + saveKeyToNewStorage(userId, keyStoreInfo) MixpanelManager.accountRestore( cryptoProvider.getAddress(), restoreType @@ -1329,6 +1336,8 @@ class KeyStoreRestoreViewModel : ViewModel() { ) ) ) + // Persist key material in independent storage + saveKeyToNewStorage(firebaseUid().orEmpty(), keyStoreInfo) MixpanelManager.accountCreated( cryptoProvider.getPublicKey(), AccountCreateKeyType.RESTORE_KEYSTORE, @@ -1365,6 +1374,31 @@ class KeyStoreRestoreViewModel : ViewModel() { } } + /** + * Write key material to the independent [KeyStorageManager] store. + * Prefers the in-memory mnemonic (seed-phrase restore path); falls back to + * the private key stored in keyStoreInfo (private-key import path). + */ + private fun saveKeyToNewStorage(uid: String, keyStoreInfo: String?) { + if (uid.isBlank()) return + val mnemonic = currentMnemonic + if (!mnemonic.isNullOrBlank()) { + KeyStorageManager.saveSeedPhrase(uid, mnemonic) + return + } + if (!keyStoreInfo.isNullOrBlank()) { + try { + val ks = Gson().fromJson(keyStoreInfo, KeystoreAddress::class.java) + val hex = ks?.privateKey?.removePrefix("0x") + if (!hex.isNullOrBlank()) { + KeyStorageManager.savePrivateKey(uid, hex) + } + } catch (e: Exception) { + logd("KeyStoreRestoreViewModel", "saveKeyToNewStorage: failed to parse keyStoreInfo: ${e.message}") + } + } + } + private fun encryptedMnemonic(uid: String?): String? { val mnemonic = currentMnemonic ?: return null return if (!uid.isNullOrBlank()) { diff --git a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/NativeFRWBridge.kt b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/NativeFRWBridge.kt index 092e6fa6..f5689da1 100644 --- a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/NativeFRWBridge.kt +++ b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/NativeFRWBridge.kt @@ -51,6 +51,7 @@ import com.flowfoundation.wallet.network.ApiService import com.flowfoundation.wallet.network.generatePrefix import org.onflow.flow.infrastructure.Cadence.Companion.uint8 import com.facebook.react.modules.core.DeviceEventManagerModule +import com.flowfoundation.wallet.manager.key.storage.KeyStorageManager import com.flowfoundation.wallet.reactnative.bridge.handlers.AccountBridgeHandler import com.flowfoundation.wallet.reactnative.bridge.handlers.AuthBridgeHandler import com.flowfoundation.wallet.reactnative.bridge.handlers.UIBridgeHandler @@ -160,6 +161,12 @@ class NativeFRWBridge(reactContext: ReactApplicationContext) : NativeFRWBridgeSp // Update and store the mnemonic in Wallet Wallet.store().updateMnemonic(seedPhrase).store() + // Also persist in independent key storage so it survives account-cache loss + val uid = firebaseUid() ?: AccountManager.get()?.wallet?.id + if (!uid.isNullOrBlank()) { + KeyStorageManager.saveSeedPhrase(uid, seedPhrase) + } + logd(TAG, "saveNewKey() - Seed phrase saved successfully") uiScope { promise.resolve(null) diff --git a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/AuthBridgeHandler.kt b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/AuthBridgeHandler.kt index 5f025e7a..06c07166 100644 --- a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/AuthBridgeHandler.kt +++ b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/AuthBridgeHandler.kt @@ -17,6 +17,7 @@ import com.flowfoundation.wallet.manager.app.chainNetWorkString import com.flowfoundation.wallet.manager.emoji.AccountEmojiManager import com.flowfoundation.wallet.manager.key.CryptoProviderManager import com.flowfoundation.wallet.manager.key.HDWalletCryptoProvider +import com.flowfoundation.wallet.manager.key.storage.KeyStorageManager import com.flowfoundation.wallet.manager.wallet.WalletManager import com.flowfoundation.wallet.manager.walletdata.EOAWallet import com.flowfoundation.wallet.manager.walletdata.FlowWallet @@ -550,6 +551,8 @@ class AuthBridgeHandler(private val reactContext: ReactApplicationContext) { throw IllegalStateException("Failed to store mnemonic for userId: $userId") } logd(TAG, "saveMnemonic() - Mnemonic stored successfully via AccountWalletManager") + // Also persist in independent key storage so it survives account-cache loss + KeyStorageManager.saveSeedPhrase(userId, mnemonic) // Account discovery is now handled by React Native layer // React Native will handle wallet initialization after Flow address is created From 9ccc4f36699808ca8ee3ff4769106ca4fd56568b Mon Sep 17 00:00:00 2001 From: Meng Date: Tue, 3 Mar 2026 01:14:39 +0800 Subject: [PATCH 02/27] fix: switch current account set --- .../wallet/cache/AccountCacheManager.kt | 30 +------- .../wallet/manager/account/AccountManager.kt | 5 +- .../wallet/network/UserRegisterUtils.kt | 55 +------------- .../viewmodel/KeyStoreRestoreViewModel.kt | 71 +++++++++++-------- 4 files changed, 47 insertions(+), 114 deletions(-) diff --git a/app/src/main/java/com/flowfoundation/wallet/cache/AccountCacheManager.kt b/app/src/main/java/com/flowfoundation/wallet/cache/AccountCacheManager.kt index 110fa070..d525929d 100644 --- a/app/src/main/java/com/flowfoundation/wallet/cache/AccountCacheManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/cache/AccountCacheManager.kt @@ -66,12 +66,9 @@ object AccountCacheManager{ return null } - var str = cacheFile.read() + val str = cacheFile.read() logd(TAG, "Reading from ${cacheFile.name}: ${str.length} characters, isBlank=${str.isBlank()}") - // Migrate old field names to new format - str = migrateOldFieldNames(str) - if (str.isBlank()) { logd(TAG, "Warning: Cache file ${cacheFile.name} exists but is empty") return null @@ -196,29 +193,4 @@ object AccountCacheManager{ } } - /** - * Migrates old field names in cached JSON to new format. - * This handles the transition from old cache format to new serialization format. - * - * Field mappings: - * - "isPrivate" -> "private" (UserInfoData field name change) - * - "chainId" -> "chain_id" (BlockchainData field name change) - */ - private fun migrateOldFieldNames(json: String): String { - var migrated = json - - // Migrate UserInfoData.isPrivate to private - if (migrated.contains("\"isPrivate\":")) { - logd(TAG, "Migrating old field name: isPrivate -> private") - migrated = migrated.replace("\"isPrivate\":", "\"private\":") - } - - // Migrate BlockchainData.chainId to chain_id - if (migrated.contains("\"chainId\":")) { - logd(TAG, "Migrating old field name: chainId -> chain_id") - migrated = migrated.replace("\"chainId\":", "\"chain_id\":") - } - - return migrated - } } diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt index fc28608e..5104a699 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt @@ -484,11 +484,12 @@ object AccountManager { return@ioScope } isSwitching = true - currentAccount = account - logd(TAG, "Account switched. Current account is now: $currentAccount") + logd(TAG, "Starting account switch to: ${account.userInfo.username}") switchAccount(account) { isSuccess -> if (isSuccess) { isSwitching = false + currentAccount = account + logd(TAG, "Account switch successful. Current account updated to: $currentAccount") accounts.forEach { it.isActive = it.userInfo.username == account.userInfo.username } diff --git a/app/src/main/java/com/flowfoundation/wallet/network/UserRegisterUtils.kt b/app/src/main/java/com/flowfoundation/wallet/network/UserRegisterUtils.kt index e9cc1ec7..1c0155db 100644 --- a/app/src/main/java/com/flowfoundation/wallet/network/UserRegisterUtils.kt +++ b/app/src/main/java/com/flowfoundation/wallet/network/UserRegisterUtils.kt @@ -560,63 +560,10 @@ private suspend fun registerServer(username: String, prefix: String): RegisterRe firebaseJwt ) ) - // Create EVMAccountInfo for registration - // IMPORTANT: EVM key must be derived from the MNEMONIC, not from the P256 private key - // The extension derives EVM from mnemonic with BIP44 path m/44'/60'/0'/0/0 - val evmAccountInfo = try { - // Generate and store mnemonic globally for potential future EOA support - val mnemonic = BIP39.generate(BIP39.SeedPhraseLength.TWELVE) - logd(TAG, "Generated new 12-word mnemonic for backup support") - - val passwordMap = try { - val pref = readWalletPassword() - if (pref.isBlank()) { - HashMap() - } else { - Gson().fromJson(pref, object : TypeToken>() {}.type) - } - } catch (_: Exception) { - HashMap() - } - - // Store mnemonic globally (available for future EOA enablement if user chooses) - storeWalletPassword(Gson().toJson(passwordMap.apply { put("global", mnemonic) })) - logd(TAG, "Stored mnemonic globally for backup support") - // Use Trust Wallet Core to derive EVM key from mnemonic - val hdWallet = wallet.core.jni.HDWallet(mnemonic, "") - val evmDerivationPath = "m/44'/60'/0'/0/0" // Standard Ethereum BIP44 path - - // Get private key for EVM using secp256k1 curve - val evmPrivateKey = hdWallet.getKeyByCurve(wallet.core.jni.Curve.SECP256K1, evmDerivationPath) - val evmPublicKey = evmPrivateKey.getPublicKeySecp256k1(false) // uncompressed - - // Derive EVM address from public key - val evmAddress = wallet.core.jni.AnyAddress(evmPublicKey, wallet.core.jni.CoinType.ETHEREUM).description() - logd(TAG, "Derived EVM address from mnemonic: $evmAddress") - - // Sign keccak256(idToken) for EVM - NO domain tag, same as extension - val jwtBytes = firebaseJwt.toByteArray(Charsets.UTF_8) - val jwtHash = Hash.keccak256(jwtBytes) - - // Sign the digest with secp256k1 - val signatureData = evmPrivateKey.sign(jwtHash, wallet.core.jni.Curve.SECP256K1) - - val evmSignature = "0x" + signatureData.joinToString("") { "%02x".format(it) } - logd(TAG, "Generated EVM signature from mnemonic, length: ${evmSignature.length}") - - EvmAccountInfo( - eoaAddress = evmAddress, - signature = evmSignature - ) - } catch (e: Exception) { - logd(TAG, "Error creating EVM account info from mnemonic: ${e.message}") - e.printStackTrace() - null - } val request = RegisterRequest( flowAccountInfo = flowAccountInfo, - evmAccountInfo = evmAccountInfo, + evmAccountInfo = null, username = username, deviceInfo = deviceInfoRequest ) diff --git a/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/viewmodel/KeyStoreRestoreViewModel.kt b/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/viewmodel/KeyStoreRestoreViewModel.kt index 28b2a356..c6480933 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/viewmodel/KeyStoreRestoreViewModel.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/viewmodel/KeyStoreRestoreViewModel.kt @@ -1258,39 +1258,52 @@ class KeyStoreRestoreViewModel : ViewModel() { // Create EVMAccountInfo for keystore registration val evmAccountInfo = try { val storage = getStorage() - val privateKeyHex = cryptoProvider.getPrivateKey() - val key = PrivateKey.create(storage).apply { - val keyBytes = privateKeyHex.removePrefix("0x").hexToBytes() - importPrivateKey(keyBytes, KeyFormat.RAW) - } + if (currentMnemonic.isNullOrBlank().not()) { + val hdWallet = wallet.core.jni.HDWallet(currentMnemonic, "") + val evmDerivationPath = "m/44'/60'/0'/0/0" + val evmPrivateKey = hdWallet.getKeyByCurve(wallet.core.jni.Curve.SECP256K1, evmDerivationPath) + val evmPublicKey = evmPrivateKey.getPublicKeySecp256k1(false) + val evmAddress = wallet.core.jni.AnyAddress(evmPublicKey, wallet.core.jni.CoinType.ETHEREUM).description() + val jwtHash = Hash.keccak256(firebaseJwt.toByteArray(Charsets.UTF_8)) + val signatureData = evmPrivateKey.sign(jwtHash, wallet.core.jni.Curve.SECP256K1) + val evmSignature = "0x" + signatureData.joinToString("") { "%02x".format(it) } + EvmAccountInfo(eoaAddress = evmAddress, signature = evmSignature) + } else { + val privateKeyHex = cryptoProvider.getPrivateKey() + val key = PrivateKey.create(storage).apply { + val keyBytes = privateKeyHex.removePrefix("0x").hexToBytes() + importPrivateKey(keyBytes, KeyFormat.RAW) + } - // Get secp256k1 public key for EVM address derivation - val evmPublicKeyBytes = key.publicKey(SigningAlgorithm.ECDSA_secp256k1) - if (evmPublicKeyBytes != null) { - // Derive EVM address from public key using Keccak256 - val publicKeyForHash = if (evmPublicKeyBytes.size == 65 && evmPublicKeyBytes[0] == 0x04.toByte()) { - evmPublicKeyBytes.copyOfRange(1, evmPublicKeyBytes.size) + // Get secp256k1 public key for EVM address derivation + val evmPublicKeyBytes = key.publicKey(SigningAlgorithm.ECDSA_secp256k1) + if (evmPublicKeyBytes != null) { + // Derive EVM address from public key using Keccak256 + val publicKeyForHash = if (evmPublicKeyBytes.size == 65 && evmPublicKeyBytes[0] == 0x04.toByte()) { + evmPublicKeyBytes.copyOfRange(1, evmPublicKeyBytes.size) + } else { + evmPublicKeyBytes + } + val addressHash = Hash.keccak256(publicKeyForHash) + val evmAddress = "0x" + addressHash.copyOfRange(12, 32).joinToString("") { "%02x".format(it) } + logd("KeyStoreRestoreViewModel", "Derived EVM address: $evmAddress") + + // Sign Firebase JWT for EVM with secp256k1 key + val dataToSign = DomainTag.User.bytes + firebaseJwt.toByteArray(Charsets.UTF_8) + val evmSignatureBytes = key.sign(dataToSign, SigningAlgorithm.ECDSA_secp256k1, HashingAlgorithm.SHA2_256) + val evmSignature = evmSignatureBytes.joinToString("") { "%02x".format(it) } + logd("KeyStoreRestoreViewModel", "Generated EVM signature, length: ${evmSignature.length}") + + EvmAccountInfo( + eoaAddress = evmAddress, + signature = evmSignature + ) } else { - evmPublicKeyBytes + logd("KeyStoreRestoreViewModel", "Could not derive secp256k1 public key, skipping EVM account") + null } - val addressHash = Hash.keccak256(publicKeyForHash) - val evmAddress = "0x" + addressHash.copyOfRange(12, 32).joinToString("") { "%02x".format(it) } - logd("KeyStoreRestoreViewModel", "Derived EVM address: $evmAddress") - - // Sign Firebase JWT for EVM with secp256k1 key - val dataToSign = DomainTag.User.bytes + firebaseJwt.toByteArray(Charsets.UTF_8) - val evmSignatureBytes = key.sign(dataToSign, SigningAlgorithm.ECDSA_secp256k1, HashingAlgorithm.SHA2_256) - val evmSignature = evmSignatureBytes.joinToString("") { "%02x".format(it) } - logd("KeyStoreRestoreViewModel", "Generated EVM signature, length: ${evmSignature.length}") - - EvmAccountInfo( - eoaAddress = evmAddress, - signature = evmSignature - ) - } else { - logd("KeyStoreRestoreViewModel", "Could not derive secp256k1 public key, skipping EVM account") - null } + } catch (e: Exception) { logd("KeyStoreRestoreViewModel", "Error creating EVM account info: ${e.message}") null From 62f1ba0ee7f3a08192c705b981d215ac6bf21140 Mon Sep 17 00:00:00 2001 From: Meng Date: Wed, 4 Mar 2026 22:35:22 +0800 Subject: [PATCH 03/27] fix: firebase login after delete --- .../wallet/firebase/auth/FirebaseAuth.kt | 2 +- .../bridge/handlers/AuthBridgeHandler.kt | 176 ++++++------------ gradle.properties | 2 +- 3 files changed, 60 insertions(+), 120 deletions(-) diff --git a/app/src/main/java/com/flowfoundation/wallet/firebase/auth/FirebaseAuth.kt b/app/src/main/java/com/flowfoundation/wallet/firebase/auth/FirebaseAuth.kt index b19cc0b7..eaf3f68f 100644 --- a/app/src/main/java/com/flowfoundation/wallet/firebase/auth/FirebaseAuth.kt +++ b/app/src/main/java/com/flowfoundation/wallet/firebase/auth/FirebaseAuth.kt @@ -53,7 +53,7 @@ fun firebaseCustomLogin(token: String, onComplete: FirebaseAuthCallback) { logd(TAG, "Sign in successful, new user UID: ${newUser?.uid}") logd(TAG, "Requesting ID token refresh") - newUser?.getIdToken(true)?.addOnSuccessListener { result -> + newUser?.getIdToken(true)?.addOnSuccessListener { _ -> logd(TAG, "ID token obtained successfully") uiScope { onComplete.invoke(true, null) diff --git a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/AuthBridgeHandler.kt b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/AuthBridgeHandler.kt index 06c07166..1ef11d80 100644 --- a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/AuthBridgeHandler.kt +++ b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/AuthBridgeHandler.kt @@ -355,53 +355,35 @@ class AuthBridgeHandler(private val reactContext: ReactApplicationContext) { try { com.flowfoundation.wallet.firebase.auth.firebaseCustomLogin(customToken) { isSuccessful, exception -> if (isSuccessful) { - logd(TAG, "signInWithCustomToken() - Custom token authentication successful, waiting for JWT...") - // Wait for JWT to be available after sign-in - // This prevents race conditions where API calls happen before token propagates + // firebaseCustomLogin already calls getIdToken(true) internally before invoking this callback, + // so the Firebase ID token is already refreshed at this point. + // Calling getFirebaseJwt(forceRefresh=true) repeatedly here would trigger App Check rate limiting. + logd(TAG, "signInWithCustomToken() - Custom token authentication successful, validating with backend...") ioScope { - var tokenReady = false var backendValidated = false var attempts = 0 - val maxAttempts = 15 + val maxAttempts = 5 - while (!tokenReady && attempts < maxAttempts) { + while (!backendValidated && attempts < maxAttempts) { attempts++ try { - val jwt = getFirebaseJwt(forceRefresh = true) - val firebaseUid = com.flowfoundation.wallet.firebase.auth.firebaseUid() - - if (jwt.isNotBlank() && firebaseUid != null) { - logd(TAG, "signInWithCustomToken() - JWT ready after $attempts attempt(s), Firebase UID: $firebaseUid") - - // Validate with backend - make sure the user is recognized - try { - val service = com.flowfoundation.wallet.network.retrofit() - .create(com.flowfoundation.wallet.network.ApiService::class.java) - val userInfo = service.userInfo().data - logd(TAG, "signInWithCustomToken() - Backend validated, username: ${userInfo.username}") - tokenReady = true - backendValidated = true - } catch (apiError: Exception) { - logd(TAG, "signInWithCustomToken() - Backend validation failed on attempt $attempts: ${apiError.message}") - // Backend might not be ready yet, continue waiting - kotlinx.coroutines.delay(500) - } - } else { - logd(TAG, "signInWithCustomToken() - JWT not ready, attempt $attempts/$maxAttempts") - kotlinx.coroutines.delay(300) - } - } catch (e: Exception) { - logd(TAG, "signInWithCustomToken() - JWT check error on attempt $attempts: ${e.message}") - kotlinx.coroutines.delay(300) + val service = com.flowfoundation.wallet.network.retrofit() + .create(com.flowfoundation.wallet.network.ApiService::class.java) + val userInfo = service.userInfo().data + logd(TAG, "signInWithCustomToken() - Backend validated on attempt $attempts, username: ${userInfo.username}") + backendValidated = true + } catch (apiError: Exception) { + logd(TAG, "signInWithCustomToken() - Backend validation failed on attempt $attempts: ${apiError.message}") + kotlinx.coroutines.delay(1000) } } - if (tokenReady && backendValidated) { + if (backendValidated) { uiScope { promise.resolve(null) } } else { - loge(TAG, "signInWithCustomToken() - Auth not ready after $maxAttempts attempts (tokenReady=$tokenReady, backendValidated=$backendValidated)") + loge(TAG, "signInWithCustomToken() - Backend validation failed after $maxAttempts attempts") uiScope { promise.reject("CUSTOM_TOKEN_AUTH_ERROR", "Authentication succeeded but backend validation failed", null) } @@ -447,57 +429,15 @@ class AuthBridgeHandler(private val reactContext: ReactApplicationContext) { onSuccess = { ioScope { try { - // Force Firebase ID token refresh to get the new account's JWT - // This ensures API requests use the new account's credentials - logd(TAG, "saveMnemonic() - Forcing Firebase ID token refresh...") - var tokenRefreshed = false - var refreshAttempts = 0 - val maxRefreshAttempts = 10 - - while (!tokenRefreshed && refreshAttempts < maxRefreshAttempts) { - kotlinx.coroutines.delay(500) // Wait 500ms between checks - refreshAttempts++ - try { - // Force refresh the token - val jwt = getFirebaseJwt(forceRefresh = true) - val currentUid = com.flowfoundation.wallet.firebase.auth.firebaseUid() - - if (jwt.isNotBlank() && currentUid != null) { - tokenRefreshed = true - logd(TAG, "saveMnemonic() - Firebase ID token refreshed after $refreshAttempts attempt(s), UID: $currentUid") - - // Verify the username matches by making a test API call - try { - val testService = com.flowfoundation.wallet.network.retrofit() - .create(com.flowfoundation.wallet.network.ApiService::class.java) - val testUserInfo = testService.userInfo().data - logd(TAG, "saveMnemonic() - Token validated, backend returned username: ${testUserInfo.username}") - - // Check if username matches (case-insensitive, ignoring numeric suffix) - // Backend normalizes to lowercase and adds suffix: "FancyRiverVolcano" -> "fancyrivervolcano_476" - val backendUsernameBase = testUserInfo.username.substringBefore("_").lowercase() - val expectedUsernameBase = username.lowercase() - - if (backendUsernameBase != expectedUsernameBase) { - logw(TAG, "saveMnemonic() - Username mismatch! Expected: $expectedUsernameBase, Got: $backendUsernameBase. Retrying...") - tokenRefreshed = false // Retry - } else { - logd(TAG, "saveMnemonic() - Username validated: $expectedUsernameBase matches $backendUsernameBase") - } - } catch (e: Exception) { - logw(TAG, "saveMnemonic() - Could not validate token with backend, continuing: ${e.message}") - } - } else { - logd(TAG, "saveMnemonic() - Waiting for token refresh (attempt $refreshAttempts/$maxRefreshAttempts)") - } - } catch (e: Exception) { - logd(TAG, "saveMnemonic() - Error during token refresh (attempt $refreshAttempts): ${e.message}") - } - } - - if (!tokenRefreshed) { - logw(TAG, "saveMnemonic() - Warning: Token may not be for correct user, proceeding anyway") + // authenticateWithFirebase -> firebaseCustomLogin already calls getIdToken(true) before + // invoking this callback, so the token is already refreshed. Calling + // getFirebaseJwt(forceRefresh=true) in a loop here would trigger App Check rate limiting. + val currentFirebaseUser = Firebase.auth.currentUser + val currentUid = currentFirebaseUser?.uid + if (currentFirebaseUser == null || currentFirebaseUser.isAnonymous) { + throw IllegalStateException("Firebase auth failed: user is still anonymous after custom token login") } + logd(TAG, "saveMnemonic() - Firebase authenticated, UID: $currentUid") // Fetch user info from backend val service = com.flowfoundation.wallet.network.retrofit() @@ -677,45 +617,45 @@ private fun authenticateWithFirebase( ) { logd(TAG, "authenticateWithFirebase() - Checking current Firebase auth state...") + // getV4RegistrationSignatures() ensures anonymous sign-in before saveMnemonic() is called, + // so currentUser is always non-null here. Mirror the registerFirebase() pattern in UserRegisterUtils. val currentUser = Firebase.auth.currentUser - val currentUid = currentUser?.uid - val isAnonymous = currentUser?.isAnonymous ?: true - - if (currentUser != null) { - logd(TAG, "authenticateWithFirebase() - Current user: UID=$currentUid, isAnonymous=$isAnonymous") + logd(TAG, "authenticateWithFirebase() - Current user: UID=${currentUser?.uid}, isAnonymous=${currentUser?.isAnonymous}") + + fun doLogin() { + logd(TAG, "authenticateWithFirebase() - Signing in with new custom token...") + com.flowfoundation.wallet.firebase.auth.firebaseCustomLogin(customToken) { isSuccessful, exception -> + if (isSuccessful) { + logd(TAG, "authenticateWithFirebase() - Firebase authentication successful, new UID: ${Firebase.auth.currentUser?.uid}") + onSuccess() + } else { + val errorMessage = exception?.message ?: "Firebase authentication failed" + loge(TAG, "authenticateWithFirebase() - Failed: $errorMessage") + onFailure(errorMessage) + } + } } - // If already authenticated with a non-anonymous user, we MUST sign out first - // to switch to the new account. Firebase won't switch users without signing out. - if (currentUser != null && !isAnonymous) { - logd(TAG, "authenticateWithFirebase() - Signing out current user to switch accounts...") - - // Sign out the current user - Firebase.auth.signOut() - logd(TAG, "authenticateWithFirebase() - User signed out successfully") - - // Delete Firebase messaging token for the old user + if (currentUser == null || !currentUser.isAnonymous) { + // No user, or non-anonymous user: signOut() is synchronous, safe to call directly before login + if (currentUser != null) { + logd(TAG, "authenticateWithFirebase() - Signing out non-anonymous user before login...") + Firebase.auth.signOut() + } com.google.firebase.messaging.FirebaseMessaging.getInstance().deleteToken() - } else if (isAnonymous) { - // Delete anonymous user + doLogin() + } else { + // Anonymous user: await delete() before signing in - same pattern as registerFirebase() + // delete() is async; calling signInWithCustomToken without waiting would race with it + logd(TAG, "authenticateWithFirebase() - Deleting anonymous user before login...") com.google.firebase.messaging.FirebaseMessaging.getInstance().deleteToken() - currentUser?.delete()?.addOnCompleteListener { - logd(TAG, "authenticateWithFirebase() - Previous anonymous user deleted") - } - } - - logd(TAG, "authenticateWithFirebase() - Signing in with new custom token...") - - // Sign in with the new account's custom token - com.flowfoundation.wallet.firebase.auth.firebaseCustomLogin(customToken) { isSuccessful, exception -> - if (isSuccessful) { - val newUid = Firebase.auth.currentUser?.uid - logd(TAG, "authenticateWithFirebase() - Firebase authentication successful, new UID: $newUid") - onSuccess() - } else { - val errorMessage = exception?.message ?: "Firebase authentication failed" - loge(TAG, "authenticateWithFirebase() - Failed: $errorMessage") - onFailure(errorMessage) + currentUser.delete().addOnCompleteListener { task -> + logd(TAG, "authenticateWithFirebase() - Anonymous user delete finished, exception: ${task.exception}") + if (task.isSuccessful) { + doLogin() + } else { + onFailure("Failed to delete anonymous user: ${task.exception?.message}") + } } } } diff --git a/gradle.properties b/gradle.properties index 69561757..e39297f2 100644 --- a/gradle.properties +++ b/gradle.properties @@ -64,7 +64,7 @@ android.r8.dexing.parallel=true #android.bundle.enableUncompressedNativeLibs=false #android.experimental.enableArtProfiles=true -vCode=333 +vCode=400000458 vName=r3.1.0 # --- GitHub Packages (Flow Wallet Kit) --- From 9d95e060906aee94a6a6c7befe77141570228fc6 Mon Sep 17 00:00:00 2001 From: Meng Date: Thu, 5 Mar 2026 03:05:23 +0800 Subject: [PATCH 04/27] fix: navigation bar padding & orientation --- app/src/main/AndroidManifest.xml | 14 +++- .../wallet/base/activity/BaseActivity.kt | 57 ++++++++++++- .../wallet/cache/AccountCacheManager.kt | 83 ++++++++----------- .../browser/presenter/BrowserPresenter.kt | 16 ++-- .../wallet/page/common/WebViewActivity.kt | 3 +- .../wallet/page/main/MainActivity.kt | 11 --- .../page/main/drawer/DrawerLayoutViewModel.kt | 2 +- .../wallet/reactnative/ReactNativeActivity.kt | 25 ++++++ app/src/main/res/layout/activity_webview.xml | 13 ++- 9 files changed, 150 insertions(+), 74 deletions(-) diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index 8f63481a..e79b7e5f 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -76,6 +76,7 @@ android:name=".reactnative.ReactNativeActivity" android:exported="false" android:launchMode="singleTop" + android:screenOrientation="portrait" android:theme="@style/AppTheme" android:configChanges="keyboard|keyboardHidden|orientation|screenSize|uiMode" android:windowSoftInputMode="adjustResize" @@ -84,21 +85,25 @@ + android:launchMode="singleTop" + android:screenOrientation="portrait"/> + android:name=".page.nft.search.NFTSearchActivity" + android:screenOrientation="portrait"/> @@ -412,6 +421,7 @@ (android.R.id.content) ?: return + ViewCompat.setOnApplyWindowInsetsListener(window.decorView) { _, insets -> + val navBar = insets.getInsets(WindowInsetsCompat.Type.navigationBars()) + contentView.updatePadding(bottom = navBar.bottom) + insets // Return without consuming — let normal child dispatch continue + } + // Trigger an immediate insets dispatch now that the listener is set up and + // setDecorFitsSystemWindows(false) is in its final state. + ViewCompat.requestApplyInsets(window.decorView) + } + + override fun onWindowFocusChanged(hasFocus: Boolean) { + super.onWindowFocusChanged(hasFocus) + // Re-trigger insets dispatch once the window is actually visible and has valid insets. + // requestApplyInsets() in onPostCreate fires before the window is shown (pre-WindowManager + // attach), so it may receive zero insets. Activities without UltimateBarX have no other + // insets trigger, so this guarantees the listener fires at least once with real values. + if (hasFocus) { + ViewCompat.requestApplyInsets(window.decorView) + } + } + override fun getDelegate() = BaseContextWrappingDelegate(super.getDelegate()) override fun onResume() { diff --git a/app/src/main/java/com/flowfoundation/wallet/cache/AccountCacheManager.kt b/app/src/main/java/com/flowfoundation/wallet/cache/AccountCacheManager.kt index d525929d..3438ff8d 100644 --- a/app/src/main/java/com/flowfoundation/wallet/cache/AccountCacheManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/cache/AccountCacheManager.kt @@ -9,6 +9,8 @@ import com.flowfoundation.wallet.manager.walletdata.FlowWallet import com.flowfoundation.wallet.utils.* import com.flowfoundation.wallet.utils.error.AccountError import com.flowfoundation.wallet.utils.error.ErrorReporter +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock import kotlinx.serialization.builtins.ListSerializer import kotlinx.serialization.json.Json import java.io.File @@ -18,6 +20,7 @@ object AccountCacheManager{ private val TAG = AccountCacheManager::class.java.simpleName private val file by lazy { File(ACCOUNT_PATH, "${"accounts".hashCode()}") } private val backupFile by lazy { File(ACCOUNT_PATH, "${"accounts_backup".hashCode()}") } + private val writeMutex = Mutex() @WorkerThread fun read(): List? { @@ -29,11 +32,13 @@ object AccountCacheManager{ logd(TAG, "Successfully read from primary cache: ${primaryResult.size} accounts") // Update backup if primary is good ioScope { - try { - backupFile.writeText(file.readText()) - logd(TAG, "Updated backup from validated primary cache") - } catch (e: Exception) { - loge(TAG, "Failed to update backup: $e") + writeMutex.withLock { + try { + backupFile.writeText(file.readText()) + logd(TAG, "Updated backup from validated primary cache") + } catch (e: Exception) { + loge(TAG, "Failed to update backup: $e") + } } } return primaryResult @@ -44,13 +49,15 @@ object AccountCacheManager{ val backupResult = readFromFile(backupFile) if (backupResult != null) { logd(TAG, "Successfully recovered from backup cache: ${backupResult.size} accounts") - // Restore primary from backup + // Restore primary from backup — must go through mutex to avoid racing with cache() ioScope { - try { - file.writeText(backupFile.readText()) - logd(TAG, "Restored primary from repaired backup cache") - } catch (e: Exception) { - loge(TAG, "Failed to restore primary from backup: $e") + writeMutex.withLock { + try { + backupFile.copyTo(file, overwrite = true) + logd(TAG, "Restored primary from repaired backup cache") + } catch (e: Exception) { + loge(TAG, "Failed to restore primary from backup: $e") + } } } return backupResult @@ -124,19 +131,12 @@ object AccountCacheManager{ } fun cache(data: List) { - logd(TAG, "cache() called with ${data.size} accounts") - logd(TAG, "cache() called with accounts: $data") - if (data.isEmpty()) { - logd(TAG, "Warning: Caching empty accounts list") - } else { - logd(TAG, "Caching accounts with usernames: ${data.map { it.userInfo.username }}") - } + logd(TAG, "cache() called with ${data.size} accounts: ${data.map { it.userInfo.username }}") ioScope { - try { - cacheSync(data) - // Create backup copy only after verifying main file integrity - if (file.exists() && file.length() > 0) { - // Verify the written data is valid before creating backup + writeMutex.withLock { + try { + cacheSync(data) + // Create backup copy only after verifying main file integrity val writtenData = readFromFile(file) if (writtenData != null && writtenData.size == data.size) { backupFile.writeText(file.readText()) @@ -144,41 +144,24 @@ object AccountCacheManager{ } else { loge(TAG, "Main cache validation failed, not creating backup. Expected: ${data.size}, Got: ${writtenData?.size}") } + } catch (e: Exception) { + loge(TAG, "Error caching accounts: $e") } - } catch (e: Exception) { - loge(TAG, "Error caching accounts: $e") } } } private fun cacheSync(data: List) { - try { - val str = Json.encodeToString(ListSerializer(Account.serializer()), data) - - // Validate JSON before writing - try { - Json.decodeFromString(ListSerializer(Account.serializer()), str) - } catch (e: Exception) { - loge(TAG, "Generated invalid JSON, not writing to cache: $e") - return - } - + val str = Json.encodeToString(ListSerializer(Account.serializer()), data) + // Atomic write: write to a temp file first, then rename to avoid partial writes + val tempFile = File(ACCOUNT_PATH, "${"accounts".hashCode()}.tmp") + tempFile.writeText(str) + if (!tempFile.renameTo(file)) { + // renameTo can fail across filesystems; fall back to direct write + tempFile.delete() str.saveToFile(file) - logd(TAG, "Successfully cached ${data.size} accounts") - } catch (e: Exception) { - loge(TAG, "Error during cacheSync: $e") - loge(TAG, "Exception type: ${e.javaClass.name}") - e.printStackTrace() - // Log account structure for debugging - if (data.isNotEmpty()) { - val firstAccount = data.first() - loge(TAG, "First account structure: userInfo=${firstAccount.userInfo.javaClass.name}, " + - "wallet=${firstAccount.wallet?.javaClass?.name}, " + - "walletEmojiList=${firstAccount.walletEmojiList?.javaClass?.name}, " + - "walletNodes=${firstAccount.walletNodes.javaClass.name}") - } - throw e } + logd(TAG, "Successfully cached ${data.size} accounts") } fun clearCache() { diff --git a/app/src/main/java/com/flowfoundation/wallet/page/browser/presenter/BrowserPresenter.kt b/app/src/main/java/com/flowfoundation/wallet/page/browser/presenter/BrowserPresenter.kt index 819d3b4d..3b51cd5c 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/browser/presenter/BrowserPresenter.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/browser/presenter/BrowserPresenter.kt @@ -1,8 +1,10 @@ package com.flowfoundation.wallet.page.browser.presenter +import androidx.core.view.ViewCompat +import androidx.core.view.WindowInsetsCompat +import androidx.core.view.updatePadding import com.flowfoundation.wallet.base.activity.BaseActivity import com.flowfoundation.wallet.manager.app.chainNetWorkString -import com.zackratos.ultimatebarx.ultimatebarx.navigationBarHeight import com.zackratos.ultimatebarx.ultimatebarx.statusBarHeight import com.flowfoundation.wallet.base.presenter.BasePresenter import com.flowfoundation.wallet.databinding.LayoutBrowserBinding @@ -35,10 +37,14 @@ class BrowserPresenter( with(binding) { contentWrapper.post { statusBarHolder.layoutParams.height = statusBarHeight - with(root) { - val navBarHeight = if (navigationBarHeight < 50) 0 else navigationBarHeight - setPadding(paddingLeft, paddingTop, paddingRight, paddingBottom + navBarHeight) - } + } + // Use dynamic insets instead of static navigationBarHeight with a threshold. + // The FloatWindow is added directly to activity.window.decorView, so it participates + // in the normal insets dispatch chain and this listener will fire correctly. + ViewCompat.setOnApplyWindowInsetsListener(root) { view, insets -> + val navBar = insets.getInsets(WindowInsetsCompat.Type.navigationBars()) + view.updatePadding(bottom = navBar.bottom) + insets } with(binding) { refreshButton.setOnClickListener { webview()?.reload() } diff --git a/app/src/main/java/com/flowfoundation/wallet/page/common/WebViewActivity.kt b/app/src/main/java/com/flowfoundation/wallet/page/common/WebViewActivity.kt index d0379cc9..137bb25b 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/common/WebViewActivity.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/common/WebViewActivity.kt @@ -15,6 +15,7 @@ class WebViewActivity : BaseActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_webview) + findViewById(R.id.webview).apply { loadUrl(this@WebViewActivity.url!!) } @@ -37,4 +38,4 @@ class WebViewActivity : BaseActivity() { }) } } -} \ No newline at end of file +} diff --git a/app/src/main/java/com/flowfoundation/wallet/page/main/MainActivity.kt b/app/src/main/java/com/flowfoundation/wallet/page/main/MainActivity.kt index 479c654e..31719269 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/main/MainActivity.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/main/MainActivity.kt @@ -7,10 +7,6 @@ import android.content.BroadcastReceiver import android.content.IntentFilter import android.os.Bundle import androidx.core.view.GravityCompat -import androidx.core.view.ViewCompat -import androidx.core.view.WindowCompat -import androidx.core.view.WindowInsetsCompat -import androidx.core.view.updatePadding import androidx.lifecycle.ViewModelProvider import androidx.localbroadcastmanager.content.LocalBroadcastManager import com.flowfoundation.wallet.base.activity.BaseActivity @@ -61,13 +57,6 @@ class MainActivity : BaseActivity() { UltimateBarX.with(this).fitWindow(false).light(!isNightMode(this)).applyStatusBar() - WindowCompat.setDecorFitsSystemWindows(window, false) - - ViewCompat.setOnApplyWindowInsetsListener(binding.root) { _, windowInsets -> - val systemBarsInsets = windowInsets.getInsets(WindowInsetsCompat.Type.systemBars()) - binding.navigationView.updatePadding(bottom = systemBarsInsets.bottom) - windowInsets - } contentPresenter = MainContentPresenter(this, binding) setupDrawerLayoutCompose(binding.drawerLayout) binding.drawerLayout.close() diff --git a/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt b/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt index 3d8b1179..ce75d976 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt @@ -53,7 +53,6 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { } fun loadData(refreshBalance: Boolean = false) { - loadEvmStatus() refreshWalletList(refreshBalance) } @@ -155,6 +154,7 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { } _accounts.value = filteredAccounts + loadEvmStatus() if (refreshBalance) { fetchAllBalances(addressList, pendingEvmAddresses) } diff --git a/app/src/main/java/com/flowfoundation/wallet/reactnative/ReactNativeActivity.kt b/app/src/main/java/com/flowfoundation/wallet/reactnative/ReactNativeActivity.kt index cc375175..c3ad8740 100644 --- a/app/src/main/java/com/flowfoundation/wallet/reactnative/ReactNativeActivity.kt +++ b/app/src/main/java/com/flowfoundation/wallet/reactnative/ReactNativeActivity.kt @@ -2,6 +2,11 @@ package com.flowfoundation.wallet.reactnative import android.content.Context import android.content.Intent import android.os.Bundle +import android.view.View +import androidx.core.view.ViewCompat +import androidx.core.view.WindowCompat +import androidx.core.view.WindowInsetsCompat +import androidx.core.view.updatePadding import com.facebook.react.ReactActivity import com.facebook.react.ReactActivityDelegate import com.facebook.react.defaults.DefaultReactActivityDelegate @@ -86,9 +91,21 @@ class ReactNativeActivity : ReactActivity() { } override fun onCreate(savedInstanceState: Bundle?) { + // Opt into edge-to-edge. On API 35+ this is enforced by the system; on older APIs + // we set it explicitly so the behavior is consistent across all versions. + WindowCompat.setDecorFitsSystemWindows(window, false) logd(TAG, "onCreate called") super.onCreate(savedInstanceState) + // ReactActivity doesn't extend BaseActivity, so we apply nav bar insets here directly. + // This pads android.R.id.content so the React Native root view doesn't go behind the nav bar. + val contentView = window.decorView.findViewById(android.R.id.content) + ViewCompat.setOnApplyWindowInsetsListener(window.decorView) { _, insets -> + val navBar = insets.getInsets(WindowInsetsCompat.Type.navigationBars()) + contentView?.updatePadding(bottom = navBar.bottom) + insets + } + // Log the intent extras for debugging intent?.let { logd(TAG, "Intent extras:") @@ -106,6 +123,14 @@ class ReactNativeActivity : ReactActivity() { setIntent(intent) } + override fun onWindowFocusChanged(hasFocus: Boolean) { + super.onWindowFocusChanged(hasFocus) + // Re-trigger insets dispatch once the window is visible and has valid insets. + if (hasFocus) { + ViewCompat.requestApplyInsets(window.decorView) + } + } + override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) { super.onActivityResult(requestCode, resultCode, data) diff --git a/app/src/main/res/layout/activity_webview.xml b/app/src/main/res/layout/activity_webview.xml index f4c09c66..96f4b4a3 100644 --- a/app/src/main/res/layout/activity_webview.xml +++ b/app/src/main/res/layout/activity_webview.xml @@ -1,10 +1,17 @@ - \ No newline at end of file + android:layout_width="0dp" + android:layout_height="0dp" + app:layout_constraintBottom_toBottomOf="parent" + app:layout_constraintEnd_toEndOf="parent" + app:layout_constraintStart_toStartOf="parent" + app:layout_constraintTop_toTopOf="parent" /> + + From c1b8391fbb64f7d09ec78d3d9d0350d88c04ef2e Mon Sep 17 00:00:00 2001 From: Meng Date: Fri, 6 Mar 2026 02:13:18 +0800 Subject: [PATCH 05/27] fix: key rotaion and migration after key storage migration & switch local key account --- app/build.gradle | 2 +- .../wallet/cache/AccountCacheManager.kt | 10 ++- .../wallet/firebase/FirebaseUtils.kt | 4 +- .../wallet/manager/account/AccountManager.kt | 83 ++++++++++++------- .../manager/key/CryptoProviderManager.kt | 43 +++++++++- .../manager/key/storage/KeyStorageManager.kt | 35 +++++++- .../key/storage/KeyStorageMigration.kt | 12 ++- .../manager/wallet/WalletCreationHelper.kt | 42 ++++++---- .../dialog/profile/ProfileSwitchDialog.kt | 27 ++---- .../viewmodel/KeyStoreRestoreViewModel.kt | 30 +++---- .../mnemonic/RestoreMnemonicViewModel.kt | 61 +++++++++++++- .../presenter/RestoreMnemonicScreen.kt | 18 +++- .../reactnative/bridge/NativeFRWBridge.kt | 31 +++++++ .../bridge/handlers/AccountBridgeHandler.kt | 46 ++++++---- app/src/main/res/values/strings.xml | 1 + gradle.properties | 2 +- 16 files changed, 330 insertions(+), 117 deletions(-) diff --git a/app/build.gradle b/app/build.gradle index 40028dd7..c7c519ca 100644 --- a/app/build.gradle +++ b/app/build.gradle @@ -352,7 +352,7 @@ dependencies { api fileTree(dir: "libs", include: ["*.aar", "*.jar"], exclude: ["trustwalletcore.aar"]) // Fetch Flow Wallet Kit from GitHub Packages - implementation 'com.github.onflow.flow-wallet-kit:flow-wallet-android:0.2.4' + implementation 'com.github.onflow.flow-wallet-kit:flow-wallet-android:0.2.5' implementation "org.jetbrains.kotlin:kotlin-stdlib:1.9.22" /** Android Architecture **/ implementation 'androidx.core:core-ktx:1.13.1' diff --git a/app/src/main/java/com/flowfoundation/wallet/cache/AccountCacheManager.kt b/app/src/main/java/com/flowfoundation/wallet/cache/AccountCacheManager.kt index 3438ff8d..a3414404 100644 --- a/app/src/main/java/com/flowfoundation/wallet/cache/AccountCacheManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/cache/AccountCacheManager.kt @@ -5,6 +5,7 @@ import com.flowfoundation.wallet.manager.account.Account import com.flowfoundation.wallet.manager.account.AccountManager.walletNodes import com.flowfoundation.wallet.manager.account.AccountWalletManager import com.flowfoundation.wallet.manager.app.chainNetWorkString +import com.flowfoundation.wallet.manager.key.storage.KeyStorageManager import com.flowfoundation.wallet.manager.walletdata.FlowWallet import com.flowfoundation.wallet.utils.* import com.flowfoundation.wallet.utils.error.AccountError @@ -95,9 +96,14 @@ object AccountCacheManager{ // Validate account data val validAccounts = result.filter { account -> + val uid = account.wallet?.id ?: "" val isValid = account.userInfo.username.isNotBlank() && - (!account.keyStoreInfo.isNullOrBlank() || !account.prefix - .isNullOrBlank() || AccountWalletManager.isHDWallet(account.wallet?.id ?: "")) + (!account.keyStoreInfo.isNullOrBlank() || + !account.prefix.isNullOrBlank() || + AccountWalletManager.isHDWallet(uid) || + KeyStorageManager.hasSeedPhrase(uid) || + KeyStorageManager.hasPrivateKey(uid) || + KeyStorageManager.hasAndroidKeystorePrefix(uid)) if (!isValid) { logd(TAG, "Invalid account found: ${account.userInfo.username}") } diff --git a/app/src/main/java/com/flowfoundation/wallet/firebase/FirebaseUtils.kt b/app/src/main/java/com/flowfoundation/wallet/firebase/FirebaseUtils.kt index 51149ba4..4105a739 100644 --- a/app/src/main/java/com/flowfoundation/wallet/firebase/FirebaseUtils.kt +++ b/app/src/main/java/com/flowfoundation/wallet/firebase/FirebaseUtils.kt @@ -1,7 +1,7 @@ package com.flowfoundation.wallet.firebase import android.app.Application -import com.google.firebase.BuildConfig +import com.flowfoundation.wallet.BuildConfig import com.google.firebase.FirebaseApp import com.google.firebase.appcheck.FirebaseAppCheck import com.google.firebase.appcheck.debug.DebugAppCheckProviderFactory @@ -32,4 +32,4 @@ private fun setupAppCheck() { logd(TAG, "AppCheck token: $token") } } -} \ No newline at end of file +} diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt index 5104a699..9fba0229 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt @@ -157,7 +157,7 @@ object AccountManager { fun getSwitchAccountList(): List { logd(TAG, "getSwitchAccountList() called") - logd(TAG, "Current accounts: $accounts") + logd(TAG, "Current accounts: ${accounts.map { it.userInfo.username }}") val list = mutableListOf() list.addAll(accounts) @@ -193,9 +193,10 @@ object AccountManager { return orphanUids.map { uid -> val akPrefix = KeyStorageManager.getAndroidKeystorePrefix(uid) + val address = KeyStorageManager.getWalletAddress(uid) ?: "" LocalSwitchAccount( - username = uid, - address = "", + username = address, + address = address, userId = uid, prefix = akPrefix ) @@ -207,7 +208,7 @@ object AccountManager { WalletManager.clear() currentAccount = account - logd(TAG, "Account added. Current account is now: $currentAccount") + logd(TAG, "Account added. Current account is now: ${currentAccount?.userInfo?.username.orEmpty()}") accounts.removeAll { it.userInfo.username == account.userInfo.username } accounts.add(account) accounts.forEach { @@ -269,9 +270,6 @@ object AccountManager { logd(TAG, "Removing active account and clearing all related state") - // Set Firebase to anonymous before clearing state - setToAnonymous() - // Clear the account from the list val account = accounts.removeAt(index) logd(TAG, "Removed account: ${account.userInfo.username}") @@ -289,7 +287,6 @@ object AccountManager { AccountCacheManager.cache(Accounts().apply { addAll(accounts) }) logd(TAG, "Cleared account cache") - // Clear WalletManager state try { WalletManager.clear() @@ -326,14 +323,20 @@ object AccountManager { setUploadedAddressSet(emptySet()) logd(TAG, "Cleared uploaded address set") - uiScope { - // Clear user cache - clearUserCache() - logd(TAG, "Cleared user cache") - - // Navigate to main activity (which should show the get started screen) - logd(TAG, "Relaunching MainActivity after account reset") - MainActivity.relaunch(Env.getApp(), true) + val nextAccount = accounts.firstOrNull() + if (nextAccount != null) { + // Switch to the first remaining account so Firebase re-authenticates properly. + // setToAnonymous() is called inside switchAccount() before the new login. + logd(TAG, "Remaining accounts found, switching to: ${nextAccount.userInfo.username}") + switch(nextAccount) {} + } else { + // No remaining accounts — go back to get started screen. + setToAnonymous() + uiScope { + clearUserCache() + logd(TAG, "Relaunching MainActivity after account reset") + MainActivity.relaunch(Env.getApp(), true) + } } } } @@ -441,14 +444,14 @@ object AccountManager { } fun list(): List { - logd(TAG, "list() called. Accounts: $accounts") + logd(TAG, "list() called. Accounts: ${accounts.map { it.userInfo.username }}") return accounts } private var isSwitching = false fun switch(account: Account, onFinish: () -> Unit) { - logd(TAG, "switch() called. Switching to account: $account") + logd(TAG, "switch() called. Switching to account: ${account.userInfo.username}") // Check if we're already on this account if (account.isActive && currentAccount?.userInfo?.username == account.userInfo.username) { @@ -489,7 +492,7 @@ object AccountManager { if (isSuccess) { isSwitching = false currentAccount = account - logd(TAG, "Account switch successful. Current account updated to: $currentAccount") + logd(TAG, "Account switch successful. Current account updated to: ${currentAccount?.userInfo?.username}") accounts.forEach { it.isActive = it.userInfo.username == account.userInfo.username } @@ -504,7 +507,7 @@ object AccountManager { loge(TAG, "Account switch failed, showing error toast") toast(msgRes = R.string.resume_login_error, duration = Toast.LENGTH_LONG) } - logd(TAG, "switch() completed. Current account: $currentAccount") + logd(TAG, "switch() completed. Current account: ${currentAccount?.userInfo?.username}") onFinish() } } @@ -657,7 +660,7 @@ object AccountManager { } private fun dispatchListeners(account: Account) { - logd(TAG, "dispatchListeners: $account") + logd(TAG, "dispatchListeners: ${account.userInfo.username}") uiScope { listeners.removeAll { it.get() == null } listeners.forEach { it.get()?.onAccountUpdate(account) } @@ -760,21 +763,43 @@ object AccountManager { val resp = service.loginV4(loginRequest) if (resp.data?.customToken.isNullOrBlank()) { loge(tag = "SWITCH_ACCOUNT", msg = "get customToken failed :: ${resp.data?.customToken}") + loge(tag = "SWITCH_ACCOUNT", msg = "Response status: ${resp.status}, message: ${resp.message}") callback.invoke(false) } else { firebaseLogin(resp.data.customToken) { isSuccess -> if (isSuccess) { setRegistered() - if (switchAccount.prefix == null) { - Wallet.store().resume() - } else { - firebaseUid()?.let { userId -> - userPrefixes.removeAll { it.userId == userId} - userPrefixes.add(UserPrefix(userId, switchAccount.prefix)) - UserPrefixCacheManager.cache(UserPrefixes().apply { addAll(userPrefixes) }) + // Fetch user info and persist the account so it survives MainActivity relaunch. + // Without this, AccountManager.init() reads an empty cache after relaunch. + ioScope { + try { + val userInfo = service.userInfo().data + val userId = firebaseUid() ?: "" + clearUserCache() + add(Account( + userInfo = userInfo, + wallet = WalletListData(id = userId, username = userInfo.username, wallets = null), + prefix = switchAccount.prefix + )) + logd(TAG, "LocalSwitchAccount: account stored for uid: $userId") + + if (switchAccount.prefix != null) { + // Hardware-backed key: persist prefix so CryptoProviderManager + // can reconstruct the provider after relaunch. + userPrefixes.removeAll { it.userId == userId } + userPrefixes.add(UserPrefix(userId, switchAccount.prefix)) + UserPrefixCacheManager.cache(UserPrefixes().apply { addAll(userPrefixes) }) + } else if (!KeyStorageManager.hasPrivateKey(switchAccount.userId ?: "")) { + // HD wallet (seed phrase) account only — not private-key import. + // Mirrors the condition in switchAccount(Account): + // account.prefix == null && account.keyStoreInfo == null + Wallet.store().resume() + } + } catch (e: Exception) { + loge(TAG, "LocalSwitchAccount: failed to fetch/store user info: ${e.message}") } + callback.invoke(true) } - callback.invoke(true) } else { loge(tag = "SWITCH_ACCOUNT", msg = "get firebase login failed :: ${resp.data.customToken}") callback.invoke(false) diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/key/CryptoProviderManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/key/CryptoProviderManager.kt index 4d9d15f2..681c97dc 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/key/CryptoProviderManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/key/CryptoProviderManager.kt @@ -117,7 +117,8 @@ object CryptoProviderManager { if (privateKey != null) { logd(TAG, "New storage: found private key object for uid: $uid") val keyWallet = WalletFactory.createKeyWallet(privateKey, setOf(ChainId.Mainnet, ChainId.Testnet), storage) as KeyWallet - return PrivateKeyCryptoProvider(privateKey, keyWallet) + val address = account.firstFlowWalletAddress() ?: "" + return runBlocking { createPrivateKeyCryptoProvider(privateKey, keyWallet, address) } } // AKP prefix from new storage falls through to prefix-based branch below } @@ -276,7 +277,8 @@ object CryptoProviderManager { if (privateKey != null) { logd("CryptoProviderManager", "Switch account new storage: private key object for uid: $switchUid") val keyWallet = WalletFactory.createKeyWallet(privateKey, setOf(ChainId.Mainnet, ChainId.Testnet), storage) as KeyWallet - return PrivateKeyCryptoProvider(privateKey, keyWallet) + val address = account.firstFlowWalletAddress() ?: "" + return runBlocking { createPrivateKeyCryptoProvider(privateKey, keyWallet, address) } } } @@ -427,7 +429,8 @@ object CryptoProviderManager { if (privateKey != null) { logd("CryptoProviderManager", "LocalSwitchAccount new storage: private key object for uid: $localUid") val keyWallet = WalletFactory.createKeyWallet(privateKey, setOf(ChainId.Mainnet, ChainId.Testnet), storage) as KeyWallet - return PrivateKeyCryptoProvider(privateKey, keyWallet) + val address = switchAccount.address + return runBlocking { createPrivateKeyCryptoProvider(privateKey, keyWallet, address) } } } @@ -461,7 +464,8 @@ object CryptoProviderManager { ) as KeyWallet // For prefix-based accounts, we use PrivateKeyCryptoProvider instead of BackupCryptoProvider - PrivateKeyCryptoProvider(privateKey, wallet) + val address = switchAccount.address + runBlocking { createPrivateKeyCryptoProvider(privateKey, wallet, address) } } // Handle other accounts @@ -486,6 +490,37 @@ object CryptoProviderManager { } } + /** + * Create a PrivateKeyCryptoProvider by resolving the correct signing and hashing algorithms + * from the on-chain account keys. Falls back to ECDSA_P256 defaults if the lookup fails. + */ + @OptIn(ExperimentalStdlibApi::class) + private suspend fun createPrivateKeyCryptoProvider( + privateKey: PrivateKey, + keyWallet: KeyWallet, + address: String + ): PrivateKeyCryptoProvider { + if (address.isNotEmpty()) { + try { + val onChainAccount = FlowCadenceApi.getAccount(address) + val onChainKeys = onChainAccount.keys?.filter { !it.revoked } ?: emptyList() + + for (sigAlgo in listOf(SigningAlgorithm.ECDSA_P256, SigningAlgorithm.ECDSA_secp256k1)) { + val pubKey = privateKey.publicKey(sigAlgo)?.toHexString() ?: continue + val matched = onChainKeys.find { isKeyMatchRobust(pubKey, it.publicKey) } + if (matched != null) { + logd(TAG, "createPrivateKeyCryptoProvider: matched on-chain key sigAlgo=$sigAlgo hashAlgo=${matched.hashingAlgorithm}") + return PrivateKeyCryptoProvider(privateKey, keyWallet, sigAlgo, matched.hashingAlgorithm) + } + } + logd(TAG, "createPrivateKeyCryptoProvider: no on-chain match for $address, using defaults") + } catch (e: Exception) { + logd(TAG, "createPrivateKeyCryptoProvider: on-chain lookup failed: ${e.message}, using defaults") + } + } + return PrivateKeyCryptoProvider(privateKey, keyWallet, SigningAlgorithm.ECDSA_P256) + } + fun clear() { cryptoProvider = null } diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/key/storage/KeyStorageManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/key/storage/KeyStorageManager.kt index 1a9de3e9..083d4468 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/key/storage/KeyStorageManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/key/storage/KeyStorageManager.kt @@ -135,7 +135,7 @@ object KeyStorageManager { fun hasSeedPhrase(uid: String): Boolean = spStorage.get(uid) != null /** Returns all UIDs that have a stored seed phrase. */ - fun getAllSeedPhraseUids(): List = spStorage.allKeys + fun getAllSeedPhraseUids(): List = spStorage.allKeys.filter { !it.endsWith("_metadata") } // ─── Private Key (filesDir/frw_pk_storage/{uid}) ──────────────────────── @@ -167,8 +167,18 @@ object KeyStorageManager { fun hasPrivateKey(uid: String): Boolean = pkStorage.get(uid) != null + /** Removes the private key entry for [uid] from pkStorage. No-op if not present. */ + fun deletePrivateKey(uid: String) { + try { + pkStorage.remove(uid) + logd(TAG, "Deleted private key for uid: $uid") + } catch (e: Exception) { + loge(TAG, "Failed to delete private key for uid $uid: ${e.message}") + } + } + /** Returns all UIDs that have a stored private key. */ - fun getAllPrivateKeyUids(): List = pkStorage.allKeys + fun getAllPrivateKeyUids(): List = pkStorage.allKeys.filter { !it.endsWith("_metadata") } // ─── Android Keystore Prefix (filesDir/frw_akp_storage/{uid}) ─────────── @@ -192,5 +202,24 @@ object KeyStorageManager { CryptoProviderKey.hasProviderIdentifier(uid, akpStorage) /** Returns all UIDs that have a stored Android Keystore prefix. */ - fun getAllAndroidKeystoreUids(): List = akpStorage.allKeys + fun getAllAndroidKeystoreUids(): List = akpStorage.allKeys.filter { !it.endsWith("_metadata") } + + // ─── Wallet Address index (plain SharedPreferences, no encryption) ──────────── + // Stores uid → primary Flow wallet address for display in LocalSwitchAccount. + // Intentionally separate from key material — no master password, no ChaCha20. + + private const val ADDR_PREFS_NAME = "frw_uid_address_map" + + private val addrPrefs: SharedPreferences by lazy { + Env.getApp().getSharedPreferences(ADDR_PREFS_NAME, Context.MODE_PRIVATE) + } + + fun saveWalletAddress(uid: String, address: String) { + addrPrefs.edit { putString(uid, address) } + logd(TAG, "Saved wallet address for uid: $uid") + } + + fun getWalletAddress(uid: String): String? = addrPrefs.getString(uid, null) + + fun hasWalletAddress(uid: String): Boolean = addrPrefs.contains(uid) } diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/key/storage/KeyStorageMigration.kt b/app/src/main/java/com/flowfoundation/wallet/manager/key/storage/KeyStorageMigration.kt index 70ae570e..2626b67b 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/key/storage/KeyStorageMigration.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/key/storage/KeyStorageMigration.kt @@ -3,6 +3,7 @@ package com.flowfoundation.wallet.manager.key.storage import com.flowfoundation.wallet.manager.account.Account import com.flowfoundation.wallet.manager.account.AccountManager import com.flowfoundation.wallet.manager.account.AccountWalletManager +import com.flowfoundation.wallet.manager.account.firstFlowWalletAddress import com.flowfoundation.wallet.page.restore.keystore.model.KeystoreAddress import com.flowfoundation.wallet.utils.logd import com.flowfoundation.wallet.utils.loge @@ -77,6 +78,15 @@ object KeyStorageMigration { // Case 4: plain HD-wallet mnemonic account else -> migrateFromAccountWalletManager(uid) } + + // Save wallet address independently (idempotent, no master password needed) + if (!KeyStorageManager.hasWalletAddress(uid)) { + val address = account.firstFlowWalletAddress() + if (!address.isNullOrBlank()) { + KeyStorageManager.saveWalletAddress(uid, address) + logd(TAG, "Saved wallet address for uid: $uid") + } + } } private fun migrateFromKeyStoreInfo(uid: String, keyStoreInfo: String) { @@ -104,7 +114,7 @@ object KeyStorageMigration { } // privateKey present → private-key import - !ks.privateKey.isNullOrBlank() -> { + ks.privateKey.isNotBlank() -> { if (!KeyStorageManager.hasPrivateKey(uid)) { val hex = ks.privateKey.removePrefix("0x") KeyStorageManager.savePrivateKey(uid, hex) diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletCreationHelper.kt b/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletCreationHelper.kt index 91da2345..babb9f93 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletCreationHelper.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletCreationHelper.kt @@ -60,7 +60,9 @@ object WalletCreationHelper { val privateKey = KeyStorageManager.getPrivateKeyObject(userId) if (privateKey != null) { logd(TAG, "New storage: private key object found for uid: $userId") - return createWalletFromPrivateKey(privateKey, isCurrentAccount) + val wallet = createWalletFromPrivateKey(privateKey, isCurrentAccount) + checkAndNotifyMnemonicRestoreIfNeeded(isCurrentAccount) + return wallet } // Android Keystore prefix → reconstruct provider at app layer val akPrefix = KeyStorageManager.getAndroidKeystorePrefix(userId) @@ -116,7 +118,6 @@ object WalletCreationHelper { val uid = if (isCurrentAccount) firebaseUid() else userId if (!uid.isNullOrBlank()) { val decryptedMnemonic = EncryptedMnemonicUtils.decrypt(ks.encryptedMnemonic, uid) - logd(TAG, "Decrypted mnemonic: $decryptedMnemonic") if (!decryptedMnemonic.isNullOrBlank()) { // Create HD Wallet using the decrypted mnemonic val seedPhraseKey = SeedPhraseKey( @@ -141,21 +142,7 @@ object WalletCreationHelper { } } else { logd(TAG, "No encrypted mnemonic found, using private key mode") - try { - val service = retrofitApi().create(ApiService::class.java) - val response = service.checkUserMnemonicStatus() - logd(TAG, "Checked user mnemonic status: ${response.data}") - if (response.data?.isExist == true) { - logd(TAG, "Mnemonic restore required. Disabling EOA and notifying UI.") - if (isCurrentAccount) { - WalletManager.setEoaDisabled(true) - LocalBroadcastManager.getInstance(com.flowfoundation.wallet.utils.Env.getApp()) - .sendBroadcast(android.content.Intent("ACTION_RESTORE_MNEMONIC")) - } - } - } catch (e: Exception) { - logd(TAG, "Error checking mnemonic status: ${e.message}") - } + checkAndNotifyMnemonicRestoreIfNeeded(isCurrentAccount) } // Fallback to private key mode @@ -262,6 +249,27 @@ object WalletCreationHelper { return WalletFactory.createKeyWallet(privateKey, setOf(ChainId.Mainnet, ChainId.Testnet), storage) } + /** + * Checks the server-side mnemonic status and fires ACTION_RESTORE_MNEMONIC if the user + * has no mnemonic backup yet. Only runs for the current account to avoid spurious prompts. + */ + private suspend fun checkAndNotifyMnemonicRestoreIfNeeded(isCurrentAccount: Boolean) { + if (!isCurrentAccount) return + try { + val service = retrofitApi().create(ApiService::class.java) + val response = service.checkUserMnemonicStatus() + logd(TAG, "Checked user mnemonic status: ${response.data}") + if (response.data?.isExist == true) { + logd(TAG, "Mnemonic restore required. Disabling EOA and notifying UI.") + WalletManager.setEoaDisabled(true) + LocalBroadcastManager.getInstance(com.flowfoundation.wallet.utils.Env.getApp()) + .sendBroadcast(android.content.Intent("ACTION_RESTORE_MNEMONIC")) + } + } catch (e: Exception) { + logd(TAG, "Error checking mnemonic status: ${e.message}") + } + } + /** * Create wallet from keystore private key * Private key imports cannot derive EOA addresses (no mnemonic available). diff --git a/app/src/main/java/com/flowfoundation/wallet/page/dialog/profile/ProfileSwitchDialog.kt b/app/src/main/java/com/flowfoundation/wallet/page/dialog/profile/ProfileSwitchDialog.kt index d0696658..d3c9813e 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/dialog/profile/ProfileSwitchDialog.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/dialog/profile/ProfileSwitchDialog.kt @@ -262,14 +262,10 @@ private fun LocalSwitchAccountItem( ConstraintLayout( modifier = Modifier .fillMaxWidth() - .background( - color = colorResource(id = R.color.bg_card), - shape = RoundedCornerShape(16.dp) - ) - .padding(18.dp) + .padding(vertical = 20.dp) .clickable(onClick = onClick) ) { - val (icon, name, address) = createRefs() + val (icon, name) = createRefs() // Placeholder icon Icon( @@ -278,7 +274,7 @@ private fun LocalSwitchAccountItem( tint = colorResource(id = R.color.icon), modifier = Modifier .constrainAs(icon) { - top.linkTo(parent.top, 8.dp) + top.linkTo(parent.top) start.linkTo(parent.start) } .size(40.dp) @@ -289,27 +285,16 @@ private fun LocalSwitchAccountItem( text = account.username, color = colorResource(id = R.color.text_1), fontSize = 14.sp, - fontWeight = FontWeight.SemiBold, + fontWeight = FontWeight.Bold, modifier = Modifier .constrainAs(name) { top.linkTo(icon.top) + bottom.linkTo(icon.bottom) start.linkTo(icon.end, 12.dp) - end.linkTo(parent.end, 12.dp) + end.linkTo(parent.end) width = Dimension.fillToConstraints } ) - - // Address - Text( - text = account.address, - color = colorResource(id = R.color.text_2), - fontSize = 12.sp, - modifier = Modifier - .constrainAs(address) { - top.linkTo(name.bottom, 4.dp) - start.linkTo(name.start) - } - ) } } diff --git a/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/viewmodel/KeyStoreRestoreViewModel.kt b/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/viewmodel/KeyStoreRestoreViewModel.kt index c6480933..db20ee3f 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/viewmodel/KeyStoreRestoreViewModel.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/viewmodel/KeyStoreRestoreViewModel.kt @@ -289,8 +289,8 @@ class KeyStoreRestoreViewModel : ViewModel() { fun importPrivateKey(privateKey: String, address: String) { loadingLiveData.postValue(true) restoreType = RestoreType.PRIVATE_KEY - try { - ioScope { + ioScope { + try { val storage = getStorage() val key = PrivateKey.create(storage).apply { logd("KeyStoreRestoreViewModel", "Created new PrivateKey instance") @@ -321,12 +321,12 @@ class KeyStoreRestoreViewModel : ViewModel() { p1PublicKey ?: "" ) } + } catch (e: Exception) { + e.printStackTrace() + ErrorReporter.reportWithMixpanel(BackupError.PRIVATE_KEY_RESTORE_FAILED, e) + loadingLiveData.postValue(false) + toast(msgRes = R.string.restore_failed) } - } catch (e: Exception) { - e.printStackTrace() - ErrorReporter.reportWithMixpanel(BackupError.PRIVATE_KEY_RESTORE_FAILED, e) - loadingLiveData.postValue(false) - toast(msgRes = R.string.restore_failed) } } @@ -335,8 +335,8 @@ class KeyStoreRestoreViewModel : ViewModel() { loadingLiveData.postValue(true) restoreType = RestoreType.SEED_PHRASE currentMnemonic = mnemonic // Store mnemonic for use in KeystoreAddress creation - try { - ioScope { + ioScope { + try { val storage = getStorage() val seedPhraseKey = SeedPhraseKey( mnemonicString = mnemonic, @@ -364,12 +364,12 @@ class KeyStoreRestoreViewModel : ViewModel() { p1PublicKey ?: "" ) } + } catch (e: Exception) { + e.printStackTrace() + ErrorReporter.reportWithMixpanel(BackupError.SEED_PHRASE_RESTORE_FAILED, e) + loadingLiveData.postValue(false) + toast(msgRes = R.string.restore_failed) } - } catch (e: Exception) { - e.printStackTrace() - ErrorReporter.reportWithMixpanel(BackupError.SEED_PHRASE_RESTORE_FAILED, e) - loadingLiveData.postValue(false) - toast(msgRes = R.string.restore_failed) } } @@ -655,6 +655,7 @@ class KeyStoreRestoreViewModel : ViewModel() { val account = AccountManager.list() .firstOrNull { it.containsFlowWalletAddress(currentKeyStoreAddress?.address ?: "") } if (account != null) { + loadingLiveData.postValue(false) AccountManager.switch(account) {} return } @@ -1043,6 +1044,7 @@ class KeyStoreRestoreViewModel : ViewModel() { val account = AccountManager.list() .firstOrNull { it.containsFlowWalletAddress(keystoreAddress.address) } if (account != null) { + loadingLiveData.postValue(false) AccountManager.switch(account) {} return } diff --git a/app/src/main/java/com/flowfoundation/wallet/page/restore/mnemonic/RestoreMnemonicViewModel.kt b/app/src/main/java/com/flowfoundation/wallet/page/restore/mnemonic/RestoreMnemonicViewModel.kt index 766c5470..bf4a8ed4 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/restore/mnemonic/RestoreMnemonicViewModel.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/restore/mnemonic/RestoreMnemonicViewModel.kt @@ -1,27 +1,44 @@ package com.flowfoundation.wallet.page.restore.mnemonic import androidx.lifecycle.ViewModel +import com.flow.wallet.keys.SeedPhraseKey import com.flowfoundation.wallet.firebase.auth.firebaseUid import com.flowfoundation.wallet.manager.account.AccountManager +import com.flowfoundation.wallet.manager.account.firstFlowWalletAddress +import com.flowfoundation.wallet.manager.key.storage.KeyStorageManager import com.flowfoundation.wallet.manager.wallet.WalletManager import com.flowfoundation.wallet.manager.walletdata.WalletDataManager import com.flowfoundation.wallet.page.restore.keystore.model.KeystoreAddress +import com.flowfoundation.wallet.utils.Env.getStorage import com.flowfoundation.wallet.utils.ioScope +import com.flowfoundation.wallet.utils.loge import com.flowfoundation.wallet.utils.secret.EncryptedMnemonicUtils +import com.flowfoundation.wallet.wallet.DERIVATION_PATH import com.google.gson.Gson import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.StateFlow import kotlinx.coroutines.flow.asStateFlow +import org.onflow.flow.models.SigningAlgorithm import wallet.core.jni.HDWallet class RestoreMnemonicViewModel : ViewModel() { + private val TAG = "RestoreMnemonicViewModel" + private val _isRestoring = MutableStateFlow(false) val isRestoring: StateFlow = _isRestoring.asStateFlow() private val _restoreSuccess = MutableStateFlow(false) val restoreSuccess: StateFlow = _restoreSuccess.asStateFlow() + private val _mnemonicMismatch = MutableStateFlow(false) + val mnemonicMismatch: StateFlow = _mnemonicMismatch.asStateFlow() + + fun resetMnemonicMismatch() { + _mnemonicMismatch.value = false + } + + @OptIn(ExperimentalStdlibApi::class) fun restoreMnemonic(mnemonic: String) { if (!validateMnemonic(mnemonic)) { // Should handle validation error in UI @@ -37,11 +54,41 @@ class RestoreMnemonicViewModel : ViewModel() { return@ioScope } + val currentKeyStoreInfo = currentAccount.keyStoreInfo + + // Validate that the mnemonic derives the same public key as stored in keyStoreInfo + if (!currentKeyStoreInfo.isNullOrBlank()) { + try { + val ks = Gson().fromJson(currentKeyStoreInfo, KeystoreAddress::class.java) + val seedPhraseKey = SeedPhraseKey( + mnemonicString = mnemonic, + passphrase = "", + derivationPath = DERIVATION_PATH, + storage = getStorage() + ) + val derivedPubKey = when (ks.signAlgo) { + SigningAlgorithm.ECDSA_secp256k1.cadenceIndex -> + seedPhraseKey.publicKey(SigningAlgorithm.ECDSA_secp256k1)?.toHexString()?.removePrefix("04") + else -> // ECDSA_P256 + seedPhraseKey.publicKey(SigningAlgorithm.ECDSA_P256)?.toHexString()?.removePrefix("04") + } + val storedPubKey = ks.publicKey.removePrefix("0x").lowercase() + if (derivedPubKey == null || !derivedPubKey.equals(storedPubKey, ignoreCase = true)) { + _mnemonicMismatch.value = true + _isRestoring.value = false + return@ioScope + } + } catch (e: Exception) { + loge(TAG, "Failed to validate mnemonic public key: ${e.message}") + _isRestoring.value = false + return@ioScope + } + } + // Encrypt mnemonic val encryptedMnemonic = EncryptedMnemonicUtils.encrypt(mnemonic, uid) // Update Account keystore info - val currentKeyStoreInfo = currentAccount.keyStoreInfo if (!currentKeyStoreInfo.isNullOrBlank()) { try { // Use atomic update to ensure keystoreInfo is updated safely @@ -61,6 +108,18 @@ class RestoreMnemonicViewModel : ViewModel() { WalletManager.clear() WalletDataManager.updateCurrentAccount() + // Sync mnemonic to independent key storage and remove redundant private key entry + try { + KeyStorageManager.saveSeedPhrase(uid, mnemonic) + KeyStorageManager.deletePrivateKey(uid) + val address = AccountManager.get()?.firstFlowWalletAddress() + if (!address.isNullOrBlank()) { + KeyStorageManager.saveWalletAddress(uid, address) + } + } catch (e: Exception) { + loge(TAG, "KeyStorageManager sync failed: ${e.message}") + } + _restoreSuccess.value = true } catch (e: Exception) { e.printStackTrace() diff --git a/app/src/main/java/com/flowfoundation/wallet/page/restore/mnemonic/presenter/RestoreMnemonicScreen.kt b/app/src/main/java/com/flowfoundation/wallet/page/restore/mnemonic/presenter/RestoreMnemonicScreen.kt index 2c36eb8f..cc972c26 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/restore/mnemonic/presenter/RestoreMnemonicScreen.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/restore/mnemonic/presenter/RestoreMnemonicScreen.kt @@ -35,6 +35,7 @@ import androidx.compose.runtime.setValue import androidx.compose.ui.Modifier import androidx.compose.ui.graphics.Color import androidx.compose.ui.res.colorResource +import androidx.compose.ui.res.stringResource import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.text.style.TextAlign import androidx.compose.ui.unit.dp @@ -53,6 +54,7 @@ fun RestoreMnemonicScreen( ) { val isRestoring by viewModel.isRestoring.collectAsState() val restoreSuccess by viewModel.restoreSuccess.collectAsState() + val mnemonicMismatch by viewModel.mnemonicMismatch.collectAsState() var mnemonic by remember { mutableStateOf("") } var isValid by remember { mutableStateOf(false) } @@ -64,6 +66,7 @@ fun RestoreMnemonicScreen( LaunchedEffect(mnemonic) { isValid = viewModel.validateMnemonic(mnemonic.trim()) + if (mnemonicMismatch) viewModel.resetMnemonicMismatch() } Scaffold( @@ -116,20 +119,29 @@ fun RestoreMnemonicScreen( OutlinedTextField( value = mnemonic, - onValueChange = { mnemonic = it }, + onValueChange = { + mnemonic = it + if (mnemonicMismatch) viewModel.resetMnemonicMismatch() + }, + isError = mnemonicMismatch, + supportingText = if (mnemonicMismatch) { + { Text(stringResource(R.string.restore_mnemonic_mismatch), color = colorResource(id = R.color.error)) } + } else null, modifier = Modifier .fillMaxWidth() .height(200.dp), placeholder = { Text("Enter recovery phrase", color = colorResource(id = R.color.text_3)) }, shape = RoundedCornerShape(16.dp), colors = OutlinedTextFieldDefaults.colors( - focusedContainerColor = colorResource(id = R.color.bg_2), // Use bg_2 for input background + focusedContainerColor = colorResource(id = R.color.bg_2), unfocusedContainerColor = colorResource(id = R.color.bg_2), + errorContainerColor = colorResource(id = R.color.bg_2), focusedBorderColor = Color.Transparent, unfocusedBorderColor = Color.Transparent, cursorColor = colorResource(id = R.color.colorSecondary), focusedTextColor = colorResource(id = R.color.text), - unfocusedTextColor = colorResource(id = R.color.text) + unfocusedTextColor = colorResource(id = R.color.text), + errorTextColor = colorResource(id = R.color.text), ) ) diff --git a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/NativeFRWBridge.kt b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/NativeFRWBridge.kt index f5689da1..d40a14cc 100644 --- a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/NativeFRWBridge.kt +++ b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/NativeFRWBridge.kt @@ -22,6 +22,7 @@ import org.json.JSONObject import org.json.JSONArray import com.flowfoundation.wallet.manager.account.Account import com.flowfoundation.wallet.manager.account.AccountManager +import com.flowfoundation.wallet.manager.account.firstFlowWalletAddress import com.flowfoundation.wallet.utils.logd import com.flowfoundation.wallet.utils.loge import com.flowfoundation.wallet.utils.logw @@ -165,6 +166,10 @@ class NativeFRWBridge(reactContext: ReactApplicationContext) : NativeFRWBridgeSp val uid = firebaseUid() ?: AccountManager.get()?.wallet?.id if (!uid.isNullOrBlank()) { KeyStorageManager.saveSeedPhrase(uid, seedPhrase) + val address = AccountManager.get()?.firstFlowWalletAddress() + if (!address.isNullOrBlank()) { + KeyStorageManager.saveWalletAddress(uid, address) + } } logd(TAG, "saveNewKey() - Seed phrase saved successfully") @@ -209,6 +214,11 @@ class NativeFRWBridge(reactContext: ReactApplicationContext) : NativeFRWBridgeSp // AccountManager.add(account) will update the list and cache it AccountManager.add(account) + // Delete any pkStorage entry that KeyStorageMigration (Case 2) may have created + if (!uid.isNullOrBlank()) { + KeyStorageManager.deletePrivateKey(uid) + } + // 3. Clear CryptoProvider CryptoProviderManager.clear() @@ -375,9 +385,30 @@ class NativeFRWBridge(reactContext: ReactApplicationContext) : NativeFRWBridgeSp // 4. Update local account state with new prefix logd(TAG, "keystoreMigration() - updating local account state") + val uid = firebaseUid() ?: account.wallet?.id + val oldPrefix = account.prefix account.prefix = newPrefix AccountManager.add(account) + // Sync new prefix to independent AKP storage + if (!uid.isNullOrBlank()) { + KeyStorageManager.saveAndroidKeystorePrefix(uid, newPrefix) + val address = account.firstFlowWalletAddress() + if (!address.isNullOrBlank()) { + KeyStorageManager.saveWalletAddress(uid, address) + } + } + + // Remove the stale file-private-key entry that KeyCompatibilityManager may find + if (!oldPrefix.isNullOrBlank()) { + try { + getStorage().remove("prefix_key_$oldPrefix") + logd(TAG, "Removed old prefix key from shared storage: prefix_key_$oldPrefix") + } catch (e: Exception) { + loge(TAG, "Failed to remove old prefix key: ${e.message}") + } + } + // 5. Reload CryptoProvider logd(TAG, "keystoreMigration() - reloading crypto provider") CryptoProviderManager.clear() diff --git a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/AccountBridgeHandler.kt b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/AccountBridgeHandler.kt index cba853f5..de8b07f4 100644 --- a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/AccountBridgeHandler.kt +++ b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/AccountBridgeHandler.kt @@ -533,11 +533,12 @@ class AccountBridgeHandler(private val reactContext: ReactApplicationContext) { switchList.filterIsInstance().forEach { localAccount -> logd(TAG, "getRecoverableProfiles() - processing LocalSwitchAccount: ${localAccount.username}") - val mainEmojiInfo = createEmojiInfo(localAccount.address) + val displayAddress = localAccount.address.ifBlank { null } + val mainEmojiInfo = if (displayAddress != null) createEmojiInfo(displayAddress) else null val mainAccount = RNBridge.WalletAccount( - id = "main_${localAccount.address}", + id = "main_${displayAddress ?: localAccount.userId ?: localAccount.username}", name = mainEmojiInfo?.name ?: localAccount.username, - address = localAccount.address, + address = displayAddress ?: "", emojiInfo = mainEmojiInfo, parentEmoji = null, parentAddress = null, @@ -581,26 +582,35 @@ class AccountBridgeHandler(private val reactContext: ReactApplicationContext) { logd(TAG, "switchToProfile() called with userId: $userId") ioScope { try { - // Find the account with the matching userId (wallet id) - val accounts = AccountManager.list() - val targetAccount = accounts.find { it.wallet?.id == userId } - - if (targetAccount == null) { - logw(TAG, "switchToProfile() - account not found for userId: $userId") - uiScope { - promise.reject("PROFILE_NOT_FOUND", "Account not found for userId: $userId") + // 1. Check normal logged-in accounts first + val targetAccount = AccountManager.list().find { it.wallet?.id == userId } + if (targetAccount != null) { + logd(TAG, "switchToProfile() - found normal account: ${targetAccount.userInfo.username}") + AccountManager.switch(targetAccount) { + logd(TAG, "switchToProfile() - switch completed for userId: $userId") + uiScope { promise.resolve(null) } } return@ioScope } - logd(TAG, "switchToProfile() - found account: ${targetAccount.userInfo.username}") - - // Switch to the account - AccountManager.switch(targetAccount) { - logd(TAG, "switchToProfile() - switch completed for userId: $userId") - uiScope { - promise.resolve(null) // Success - resolve with no value + // 2. Not a normal account — check LocalSwitchAccount list (orphan keys) + // These are accounts with key material but no account cache entry. + val localAccount = AccountManager.getSwitchAccountList() + .filterIsInstance() + .find { it.userId == userId } + + if (localAccount != null) { + logd(TAG, "switchToProfile() - found LocalSwitchAccount for userId: $userId") + AccountManager.switch(localAccount) { + logd(TAG, "switchToProfile() - LocalSwitchAccount switch completed for userId: $userId") + uiScope { promise.resolve(null) } } + return@ioScope + } + + logw(TAG, "switchToProfile() - account not found for userId: $userId") + uiScope { + promise.reject("PROFILE_NOT_FOUND", "Account not found for userId: $userId") } } catch (e: Exception) { loge(TAG, "switchToProfile() - error: ${e.message}") diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 372bebd5..a339434c 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -84,6 +84,7 @@ created your previous wallet. Sign in with \nRecovery Phrase Enter the Recovery Phrase + Recovery phrase does not match this account Account not Found No account found with the recovery phrase. Do you want to create a new account with your phrase? your phrase diff --git a/gradle.properties b/gradle.properties index e39297f2..1756a69d 100644 --- a/gradle.properties +++ b/gradle.properties @@ -64,7 +64,7 @@ android.r8.dexing.parallel=true #android.bundle.enableUncompressedNativeLibs=false #android.experimental.enableArtProfiles=true -vCode=400000458 +vCode=400000462 vName=r3.1.0 # --- GitHub Packages (Flow Wallet Kit) --- From 734fb9a600184968dda836305570f0277bec3163 Mon Sep 17 00:00:00 2001 From: Meng Date: Sun, 8 Mar 2026 23:08:20 +0800 Subject: [PATCH 06/27] feat: upgrade instabug --- app/build.gradle | 6 +-- .../firebase/messaging/FirebaseMessaging.kt | 2 +- .../wallet/instabug/InstabugUtils.kt | 40 +++++++++---------- .../wallet/manager/account/AccountManager.kt | 9 +++-- .../flowjvm/transaction/Transaction.kt | 6 +-- .../manager/key/CryptoProviderManager.kt | 11 +++-- .../wallet/network/NetworkConst.kt | 8 ++-- .../wallet/network/functions/Functions.kt | 4 +- .../fragment/BackupSeedPhraseInfoFragment.kt | 4 +- .../fragment/ViewRecoveryPhraseFragment.kt | 4 +- .../BackupRecoveryPhraseInfoFragment.kt | 4 +- .../view/BackupCompletedItemView.kt | 4 +- .../wallet/page/main/MainActivity.kt | 10 ++--- .../page/profile/compose/SettingScreen.kt | 4 +- .../presenter/ProfileFragmentPresenter.kt | 4 +- .../presenter/DeveloperModePresenter.kt | 6 ++- .../fragment/PrivateKeyInfoFragment.kt | 4 +- .../fragment/PrivateKeyStoreInfoFragment.kt | 6 +-- .../fragment/SeedPhraseInfoFragment.kt | 4 +- .../viewmodel/KeyStoreRestoreViewModel.kt | 33 ++++++++++++--- .../mnemonic/RestoreMnemonicViewModel.kt | 16 +++++--- .../viewmodel/MultiRestoreViewModel.kt | 4 +- .../recovery/SecurityPrivateKeyActivity.kt | 4 +- .../recovery/SecurityPublicKeyActivity.kt | 4 +- .../recovery/SecurityRecoveryActivity.kt | 4 +- .../bridge/handlers/UtilsBridgeHandler.kt | 2 +- .../wallet/service/MessagingService.kt | 4 +- .../com/flowfoundation/wallet/utils/Log.kt | 30 +++++++------- .../wallet/utils/error/ErrorReporter.kt | 20 +++++----- .../activity_developer_mode_setting.xml | 2 +- build.gradle | 2 +- 31 files changed, 148 insertions(+), 117 deletions(-) diff --git a/app/build.gradle b/app/build.gradle index c7c519ca..bbc9a386 100644 --- a/app/build.gradle +++ b/app/build.gradle @@ -5,7 +5,7 @@ plugins { id "org.jetbrains.kotlin.plugin.serialization" version "1.9.0" id 'com.google.gms.google-services' id 'com.google.firebase.crashlytics' -// id("instabug-apm") // Disabled to fix ASM instrumentation issue +// id("luciq-apm") // Disabled to fix ASM instrumentation issue id 'com.google.devtools.ksp' id 'com.google.firebase.appdistribution' // id 'jacoco' @@ -462,8 +462,8 @@ dependencies { implementation 'com.google.firebase:firebase-appcheck-debug' /** Instabug **/ - implementation 'com.instabug.library:instabug:15.0.1' - implementation 'com.instabug.library:instabug-with-okhttp-interceptor:15.0.1' + implementation 'ai.luciq.library:luciq:19.3.0' + implementation 'ai.luciq.library:luciq-with-okhttp-interceptor:19.3.0' /** firebase **/ implementation "dev.chrisbanes:insetter-ktx:0.3.1" diff --git a/app/src/main/java/com/flowfoundation/wallet/firebase/messaging/FirebaseMessaging.kt b/app/src/main/java/com/flowfoundation/wallet/firebase/messaging/FirebaseMessaging.kt index b0ea3cbe..f4fc5298 100644 --- a/app/src/main/java/com/flowfoundation/wallet/firebase/messaging/FirebaseMessaging.kt +++ b/app/src/main/java/com/flowfoundation/wallet/firebase/messaging/FirebaseMessaging.kt @@ -13,7 +13,7 @@ import com.flowfoundation.wallet.utils.isDev import com.flowfoundation.wallet.utils.logd import com.flowfoundation.wallet.utils.loge import com.flowfoundation.wallet.utils.updatePushToken -import com.instabug.chat.Replies +import ai.luciq.chat.Replies private const val TAG = "FirebaseMessaging" diff --git a/app/src/main/java/com/flowfoundation/wallet/instabug/InstabugUtils.kt b/app/src/main/java/com/flowfoundation/wallet/instabug/InstabugUtils.kt index c27e2063..8df9aae9 100644 --- a/app/src/main/java/com/flowfoundation/wallet/instabug/InstabugUtils.kt +++ b/app/src/main/java/com/flowfoundation/wallet/instabug/InstabugUtils.kt @@ -7,18 +7,18 @@ import com.flowfoundation.wallet.manager.account.AccountManager import com.flowfoundation.wallet.manager.app.chainNetWorkString import com.flowfoundation.wallet.manager.evm.EVMWalletManager import com.flowfoundation.wallet.manager.wallet.WalletManager -import com.instabug.library.Feature -import com.instabug.library.Instabug -import com.instabug.library.IssueType -import com.instabug.library.MaskingType -import com.instabug.library.ReproConfigurations -import com.instabug.library.ReproMode -import com.instabug.library.invocation.InstabugInvocationEvent -import com.instabug.library.ui.onboarding.WelcomeMessage +import ai.luciq.library.Feature +import ai.luciq.library.Luciq +import ai.luciq.library.IssueType +import ai.luciq.library.MaskingType +import ai.luciq.library.ReproConfigurations +import ai.luciq.library.ReproMode +import ai.luciq.library.invocation.LuciqInvocationEvent +import ai.luciq.library.ui.onboarding.WelcomeMessage import com.flowfoundation.wallet.utils.isDev import com.flowfoundation.wallet.utils.isTesting -import com.instabug.bug.BugReporting -import com.instabug.bug.ProactiveReportingConfigs +import ai.luciq.bug.BugReporting +import ai.luciq.bug.ProactiveReportingConfigs fun instabugInitialize(application: Application) { @@ -26,11 +26,11 @@ fun instabugInitialize(application: Application) { return } if (isDev()) { - Instabug.Builder(application, BuildConfig.INSTABUG_TOKEN_DEV) + Luciq.Builder(application, BuildConfig.INSTABUG_TOKEN_DEV) .setInvocationEvents( - InstabugInvocationEvent.SCREENSHOT, - InstabugInvocationEvent.SHAKE, - InstabugInvocationEvent.FLOATING_BUTTON) + LuciqInvocationEvent.SCREENSHOT, + LuciqInvocationEvent.SHAKE, + LuciqInvocationEvent.FLOATING_BUTTON) .setTrackingUserStepsState(Feature.State.ENABLED) .setReproConfigurations( ReproConfigurations.Builder() @@ -38,12 +38,12 @@ fun instabugInitialize(application: Application) { .build()) .setAutoMaskScreenshotsTypes(MaskingType.MASK_NOTHING) .build() - Instabug.setWelcomeMessageState(WelcomeMessage.State.BETA) + Luciq.setWelcomeMessageState(WelcomeMessage.State.BETA) } else { - Instabug.Builder(application, BuildConfig.INSTABUG_TOKEN_PROD) + Luciq.Builder(application, BuildConfig.INSTABUG_TOKEN_PROD) .setInvocationEvents( - InstabugInvocationEvent.SCREENSHOT, - InstabugInvocationEvent.SHAKE + LuciqInvocationEvent.SCREENSHOT, + LuciqInvocationEvent.SHAKE ) .setTrackingUserStepsState(Feature.State.ENABLED) .setReproConfigurations( @@ -52,9 +52,9 @@ fun instabugInitialize(application: Application) { .build()) .setAutoMaskScreenshotsTypes(MaskingType.MASK_NOTHING) .build() - Instabug.setWelcomeMessageState(WelcomeMessage.State.DISABLED) + Luciq.setWelcomeMessageState(WelcomeMessage.State.DISABLED) } - Instabug.onReportSubmitHandler { report -> + Luciq.onReportSubmitHandler { report -> firebaseUid()?.let { report.setUserAttribute("uid", it) } diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt index 9fba0229..4bde49a4 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt @@ -448,6 +448,7 @@ object AccountManager { return accounts } + @Volatile private var isSwitching = false fun switch(account: Account, onFinish: () -> Unit) { @@ -498,6 +499,11 @@ object AccountManager { } AccountCacheManager.cache(Accounts().apply { addAll(accounts) }) AccountEmojiManager.init() + // Resume HD wallet state now that currentAccount is updated. + // Only needed for mnemonic accounts (no prefix, no keyStoreInfo). + if (account.prefix == null && account.keyStoreInfo == null) { + Wallet.store().resume() + } uiScope { clearUserCache() MainActivity.relaunch(Env.getApp(), true) @@ -612,9 +618,6 @@ object AccountManager { firebaseLogin(resp.data.customToken) { isSuccess -> if (isSuccess) { setRegistered() - if (account.prefix == null && account.keyStoreInfo == null) { - Wallet.store().resume() - } callback.invoke(true) } else { loge(tag = "SWITCH_ACCOUNT", msg = "get firebase login failed :: ${resp.data.customToken}") diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/flowjvm/transaction/Transaction.kt b/app/src/main/java/com/flowfoundation/wallet/manager/flowjvm/transaction/Transaction.kt index 8f5b5a2b..def257f7 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/flowjvm/transaction/Transaction.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/flowjvm/transaction/Transaction.kt @@ -20,7 +20,7 @@ import com.flowfoundation.wallet.utils.reportCadenceErrorToDebugView import com.flowfoundation.wallet.utils.safeRunSuspend import com.flowfoundation.wallet.utils.vibrateTransaction import com.flowfoundation.wallet.wallet.toAddress -import com.instabug.library.Instabug +import ai.luciq.library.Luciq import com.flowfoundation.wallet.manager.flow.FlowCadenceApi import org.onflow.flow.models.* import com.flowfoundation.wallet.manager.app.chainNetWorkString @@ -132,7 +132,7 @@ suspend fun sendTransaction( } if (e is InvalidKeyException) { ErrorReporter.reportCriticalWithMixpanel(WalletError.QUERY_ACCOUNT_KEY_FAILED, e) - Instabug.show() + Luciq.show() } return null } @@ -211,7 +211,7 @@ suspend fun sendBridgeTransaction( } if (e is InvalidKeyException) { ErrorReporter.reportCriticalWithMixpanel(WalletError.QUERY_ACCOUNT_KEY_FAILED, e) - Instabug.show() + Luciq.show() } return null } diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/key/CryptoProviderManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/key/CryptoProviderManager.kt index 681c97dc..919f18e7 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/key/CryptoProviderManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/key/CryptoProviderManager.kt @@ -234,12 +234,11 @@ object CryptoProviderManager { } // Handle wallet-specific mnemonic accounts else { - logd(TAG, " Branch: Inactive account.") - val mnemonic = if (account.isActive) { - Wallet.store().wallet().mnemonic() - } else { - AccountWalletManager.getHDWalletMnemonicByUID(account.wallet?.id ?: "") - } + logd(TAG, " Branch: Legacy mnemonic account.") + // Always look up the mnemonic by UID to avoid using the wrong account's mnemonic. + // Using Wallet.store().wallet().mnemonic() here would return the CURRENT account's + // mnemonic (the one being switched away from), not the target account's. + val mnemonic = AccountWalletManager.getHDWalletMnemonicByUID(account.wallet?.id ?: "") if (mnemonic == null) { loge(TAG, " Inactive account: Failed to get existing HDWallet by UID: ${account.wallet?.id}") diff --git a/app/src/main/java/com/flowfoundation/wallet/network/NetworkConst.kt b/app/src/main/java/com/flowfoundation/wallet/network/NetworkConst.kt index 72bd7b4b..1f689fe3 100644 --- a/app/src/main/java/com/flowfoundation/wallet/network/NetworkConst.kt +++ b/app/src/main/java/com/flowfoundation/wallet/network/NetworkConst.kt @@ -6,7 +6,7 @@ import com.flowfoundation.wallet.network.interceptor.HeaderInterceptor import com.flowfoundation.wallet.network.interceptor.PayerServiceInterceptor import com.flowfoundation.wallet.utils.isDev import com.flowfoundation.wallet.utils.isTesting -import com.instabug.library.okhttplogger.InstabugOkhttpInterceptor +import ai.luciq.library.okhttplogger.LuciqOkhttpInterceptor import okhttp3.OkHttpClient import okhttp3.logging.HttpLoggingInterceptor import retrofit2.Retrofit @@ -24,7 +24,7 @@ fun retrofit( ): Retrofit { val client = OkHttpClient.Builder().apply { addInterceptor(HeaderInterceptor(network = network)) - addInterceptor(InstabugOkhttpInterceptor()) + addInterceptor(LuciqOkhttpInterceptor()) callTimeout(20, TimeUnit.SECONDS) connectTimeout(20, TimeUnit.SECONDS) @@ -53,7 +53,7 @@ fun cadenceScriptApi(): Retrofit { val client = OkHttpClient.Builder().apply { addInterceptor(HeaderInterceptor(false)) addInterceptor(PayerServiceInterceptor()) // Add payer service interceptor - addInterceptor(InstabugOkhttpInterceptor()) + addInterceptor(LuciqOkhttpInterceptor()) addInterceptor(GzipRequestInterceptor()) addInterceptor(GzipResponseInterceptor()) callTimeout(20, TimeUnit.SECONDS) @@ -74,7 +74,7 @@ fun cadenceScriptApi(): Retrofit { fun retrofitWithHost(host: String, disableConverter: Boolean = false, ignoreAuthorization: Boolean = true): Retrofit { val client = OkHttpClient.Builder().apply { addInterceptor(HeaderInterceptor(ignoreAuthorization)) - addInterceptor(InstabugOkhttpInterceptor()) + addInterceptor(LuciqOkhttpInterceptor()) callTimeout(20, TimeUnit.SECONDS) connectTimeout(20, TimeUnit.SECONDS) readTimeout(20, TimeUnit.SECONDS) diff --git a/app/src/main/java/com/flowfoundation/wallet/network/functions/Functions.kt b/app/src/main/java/com/flowfoundation/wallet/network/functions/Functions.kt index 1fb2e09f..b2c94d4d 100644 --- a/app/src/main/java/com/flowfoundation/wallet/network/functions/Functions.kt +++ b/app/src/main/java/com/flowfoundation/wallet/network/functions/Functions.kt @@ -5,7 +5,7 @@ import com.flowfoundation.wallet.firebase.analytics.reportEvent import com.flowfoundation.wallet.network.interceptor.HeaderInterceptor import com.flowfoundation.wallet.network.interceptor.PayerServiceInterceptor import com.flowfoundation.wallet.utils.* -import com.instabug.library.okhttplogger.InstabugOkhttpInterceptor +import ai.luciq.library.okhttplogger.LuciqOkhttpInterceptor import kotlinx.coroutines.suspendCancellableCoroutine import okhttp3.MediaType.Companion.toMediaType import okhttp3.OkHttpClient @@ -45,7 +45,7 @@ private suspend fun executeHttp(host: String, functionName: String, data: Any? = addInterceptor(HeaderInterceptor()) addInterceptor(PayerServiceInterceptor()) // Add payer service interceptor - addInterceptor(InstabugOkhttpInterceptor()) + addInterceptor(LuciqOkhttpInterceptor()) if (isTesting()) { addInterceptor(HttpLoggingInterceptor().apply { level = HttpLoggingInterceptor.Level.BODY }) } diff --git a/app/src/main/java/com/flowfoundation/wallet/page/backup/fragment/BackupSeedPhraseInfoFragment.kt b/app/src/main/java/com/flowfoundation/wallet/page/backup/fragment/BackupSeedPhraseInfoFragment.kt index 3195b6a1..5d6ac116 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/backup/fragment/BackupSeedPhraseInfoFragment.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/backup/fragment/BackupSeedPhraseInfoFragment.kt @@ -14,7 +14,7 @@ import com.flowfoundation.wallet.page.walletcreate.fragments.mnemonic.MnemonicAd import com.flowfoundation.wallet.utils.extensions.visible import com.flowfoundation.wallet.utils.saveBackupMnemonicToPreference import com.flowfoundation.wallet.widgets.itemdecoration.GridSpaceItemDecoration -import com.instabug.library.Instabug +import ai.luciq.library.Luciq class BackupSeedPhraseInfoFragment: Fragment() { @@ -47,7 +47,7 @@ class BackupSeedPhraseInfoFragment: Fragment() { adapter = this@BackupSeedPhraseInfoFragment.adapter layoutManager = GridLayoutManager(context, 2, GridLayoutManager.VERTICAL, false) addItemDecoration(GridSpaceItemDecoration(vertical = 16.0)) - Instabug.addPrivateViews(this) + Luciq.addPrivateViews(this) visible() } with(binding.copyButton) { diff --git a/app/src/main/java/com/flowfoundation/wallet/page/backup/fragment/ViewRecoveryPhraseFragment.kt b/app/src/main/java/com/flowfoundation/wallet/page/backup/fragment/ViewRecoveryPhraseFragment.kt index 1e855af4..066bdd5c 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/backup/fragment/ViewRecoveryPhraseFragment.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/backup/fragment/ViewRecoveryPhraseFragment.kt @@ -12,7 +12,7 @@ import com.flowfoundation.wallet.page.backup.viewmodel.BackupViewMnemonicViewMod import com.flowfoundation.wallet.page.walletcreate.fragments.mnemonic.MnemonicAdapter import com.flowfoundation.wallet.utils.extensions.setVisible import com.flowfoundation.wallet.widgets.itemdecoration.GridSpaceItemDecoration -import com.instabug.library.Instabug +import ai.luciq.library.Luciq class ViewRecoveryPhraseFragment: Fragment() { private lateinit var binding: FragmentViewRecoveryPhraseBinding @@ -45,7 +45,7 @@ class ViewRecoveryPhraseFragment: Fragment() { adapter = this@ViewRecoveryPhraseFragment.adapter layoutManager = GridLayoutManager(context, 2, GridLayoutManager.VERTICAL, false) addItemDecoration(GridSpaceItemDecoration(vertical = 16.0)) - Instabug.addPrivateViews(this) + Luciq.addPrivateViews(this) } binding.copyButton.setOnClickListener { viewModel.copyMnemonic() diff --git a/app/src/main/java/com/flowfoundation/wallet/page/backup/multibackup/fragment/BackupRecoveryPhraseInfoFragment.kt b/app/src/main/java/com/flowfoundation/wallet/page/backup/multibackup/fragment/BackupRecoveryPhraseInfoFragment.kt index 4a0deb4f..1ff3392d 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/backup/multibackup/fragment/BackupRecoveryPhraseInfoFragment.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/backup/multibackup/fragment/BackupRecoveryPhraseInfoFragment.kt @@ -16,7 +16,7 @@ import com.flowfoundation.wallet.page.backup.multibackup.viewmodel.MultiBackupVi import com.flowfoundation.wallet.page.walletcreate.fragments.mnemonic.MnemonicAdapter import com.flowfoundation.wallet.utils.extensions.visible import com.flowfoundation.wallet.widgets.itemdecoration.GridSpaceItemDecoration -import com.instabug.library.Instabug +import ai.luciq.library.Luciq class BackupRecoveryPhraseInfoFragment : Fragment() { @@ -53,7 +53,7 @@ class BackupRecoveryPhraseInfoFragment : Fragment() { adapter = this@BackupRecoveryPhraseInfoFragment.adapter layoutManager = GridLayoutManager(context, 2, GridLayoutManager.VERTICAL, false) addItemDecoration(GridSpaceItemDecoration(vertical = 16.0)) - Instabug.addPrivateViews(this) + Luciq.addPrivateViews(this) visible() } with(binding.copyButton) { diff --git a/app/src/main/java/com/flowfoundation/wallet/page/backup/multibackup/view/BackupCompletedItemView.kt b/app/src/main/java/com/flowfoundation/wallet/page/backup/multibackup/view/BackupCompletedItemView.kt index d72e7835..6f674594 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/backup/multibackup/view/BackupCompletedItemView.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/backup/multibackup/view/BackupCompletedItemView.kt @@ -17,7 +17,7 @@ import com.flowfoundation.wallet.utils.extensions.visible import com.flowfoundation.wallet.utils.textToClipboard import com.flowfoundation.wallet.utils.toast import com.flowfoundation.wallet.widgets.itemdecoration.GridSpaceItemDecoration -import com.instabug.library.Instabug +import ai.luciq.library.Luciq class BackupCompletedItemView @JvmOverloads constructor( @@ -62,7 +62,7 @@ class BackupCompletedItemView @JvmOverloads constructor( adapter = this@BackupCompletedItemView.adapter layoutManager = GridLayoutManager(context, 2, GridLayoutManager.VERTICAL, false) addItemDecoration(GridSpaceItemDecoration(vertical = 16.0)) - Instabug.addPrivateViews(this) + Luciq.addPrivateViews(this) } binding.clMnemonic.visible() binding.mnemonicContainer.visible() diff --git a/app/src/main/java/com/flowfoundation/wallet/page/main/MainActivity.kt b/app/src/main/java/com/flowfoundation/wallet/page/main/MainActivity.kt index 31719269..1e1ac84c 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/main/MainActivity.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/main/MainActivity.kt @@ -29,8 +29,8 @@ import com.flowfoundation.wallet.utils.isNotificationPermissionChecked import com.flowfoundation.wallet.utils.isNotificationPermissionGrand import com.flowfoundation.wallet.utils.isRegistered import com.flowfoundation.wallet.utils.uiScope -import com.instabug.bug.BugReporting -import com.instabug.library.Instabug +import ai.luciq.bug.BugReporting +import ai.luciq.library.Luciq import com.flowfoundation.wallet.manager.wallet.WalletManager class MainActivity : BaseActivity() { @@ -73,7 +73,7 @@ class MainActivity : BaseActivity() { // Navigate to target tab if specified if (targetTabIndex >= 0) { - val targetTab = HomeTab.values().find { it.index == targetTabIndex } + val targetTab = HomeTab.entries.find { it.index == targetTabIndex } targetTab?.let { viewModel.changeTab(it) } } } @@ -91,10 +91,10 @@ class MainActivity : BaseActivity() { private fun configurationInstabugBugReport() { BugReporting.setOnInvokeCallback { DebugViewerDataSource.generateDebugZipFile(this)?.let { - Instabug.addFileAttachment(it, "log.zip") + Luciq.addFileAttachment(it, "log.zip") } BugReporting.setOnDismissCallback { _, _ -> - Instabug.clearFileAttachment() + Luciq.clearFileAttachment() BugReporting.setOnDismissCallback(null) } } diff --git a/app/src/main/java/com/flowfoundation/wallet/page/profile/compose/SettingScreen.kt b/app/src/main/java/com/flowfoundation/wallet/page/profile/compose/SettingScreen.kt index a4799afd..e36cb99f 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/profile/compose/SettingScreen.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/profile/compose/SettingScreen.kt @@ -44,7 +44,7 @@ import com.flowfoundation.wallet.page.account.AccountListActivity import com.flowfoundation.wallet.page.security.SecuritySettingActivity import com.flowfoundation.wallet.utils.* import com.flowfoundation.wallet.utils.extensions.openInSystemBrowser -import com.instabug.library.Instabug +import ai.luciq.library.Luciq import kotlinx.coroutines.launch @Composable @@ -255,7 +255,7 @@ fun SettingScreen( titleRes = R.string.bug_report, showDivider = true ) { - Instabug.show() + Luciq.show() } if (isSignedIn) { diff --git a/app/src/main/java/com/flowfoundation/wallet/page/profile/presenter/ProfileFragmentPresenter.kt b/app/src/main/java/com/flowfoundation/wallet/page/profile/presenter/ProfileFragmentPresenter.kt index fa773c49..e068779c 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/profile/presenter/ProfileFragmentPresenter.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/profile/presenter/ProfileFragmentPresenter.kt @@ -2,7 +2,7 @@ package com.flowfoundation.wallet.page.profile.presenter import android.annotation.SuppressLint import androidx.lifecycle.ViewModelProvider -import com.instabug.library.Instabug +import ai.luciq.library.Luciq import com.zackratos.ultimatebarx.ultimatebarx.addStatusBarTopPadding import com.flowfoundation.wallet.R import com.flowfoundation.wallet.base.presenter.BasePresenter @@ -105,7 +105,7 @@ class ProfileFragmentPresenter( ) } - binding.group3.bugReport.setOnClickListener { Instabug.show() } + binding.group3.bugReport.setOnClickListener { Luciq.show() } binding.group3.aboutPreference.setOnClickListener { AboutActivity.launch(context) } binding.group4.switchAccountPreference.setOnClickListener { logd("ProfileFragmentPresenter", "switchAccountPreference clicked") diff --git a/app/src/main/java/com/flowfoundation/wallet/page/profile/subpage/developer/presenter/DeveloperModePresenter.kt b/app/src/main/java/com/flowfoundation/wallet/page/profile/subpage/developer/presenter/DeveloperModePresenter.kt index 4114f4f7..cc98319d 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/profile/subpage/developer/presenter/DeveloperModePresenter.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/profile/subpage/developer/presenter/DeveloperModePresenter.kt @@ -15,6 +15,8 @@ import com.flowfoundation.wallet.manager.cadence.CadenceApiManager import com.flowfoundation.wallet.page.profile.subpage.developer.DeveloperModeViewModel import com.flowfoundation.wallet.page.profile.subpage.developer.LocalAccountKeyActivity import com.flowfoundation.wallet.page.profile.subpage.developer.model.DeveloperPageModel +import com.flowfoundation.wallet.utils.isDev +import com.flowfoundation.wallet.utils.isTesting import com.flowfoundation.wallet.utils.NETWORK_MAINNET import com.flowfoundation.wallet.utils.NETWORK_TESTNET import com.flowfoundation.wallet.utils.debug.DebugLogManager @@ -85,6 +87,8 @@ class DeveloperModePresenter( setDeveloperModeEnable(it) if (!it) { changeNetwork(NETWORK_MAINNET) + } else { + ioScope { refreshChainNetworkSync() } } } @@ -128,7 +132,7 @@ class DeveloperModePresenter( private fun setDevelopContentVisible(visible: Boolean) { binding.group2.setVisible(visible) binding.group3.setVisible(visible) - binding.cvDebug.setVisible(visible) + binding.cvDebug.setVisible(visible && (isDev() || isTesting())) binding.cvAccountKey.setVisible(visible && showLocalAccountKeys) binding.cvReloadConfig.setVisible(visible) } diff --git a/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/fragment/PrivateKeyInfoFragment.kt b/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/fragment/PrivateKeyInfoFragment.kt index 25d37960..d3d85543 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/fragment/PrivateKeyInfoFragment.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/fragment/PrivateKeyInfoFragment.kt @@ -20,7 +20,7 @@ import com.flowfoundation.wallet.utils.listeners.SimpleTextWatcher import com.flowfoundation.wallet.utils.logd import com.flowfoundation.wallet.utils.loge import com.flowfoundation.wallet.utils.toast -import com.instabug.library.Instabug +import ai.luciq.library.Luciq import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.launch @@ -121,7 +121,7 @@ class PrivateKeyInfoFragment: Fragment() { } updateImportButtonState() - Instabug.addPrivateViews(etPrivateKey) + Luciq.addPrivateViews(etPrivateKey) } } diff --git a/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/fragment/PrivateKeyStoreInfoFragment.kt b/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/fragment/PrivateKeyStoreInfoFragment.kt index 92d756ac..9458c2bc 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/fragment/PrivateKeyStoreInfoFragment.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/fragment/PrivateKeyStoreInfoFragment.kt @@ -31,7 +31,7 @@ import com.flowfoundation.wallet.utils.listeners.SimpleTextWatcher import com.flowfoundation.wallet.utils.logd import com.flowfoundation.wallet.utils.loge import com.flowfoundation.wallet.utils.toast -import com.instabug.library.Instabug +import ai.luciq.library.Luciq import org.json.JSONObject @@ -122,8 +122,8 @@ class PrivateKeyStoreInfoFragment: Fragment() { // Set up clickable error message setupErrorMessage() - Instabug.addPrivateViews(etJson) - Instabug.addPrivateViews(etPassword) + Luciq.addPrivateViews(etJson) + Luciq.addPrivateViews(etPassword) } // Observe keystore format errors from ViewModel diff --git a/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/fragment/SeedPhraseInfoFragment.kt b/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/fragment/SeedPhraseInfoFragment.kt index 13fdc98e..3f93769f 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/fragment/SeedPhraseInfoFragment.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/fragment/SeedPhraseInfoFragment.kt @@ -34,7 +34,7 @@ import com.flowfoundation.wallet.utils.extensions.visible import com.flowfoundation.wallet.utils.listeners.SimpleTextWatcher import com.flowfoundation.wallet.utils.toast import com.flowfoundation.wallet.widgets.itemdecoration.ColorDividerItemDecoration -import com.instabug.library.Instabug +import ai.luciq.library.Luciq import wallet.core.jni.HDWallet @@ -124,7 +124,7 @@ class SeedPhraseInfoFragment: Fragment() { ) } btnImport.isEnabled = false - Instabug.addPrivateViews(etSeedPhrase) + Luciq.addPrivateViews(etSeedPhrase) } } diff --git a/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/viewmodel/KeyStoreRestoreViewModel.kt b/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/viewmodel/KeyStoreRestoreViewModel.kt index db20ee3f..588e4c29 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/viewmodel/KeyStoreRestoreViewModel.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/restore/keystore/viewmodel/KeyStoreRestoreViewModel.kt @@ -647,6 +647,7 @@ class KeyStoreRestoreViewModel : ViewModel() { return } if (WalletManager.getCurrentFlowWalletAddress() == currentKeyStoreAddress?.address) { + loadingLiveData.postValue(false) toast(msgRes = R.string.wallet_already_logged_in, duration = Toast.LENGTH_LONG) val activity = BaseActivity.getCurrentActivity() ?: return activity.finish() @@ -668,6 +669,7 @@ class KeyStoreRestoreViewModel : ViewModel() { val activity = BaseActivity.getCurrentActivity() ?: run { logd("KeyStoreRestoreViewModel", "ERROR: No current activity found") + loadingLiveData.postValue(false) return@ioScope } @@ -697,6 +699,7 @@ class KeyStoreRestoreViewModel : ViewModel() { } } ?: run { logd("KeyStoreRestoreViewModel", "ERROR: Could not find matching key on-chain for public key: ${currentKeyStoreAddress?.publicKey}") + loadingLiveData.postValue(false) toast(msgRes = R.string.login_failure) activity.finish() return@ioScope @@ -706,12 +709,14 @@ class KeyStoreRestoreViewModel : ViewModel() { if (currentKey.weight.toInt() < 1000) { logd("KeyStoreRestoreViewModel", "ERROR: Key weight insufficient: ${currentKey.weight}") + loadingLiveData.postValue(false) toast(msgRes = R.string.restore_failure_insufficient_weight) activity.finish() return@ioScope } if (currentKey.revoked) { logd("KeyStoreRestoreViewModel", "ERROR: Key is revoked") + loadingLiveData.postValue(false) toast(msgRes = R.string.restore_failure_key_revoked) activity.finish() return@ioScope @@ -863,6 +868,7 @@ class KeyStoreRestoreViewModel : ViewModel() { getFirebaseUid { uid -> if (uid.isNullOrBlank()) { logd("KeyStoreRestoreViewModel", "No Firebase UID found") + loadingLiveData.postValue(false) loginProcessCallback.invoke(false) return@getFirebaseUid } @@ -889,6 +895,7 @@ class KeyStoreRestoreViewModel : ViewModel() { if (resp.data?.customToken.isNullOrBlank()) { logd("KeyStoreRestoreViewModel", "No custom token in response") + loadingLiveData.postValue(false) loginProcessCallback.invoke(false) return@runCatching } @@ -929,6 +936,7 @@ class KeyStoreRestoreViewModel : ViewModel() { logd("KeyStoreRestoreViewModel", "ERROR: No wallet address found in key indexer after login") logd("KeyStoreRestoreViewModel", "Public key used for lookup: $publicKey") logd("KeyStoreRestoreViewModel", "Chain ID used: $chainId") + loadingLiveData.postValue(false) loginProcessCallback.invoke(false) return@ioScope } @@ -1036,6 +1044,7 @@ class KeyStoreRestoreViewModel : ViewModel() { private fun loginWithKeyStoreAddress(flowAccountKey: AccountPublicKey, keystoreAddress: KeystoreAddress) { if (WalletManager.getCurrentFlowWalletAddress() == keystoreAddress.address) { + loadingLiveData.postValue(false) toast(msgRes = R.string.wallet_already_logged_in, duration = Toast.LENGTH_LONG) val activity = BaseActivity.getCurrentActivity() ?: return activity.finish() @@ -1050,13 +1059,18 @@ class KeyStoreRestoreViewModel : ViewModel() { } ioScope { val cryptoProvider = PrivateKeyStoreCryptoProvider(Gson().toJson(keystoreAddress)) - val activity = BaseActivity.getCurrentActivity() ?: return@ioScope + val activity = BaseActivity.getCurrentActivity() ?: run { + loadingLiveData.postValue(false) + return@ioScope + } if (flowAccountKey.weight.toInt() < 1000) { + loadingLiveData.postValue(false) toast(msgRes = R.string.restore_failure_insufficient_weight) activity.finish() return@ioScope } if (flowAccountKey.revoked) { + loadingLiveData.postValue(false) toast(msgRes = R.string.restore_failure_key_revoked) activity.finish() return@ioScope @@ -1213,7 +1227,10 @@ class KeyStoreRestoreViewModel : ViewModel() { logd("KeyStoreRestoreViewModel", "Starting create account with username: $username") ioScope { val cryptoProvider = PrivateKeyStoreCryptoProvider(Gson().toJson(currentKeyStoreAddress)) - val activity = BaseActivity.getCurrentActivity() ?: return@ioScope + val activity = BaseActivity.getCurrentActivity() ?: run { + loadingLiveData.postValue(false) + return@ioScope + } createAccount(username, cryptoProvider) { isSuccess -> uiScope { loadingLiveData.postValue(false) @@ -1365,11 +1382,15 @@ class KeyStoreRestoreViewModel : ViewModel() { } } } - } catch (e: HttpException) { - val errorBody = e.response()?.errorBody()?.string() - logd("KeyStoreRestoreViewModel", "HTTP Error: ${e.code()}, Response: $errorBody") + } catch (e: Exception) { + if (e is HttpException) { + val errorBody = e.response()?.errorBody()?.string() + logd("KeyStoreRestoreViewModel", "HTTP Error: ${e.code()}, Response: $errorBody") + } else { + logd("KeyStoreRestoreViewModel", "Error creating account: ${e.message}") + } callback.invoke(false) - throw e + // Don't rethrow to avoid crashing the coroutine if not handled } } } diff --git a/app/src/main/java/com/flowfoundation/wallet/page/restore/mnemonic/RestoreMnemonicViewModel.kt b/app/src/main/java/com/flowfoundation/wallet/page/restore/mnemonic/RestoreMnemonicViewModel.kt index bf4a8ed4..db9893f1 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/restore/mnemonic/RestoreMnemonicViewModel.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/restore/mnemonic/RestoreMnemonicViewModel.kt @@ -99,16 +99,15 @@ class RestoreMnemonicViewModel : ViewModel() { val newKeystoreAddress = keystoreAddress.copy(encryptedMnemonic = encryptedMnemonic) account.copy(keyStoreInfo = Gson().toJson(newKeystoreAddress)) } else { - // This case should ideally not happen if keyStoreInfo was set initially. - // But if it does, we return the original account or handle it as an error. account } } - // Clear wallet cache and re-initialize - WalletManager.clear() - WalletDataManager.updateCurrentAccount() - // Sync mnemonic to independent key storage and remove redundant private key entry + // Sync to KeyStorageManager BEFORE clearing wallet cache. + // This ensures createWalletFromAccount() finds the seed phrase (not the + // old private key) when updateCurrentAccount() triggers wallet re-creation, + // preventing a spurious ACTION_RESTORE_MNEMONIC broadcast and ensuring + // setEoaDisabled(false) is called correctly. try { KeyStorageManager.saveSeedPhrase(uid, mnemonic) KeyStorageManager.deletePrivateKey(uid) @@ -120,6 +119,11 @@ class RestoreMnemonicViewModel : ViewModel() { loge(TAG, "KeyStorageManager sync failed: ${e.message}") } + // Clear wallet cache and re-initialize — now finds seed phrase path, + // sets EOA enabled and does NOT re-trigger the restore broadcast. + WalletManager.clear() + WalletDataManager.updateCurrentAccount() + _restoreSuccess.value = true } catch (e: Exception) { e.printStackTrace() diff --git a/app/src/main/java/com/flowfoundation/wallet/page/restore/multirestore/viewmodel/MultiRestoreViewModel.kt b/app/src/main/java/com/flowfoundation/wallet/page/restore/multirestore/viewmodel/MultiRestoreViewModel.kt index 55f260c9..4d7bdf6c 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/restore/multirestore/viewmodel/MultiRestoreViewModel.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/restore/multirestore/viewmodel/MultiRestoreViewModel.kt @@ -51,7 +51,7 @@ import com.flowfoundation.wallet.utils.setMultiBackupCreated import com.flowfoundation.wallet.utils.setRegistered import com.flowfoundation.wallet.utils.toast import com.flowfoundation.wallet.utils.uiScope -import com.instabug.library.Instabug +import ai.luciq.library.Luciq import com.flow.wallet.keys.SeedPhraseKey import com.flow.wallet.storage.FileSystemStorage import com.flowfoundation.wallet.manager.flowjvm.transaction.sendTransactionWithMultiSignature @@ -527,7 +527,7 @@ class MultiRestoreViewModel : ViewModel(), OnTransactionStateChange { reportCadenceErrorToDebugView(scriptId, e) if (e is InvalidKeyException) { ErrorReporter.reportCriticalWithMixpanel(WalletError.QUERY_ACCOUNT_KEY_FAILED, e) - Instabug.show() + Luciq.show() } return null } diff --git a/app/src/main/java/com/flowfoundation/wallet/page/security/recovery/SecurityPrivateKeyActivity.kt b/app/src/main/java/com/flowfoundation/wallet/page/security/recovery/SecurityPrivateKeyActivity.kt index 2a567605..92f1d141 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/security/recovery/SecurityPrivateKeyActivity.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/security/recovery/SecurityPrivateKeyActivity.kt @@ -4,7 +4,7 @@ import android.content.Context import android.content.Intent import android.os.Bundle import android.view.MenuItem -import com.instabug.library.Instabug +import ai.luciq.library.Luciq import com.flowfoundation.wallet.R import com.flowfoundation.wallet.base.activity.BaseActivity import com.flowfoundation.wallet.databinding.ActivitySecurityPrivateKeyBinding @@ -57,7 +57,7 @@ class SecurityPrivateKeyActivity : BaseActivity() { publicKeyCopyButton.setOnClickListener { copyToClipboard(cryptoProvider.getPublicKey()) } hashAlgorithm.text = getString(R.string.hash_algorithm, cryptoProvider.getHashAlgorithm().algorithm) signAlgorithm.text = getString(R.string.sign_algorithm, cryptoProvider.getSignatureAlgorithm().value) - Instabug.addPrivateViews(privateKeyView) + Luciq.addPrivateViews(privateKeyView) } } diff --git a/app/src/main/java/com/flowfoundation/wallet/page/security/recovery/SecurityPublicKeyActivity.kt b/app/src/main/java/com/flowfoundation/wallet/page/security/recovery/SecurityPublicKeyActivity.kt index 8c94bcb3..c1d60a9b 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/security/recovery/SecurityPublicKeyActivity.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/security/recovery/SecurityPublicKeyActivity.kt @@ -13,7 +13,7 @@ import com.flowfoundation.wallet.utils.extensions.res2String import com.flowfoundation.wallet.utils.isNightMode import com.flowfoundation.wallet.utils.textToClipboard import com.flowfoundation.wallet.utils.toast -import com.instabug.library.Instabug +import ai.luciq.library.Luciq import com.zackratos.ultimatebarx.ultimatebarx.UltimateBarX class SecurityPublicKeyActivity : BaseActivity() { @@ -51,7 +51,7 @@ class SecurityPublicKeyActivity : BaseActivity() { hashAlgorithm.text = getString(R.string.hash_algorithm, cryptoProvider.getHashAlgorithm().algorithm) signAlgorithm.text = getString(R.string.sign_algorithm, cryptoProvider.getSignatureAlgorithm().value) - Instabug.addPrivateViews(privateKeyView) + Luciq.addPrivateViews(privateKeyView) } } diff --git a/app/src/main/java/com/flowfoundation/wallet/page/security/recovery/SecurityRecoveryActivity.kt b/app/src/main/java/com/flowfoundation/wallet/page/security/recovery/SecurityRecoveryActivity.kt index 9d07c567..f6ae68ff 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/security/recovery/SecurityRecoveryActivity.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/security/recovery/SecurityRecoveryActivity.kt @@ -5,7 +5,7 @@ import android.content.Intent import android.os.Bundle import android.view.MenuItem import androidx.recyclerview.widget.GridLayoutManager -import com.instabug.library.Instabug +import ai.luciq.library.Luciq import com.flowfoundation.wallet.R import com.flowfoundation.wallet.base.activity.BaseActivity import com.flowfoundation.wallet.databinding.ActivitySecurityRecoveryBinding @@ -63,7 +63,7 @@ class SecurityRecoveryActivity : BaseActivity() { adapter = this@SecurityRecoveryActivity.adapter layoutManager = GridLayoutManager(context, 2, GridLayoutManager.VERTICAL, false) addItemDecoration(GridSpaceItemDecoration(vertical = 16.0)) - Instabug.addPrivateViews(this) + Luciq.addPrivateViews(this) } loadMnemonic() } diff --git a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/UtilsBridgeHandler.kt b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/UtilsBridgeHandler.kt index 059c9362..78d2c350 100644 --- a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/UtilsBridgeHandler.kt +++ b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/UtilsBridgeHandler.kt @@ -210,7 +210,7 @@ class UtilsBridgeHandler(private val reactContext: ReactApplicationContext) { args.getString(i) ?: "" } - // Delegate to the centralized Instabug logging system in Log.kt + // Delegate to the centralized Luciq logging system in Log.kt logToInstabug(level, message, *stringArgs) } catch (e: Exception) { // Fallback with just the message if args conversion fails diff --git a/app/src/main/java/com/flowfoundation/wallet/service/MessagingService.kt b/app/src/main/java/com/flowfoundation/wallet/service/MessagingService.kt index 664ef1db..9c6ab6cf 100644 --- a/app/src/main/java/com/flowfoundation/wallet/service/MessagingService.kt +++ b/app/src/main/java/com/flowfoundation/wallet/service/MessagingService.kt @@ -8,7 +8,7 @@ import com.flowfoundation.wallet.firebase.messaging.uploadPushToken import com.flowfoundation.wallet.utils.ioScope import com.flowfoundation.wallet.utils.logd import com.flowfoundation.wallet.utils.updatePushToken -import com.instabug.chat.Replies +import ai.luciq.chat.Replies class MessagingService : FirebaseMessagingService() { @@ -29,7 +29,7 @@ class MessagingService : FirebaseMessagingService() { override fun onMessageReceived(message: RemoteMessage) { logd(TAG, "receive new firebase message:$message") parseFirebaseMessaging(message) - if (Replies.isInstabugNotification(message.getData())) { + if (Replies.isLuciqNotification(message.getData())) { Replies.showNotification(message.getData()) } } diff --git a/app/src/main/java/com/flowfoundation/wallet/utils/Log.kt b/app/src/main/java/com/flowfoundation/wallet/utils/Log.kt index ff09101f..bba3038c 100644 --- a/app/src/main/java/com/flowfoundation/wallet/utils/Log.kt +++ b/app/src/main/java/com/flowfoundation/wallet/utils/Log.kt @@ -5,7 +5,7 @@ import com.flowfoundation.wallet.BuildConfig import com.flowfoundation.wallet.firebase.analytics.reportErrorToDebugView import com.flowfoundation.wallet.firebase.analytics.reportException import com.flowfoundation.wallet.utils.debug.fragments.debugViewer.DebugViewerDataSource -import com.instabug.library.logging.InstabugLog +import ai.luciq.library.logging.LuciqLog import com.nftco.flow.sdk.FlowException import retrofit2.HttpException @@ -13,19 +13,19 @@ private const val MAX_LOG_LENGTH = 3500 private const val LOG_PREFIX = "[" private const val LOG_SUFFIX = "]" -fun logv(tag: String?, msg: Any?) = logWithLevel(tag, msg, Log.VERBOSE, InstabugLog::v) -fun logd(tag: String?, msg: Any?) = logWithLevel(tag, msg, Log.DEBUG, InstabugLog::d) -fun logi(tag: String?, msg: Any?) = logWithLevel(tag, msg, Log.INFO, InstabugLog::i) -fun logw(tag: String?, msg: Any?) = logWithLevel(tag, msg, Log.WARN, InstabugLog::w) +fun logv(tag: String?, msg: Any?) = logWithLevel(tag, msg, Log.VERBOSE, LuciqLog::v) +fun logd(tag: String?, msg: Any?) = logWithLevel(tag, msg, Log.DEBUG, LuciqLog::d) +fun logi(tag: String?, msg: Any?) = logWithLevel(tag, msg, Log.INFO, LuciqLog::i) +fun logw(tag: String?, msg: Any?) = logWithLevel(tag, msg, Log.WARN, LuciqLog::w) fun loge(tag: String?, msg: Any?) { - logWithLevel(tag, msg, Log.ERROR, InstabugLog::e) + logWithLevel(tag, msg, Log.ERROR, LuciqLog::e) reportErrorToDebugView(tag, mapOf("errorInfo" to (msg?.toString() ?: ""))) } fun loge(throwable: Throwable?, printStackTrace: Boolean = true, report: Boolean = true) { val message = throwable?.message ?: "" log("Exception", message, Log.ERROR) - InstabugLog.e("Exception: $message : ${throwable?.cause ?: ""}") + LuciqLog.e("Exception: $message : ${throwable?.cause ?: ""}") if (printLog() && printStackTrace) { throwable?.printStackTrace() @@ -102,7 +102,7 @@ private fun printLog() = BuildConfig.DEBUG || isDev() /** * Native logging method for React Native bridge callback - * Directly reports to Instabug for reliable logging + * Directly reports to Luciq for reliable logging */ fun logToInstabug(level: String, message: String, vararg args: String) { try { @@ -119,23 +119,23 @@ fun logToInstabug(level: String, message: String, vararg args: String) { // Convert string level to Android Log level constant for DebugViewerDataSource val logLevel = when (level.lowercase()) { "debug" -> { - InstabugLog.d(taggedMessage) + LuciqLog.d(taggedMessage) Log.DEBUG } "info" -> { - InstabugLog.i(taggedMessage) + LuciqLog.i(taggedMessage) Log.INFO } "warn" -> { - InstabugLog.w(taggedMessage) + LuciqLog.w(taggedMessage) Log.WARN } "error" -> { - InstabugLog.e(taggedMessage) + LuciqLog.e(taggedMessage) Log.ERROR } else -> { - InstabugLog.i(taggedMessage) + LuciqLog.i(taggedMessage) Log.INFO } } @@ -143,7 +143,7 @@ fun logToInstabug(level: String, message: String, vararg args: String) { // Also log to DebugViewer with correct level type DebugViewerDataSource.log(logLevel, "FRW-Native", taggedMessage) } catch (e: Exception) { - // Fallback to direct Instabug error report to avoid recursion - InstabugLog.e("[FRW-Native] Error in logToNative: ${e.message}") + // Fallback to direct Luciq error report to avoid recursion + LuciqLog.e("[FRW-Native] Error in logToNative: ${e.message}") } } diff --git a/app/src/main/java/com/flowfoundation/wallet/utils/error/ErrorReporter.kt b/app/src/main/java/com/flowfoundation/wallet/utils/error/ErrorReporter.kt index d3ff766b..66cd8bec 100644 --- a/app/src/main/java/com/flowfoundation/wallet/utils/error/ErrorReporter.kt +++ b/app/src/main/java/com/flowfoundation/wallet/utils/error/ErrorReporter.kt @@ -5,23 +5,23 @@ import com.flowfoundation.wallet.manager.transaction.TransactionStateManager import com.flowfoundation.wallet.mixpanel.MixpanelManager import com.flowfoundation.wallet.utils.getCurrentCodeLocation import com.flowfoundation.wallet.utils.getLocationInfo -import com.instabug.crash.CrashReporting -import com.instabug.crash.models.IBGNonFatalException -import com.instabug.library.Instabug +import ai.luciq.crash.CrashReporting +import ai.luciq.crash.models.LuciqNonFatalException +import ai.luciq.library.Luciq import org.onflow.flow.infrastructure.CadenceErrorCode object ErrorReporter { private fun report(error: BaseError, cause: Throwable? = null) { - IBGNonFatalException.Builder(CustomException(error, cause)) - .setLevel(IBGNonFatalException.Level.ERROR) + LuciqNonFatalException.Builder(CustomException(error, cause)) + .setLevel(LuciqNonFatalException.Level.ERROR) .build() .let { exception -> CrashReporting.report(exception)} } fun reportMoveAssetsError(locationInfo: String) { reportWithMixpanel(MoveError.FAILED_TO_SUBMIT_TRANSACTION, locationInfo) - Instabug.show() + Luciq.show() } fun reportWithMixpanel(error: BaseError, locationInfo: String) { @@ -40,8 +40,8 @@ object ErrorReporter { fun reportCriticalWithMixpanel(error: BaseError, cause: Throwable? = null) { val throwable = cause ?: CustomException(error) - IBGNonFatalException.Builder(throwable) - .setLevel(IBGNonFatalException.Level.CRITICAL) + LuciqNonFatalException.Builder(throwable) + .setLevel(LuciqNonFatalException.Level.CRITICAL) .build() .let { exception -> CrashReporting.report(exception)} MixpanelManager.error(error, throwable.getLocationInfo(), throwable.message) @@ -54,8 +54,8 @@ object ErrorReporter { // Map CadenceErrorCode to WalletError for consistent error reporting val walletError = WalletError(errorCode, cadenceError.name) val cause = CustomTransactionException(walletError, errorMessage) - IBGNonFatalException.Builder(cause) - .setLevel(IBGNonFatalException.Level.ERROR) + LuciqNonFatalException.Builder(cause) + .setLevel(LuciqNonFatalException.Level.ERROR) .setFingerprint("$scriptId.$errorCode") .build() .let { exception -> CrashReporting.report(exception)} diff --git a/app/src/main/res/layout/activity_developer_mode_setting.xml b/app/src/main/res/layout/activity_developer_mode_setting.xml index aea133ec..781c6f5e 100644 --- a/app/src/main/res/layout/activity_developer_mode_setting.xml +++ b/app/src/main/res/layout/activity_developer_mode_setting.xml @@ -196,7 +196,7 @@ android:layout_width="match_parent" android:layout_height="wrap_content" app:iconEnable="false" - app:titleId="@string/debug_view"/> + app:titleId="@string/wrap_eoa_tx_with_cadence"/> diff --git a/build.gradle b/build.gradle index 7860e5c0..0fe9f72b 100644 --- a/build.gradle +++ b/build.gradle @@ -19,7 +19,7 @@ buildscript { classpath 'com.google.gms:google-services:4.4.2' classpath 'com.google.firebase:firebase-crashlytics-gradle:3.0.2' - classpath 'com.instabug.library:instabug-plugin:12.0.0' + classpath 'ai.luciq.library:luciq-plugin:19.3.0' classpath 'com.google.firebase:firebase-appdistribution-gradle:5.0.0' // Google Play Publisher plugin for uploading AAB to Play Console classpath 'com.github.triplet.gradle:play-publisher:3.10.1' From 1682effd1fa639b878c4993dc7ffa47ea61cc24d Mon Sep 17 00:00:00 2001 From: Meng Date: Mon, 9 Mar 2026 01:44:46 +0800 Subject: [PATCH 07/27] fix: loading shimmer and hide coa switch view --- .../wallet/manager/account/AccountManager.kt | 6 +- .../page/account/AccountListViewModel.kt | 33 ++- .../page/main/drawer/DrawerLayoutViewModel.kt | 33 ++- .../main/presenter/DrawerLayoutContent.kt | 210 ++++++++++++------ .../page/profile/compose/SettingScreen.kt | 3 + .../presenter/DeveloperModePresenter.kt | 15 ++ .../presenter/WalletFragmentPresenter.kt | 2 + .../wallet/presenter/WalletHeaderPresenter.kt | 5 +- .../wallet/utils/PreferenceUtils.kt | 6 + .../activity_developer_mode_setting.xml | 25 +++ .../layout/fragment_coordinator_wallet.xml | 141 ++++++++++++ .../layout_wallet_coordinator_header.xml | 37 ++- app/src/main/res/values/strings.xml | 1 + 13 files changed, 424 insertions(+), 93 deletions(-) diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt index 4bde49a4..40cae41f 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt @@ -22,9 +22,7 @@ import com.flowfoundation.wallet.network.ApiService import com.flowfoundation.wallet.network.clearUserCache import com.flowfoundation.wallet.manager.key.HDWalletCryptoProvider import com.flowfoundation.wallet.network.model.AccountKey -import com.flowfoundation.wallet.network.model.EvmAccountInfo import com.flowfoundation.wallet.network.model.FlowAccountInfo -import com.flowfoundation.wallet.network.model.LoginRequest import com.flowfoundation.wallet.network.model.LoginV4Request import com.flowfoundation.wallet.network.model.UserInfoData import com.flowfoundation.wallet.network.model.WalletListData @@ -572,7 +570,7 @@ object AccountManager { logd(TAG, " Key Weight: ${cryptoProvider.getKeyWeight()}") // Get JWT with force refresh to avoid token expiration issues - val jwt = getFirebaseJwt(true) + val jwt = getFirebaseJwt() logd(TAG, "Retrieved JWT for account switch (length: ${jwt.length})") val publicKey = cryptoProvider.getPublicKey() @@ -726,7 +724,7 @@ object AccountManager { logd(TAG, " Key Weight: ${cryptoProvider.getKeyWeight()}") // Get JWT with force refresh to avoid token expiration issues - val jwt = getFirebaseJwt(true) + val jwt = getFirebaseJwt() logd(TAG, "Retrieved JWT for local account switch (length: ${jwt.length})") val publicKey = cryptoProvider.getPublicKey() diff --git a/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt b/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt index 1dcb5ad7..fac6a07b 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt @@ -18,6 +18,7 @@ import com.flowfoundation.wallet.network.retrofitApi import com.flowfoundation.wallet.page.main.model.WalletAccountData import com.flowfoundation.wallet.page.main.model.LinkedAccountData import com.flowfoundation.wallet.utils.formatLargeBalanceNumber +import com.flowfoundation.wallet.utils.isHideCOAWithZeroBalanceEnable import com.flowfoundation.wallet.utils.ioScope import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.StateFlow @@ -158,23 +159,31 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { } _balanceMap.value = formattedBalanceMap + val hideCOAWithZeroBalance = isHideCOAWithZeroBalanceEnable() + // Check each pending EVM address pendingEvmAddresses.forEach { (evmAddress, walletAddress) -> - val evmBalance = balanceMap[evmAddress] - val hasBalance = evmBalance != null && evmBalance > BigDecimal.ZERO - var hasNFTs = false - - if (!hasBalance) { - try { - val nftResponse = service.getEVMNFTCollections(evmAddress) - val totalNftCount = nftResponse.data?.sumOf { it.count ?: 0 } ?: 0 - hasNFTs = nftResponse.data?.isNotEmpty() == true && totalNftCount > 0 - } catch (e: Exception) { - // Ignore NFT API errors + val shouldShow = if (!hideCOAWithZeroBalance) { + true + } else { + val evmBalance = balanceMap[evmAddress] + val hasBalance = evmBalance != null && evmBalance > BigDecimal.ZERO + var hasNFTs = false + + if (!hasBalance) { + try { + val nftResponse = service.getEVMNFTCollections(evmAddress) + val totalNftCount = nftResponse.data?.sumOf { it.count ?: 0 } ?: 0 + hasNFTs = nftResponse.data?.isNotEmpty() == true && totalNftCount > 0 + } catch (_: Exception) { + // Ignore NFT API errors + } } + + hasBalance || hasNFTs } - if (hasBalance || hasNFTs) { + if (shouldShow) { // Add EVM address to linked accounts val currentAccounts = _accounts.value.toMutableList() val walletAccount = currentAccounts.find { it.address == walletAddress } diff --git a/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt b/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt index ce75d976..1173b28d 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt @@ -17,6 +17,7 @@ import com.flowfoundation.wallet.manager.wallet.WalletManager import com.flowfoundation.wallet.network.ApiService import com.flowfoundation.wallet.network.retrofitApi import com.flowfoundation.wallet.utils.formatLargeBalanceNumber +import com.flowfoundation.wallet.utils.isHideCOAWithZeroBalanceEnable import com.flowfoundation.wallet.utils.ioScope import com.flowfoundation.wallet.network.model.UserInfoData import com.flowfoundation.wallet.manager.account.AccountVisibilityManager @@ -169,23 +170,31 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { } _balanceMap.value = formattedBalanceMap + val hideCOAWithZeroBalance = isHideCOAWithZeroBalanceEnable() + // Check each pending EVM address pendingEvmAddresses.forEach { (evmAddress, walletAddress) -> - val evmBalance = balanceMap[evmAddress] - val hasBalance = evmBalance != null && evmBalance > BigDecimal.ZERO - var hasNFTs = false - - if (!hasBalance) { - try { - val nftResponse = service.getEVMNFTCollections(evmAddress) - val totalNftCount = nftResponse.data?.sumOf { it.count ?: 0 } ?: 0 - hasNFTs = nftResponse.data?.isNotEmpty() == true && totalNftCount > 0 - } catch (_: Exception) { - // Ignore NFT API errors + val shouldShow = if (!hideCOAWithZeroBalance) { + true + } else { + val evmBalance = balanceMap[evmAddress] + val hasBalance = evmBalance != null && evmBalance > BigDecimal.ZERO + var hasNFTs = false + + if (!hasBalance) { + try { + val nftResponse = service.getEVMNFTCollections(evmAddress) + val totalNftCount = nftResponse.data?.sumOf { it.count ?: 0 } ?: 0 + hasNFTs = nftResponse.data?.isNotEmpty() == true && totalNftCount > 0 + } catch (_: Exception) { + // Ignore NFT API errors + } } + + hasBalance || hasNFTs } - if (hasBalance || hasNFTs) { + if (shouldShow) { // Add EVM address to linked accounts val currentAccounts = _accounts.value.toMutableList() val walletAccount = currentAccounts.find { it.address == walletAddress } diff --git a/app/src/main/java/com/flowfoundation/wallet/page/main/presenter/DrawerLayoutContent.kt b/app/src/main/java/com/flowfoundation/wallet/page/main/presenter/DrawerLayoutContent.kt index e76cd3a3..5db7f729 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/main/presenter/DrawerLayoutContent.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/main/presenter/DrawerLayoutContent.kt @@ -25,6 +25,12 @@ import androidx.compose.material3.HorizontalDivider import androidx.compose.material3.Icon import androidx.compose.material3.IconButton import androidx.compose.material3.Text +import androidx.compose.animation.core.LinearEasing +import androidx.compose.animation.core.RepeatMode +import androidx.compose.animation.core.animateFloat +import androidx.compose.animation.core.infiniteRepeatable +import androidx.compose.animation.core.rememberInfiniteTransition +import androidx.compose.animation.core.tween import androidx.compose.runtime.Composable import androidx.compose.runtime.DisposableEffect import androidx.compose.runtime.LaunchedEffect @@ -32,8 +38,10 @@ import androidx.compose.runtime.getValue import androidx.compose.runtime.remember import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.alpha import androidx.compose.ui.draw.clip import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.Shape import androidx.compose.ui.layout.ContentScale import androidx.compose.ui.platform.ComposeView import androidx.compose.ui.platform.LocalContext @@ -134,18 +142,16 @@ fun DrawerLayoutCompose(drawer: DrawerLayout) { .background(colorResource(id = R.color.deep_bg)) .padding(horizontal = 18.dp, vertical = 24.dp) ) { - userInfo?.let { - HeaderSection( - userInfo = it, - onAccountSwitchClick = { ProfileSwitchDialog.show(activity.supportFragmentManager) } - ) - HorizontalDivider( - color = colorResource(id = R.color.border_line_stroke), - modifier = Modifier - .fillMaxWidth() - .padding(top = 14.dp) - ) - } + HeaderSection( + userInfo = userInfo, + onAccountSwitchClick = { ProfileSwitchDialog.show(activity.supportFragmentManager) } + ) + HorizontalDivider( + color = colorResource(id = R.color.border_line_stroke), + modifier = Modifier + .fillMaxWidth() + .padding(top = 14.dp) + ) if (showEvmLayout) { Spacer(modifier = Modifier.height(24.dp)) @@ -215,52 +221,77 @@ fun DrawerLayoutCompose(drawer: DrawerLayout) { @Composable fun HeaderSection( - userInfo: UserInfoData, + userInfo: UserInfoData?, onAccountSwitchClick: () -> Unit ) { - val avatarUrl = userInfo.avatar.parseAvatarUrl() - val avatar = if (avatarUrl.contains("flovatar.com")) { - avatarUrl.svgToPng() - } else { - avatarUrl - } ConstraintLayout( modifier = Modifier .fillMaxWidth() .padding(top = 40.dp) ) { val (icon, name, switch) = createRefs() - AsyncImage( - model = avatar, - contentDescription = "User Avatar", - contentScale = ContentScale.Crop, - placeholder = painterResource(id = R.drawable.ic_placeholder), - error = painterResource(id = R.drawable.ic_placeholder), - modifier = Modifier - .constrainAs(icon) { - top.linkTo(parent.top) - bottom.linkTo(parent.bottom) - start.linkTo(parent.start) - end.linkTo(name.start) - } - .size(40.dp) - .clip(RoundedCornerShape(8.dp)) - ) - Text( - text = userInfo.nickname, - color = colorResource(id = R.color.text_1), - fontSize = 14.sp, - fontWeight = FontWeight.SemiBold, - modifier = Modifier - .constrainAs(name) { - top.linkTo(parent.top) - bottom.linkTo(parent.bottom) - start.linkTo(icon.end, 16.dp) - end.linkTo(switch.start, 16.dp) - width = Dimension.fillToConstraints - } - ) + if (userInfo == null) { + ShimmerBox( + modifier = Modifier + .constrainAs(icon) { + top.linkTo(parent.top) + bottom.linkTo(parent.bottom) + start.linkTo(parent.start) + } + .size(40.dp), + shape = RoundedCornerShape(8.dp) + ) + ShimmerBox( + modifier = Modifier + .constrainAs(name) { + top.linkTo(parent.top) + bottom.linkTo(parent.bottom) + start.linkTo(icon.end, 16.dp) + end.linkTo(switch.start, 16.dp) + width = Dimension.fillToConstraints + } + .height(16.dp) + .width(120.dp) + ) + } else { + val avatarUrl = userInfo.avatar.parseAvatarUrl() + val avatar = if (avatarUrl.contains("flovatar.com")) { + avatarUrl.svgToPng() + } else { + avatarUrl + } + AsyncImage( + model = avatar, + contentDescription = "User Avatar", + contentScale = ContentScale.Crop, + placeholder = painterResource(id = R.drawable.ic_placeholder), + error = painterResource(id = R.drawable.ic_placeholder), + modifier = Modifier + .constrainAs(icon) { + top.linkTo(parent.top) + bottom.linkTo(parent.bottom) + start.linkTo(parent.start) + end.linkTo(name.start) + } + .size(40.dp) + .clip(RoundedCornerShape(8.dp)) + ) + Text( + text = userInfo.nickname, + color = colorResource(id = R.color.text_1), + fontSize = 14.sp, + fontWeight = FontWeight.SemiBold, + modifier = Modifier + .constrainAs(name) { + top.linkTo(parent.top) + bottom.linkTo(parent.bottom) + start.linkTo(icon.end, 16.dp) + end.linkTo(switch.start, 16.dp) + width = Dimension.fillToConstraints + } + ) + } IconButton( onClick = onAccountSwitchClick, @@ -679,13 +710,16 @@ fun AccountListSection( color = colorResource(id = R.color.text_2), fontSize = 14.sp ) - activeAccount?.let { + if (activeAccount != null) { Spacer(modifier = Modifier.height(16.dp)) ActiveAccountSection( - item = it, + item = activeAccount, balanceMap = balanceMap, onCopyClick = onCopyClick ) + } else if (accounts.isEmpty()) { + Spacer(modifier = Modifier.height(16.dp)) + ShimmerWalletAccountRow() } Spacer(modifier = Modifier.height(16.dp)) Text( @@ -694,20 +728,26 @@ fun AccountListSection( fontSize = 14.sp, ) - accounts.forEach { account -> - WalletAccountSection( - item = account, - balance = balanceMap[account.address.toAddress()] ?: "", - onCopyClick = onCopyClick, - onAccountClick = { onAccountClick(account.address) } - ) - account.linkedAccounts.forEach { linkedAccount -> - LinkedAccountSection( - item = linkedAccount, - balance = balanceMap[linkedAccount.address.toAddress()] ?: "", + if (accounts.isEmpty()) { + repeat(2) { + ShimmerWalletAccountRow() + } + } else { + accounts.forEach { account -> + WalletAccountSection( + item = account, + balance = balanceMap[account.address.toAddress()] ?: "", onCopyClick = onCopyClick, - onAccountClick = { onAccountClick(linkedAccount.address) } + onAccountClick = { onAccountClick(account.address) } ) + account.linkedAccounts.forEach { linkedAccount -> + LinkedAccountSection( + item = linkedAccount, + balance = balanceMap[linkedAccount.address.toAddress()] ?: "", + onCopyClick = onCopyClick, + onAccountClick = { onAccountClick(linkedAccount.address) } + ) + } } } } @@ -750,6 +790,50 @@ fun BottomSection( } } +@Composable +private fun ShimmerBox( + modifier: Modifier, + shape: Shape = RoundedCornerShape(4.dp) +) { + val alpha by rememberInfiniteTransition(label = "shimmer").animateFloat( + initialValue = 0.3f, + targetValue = 1.0f, + animationSpec = infiniteRepeatable( + animation = tween(durationMillis = 900, easing = LinearEasing), + repeatMode = RepeatMode.Reverse + ), + label = "shimmer_alpha" + ) + Box( + modifier = modifier + .alpha(alpha) + .background(colorResource(id = R.color.bg_card), shape) + ) +} + +@Composable +private fun ShimmerWalletAccountRow() { + Row( + verticalAlignment = Alignment.CenterVertically, + modifier = Modifier + .fillMaxWidth() + .padding(vertical = 12.dp) + ) { + ShimmerBox( + modifier = Modifier.size(42.dp), + shape = CircleShape + ) + Spacer(modifier = Modifier.width(9.dp)) + Column { + ShimmerBox(modifier = Modifier.width(100.dp).height(14.dp)) + Spacer(modifier = Modifier.height(2.dp)) + ShimmerBox(modifier = Modifier.width(70.dp).height(12.dp)) + Spacer(modifier = Modifier.height(2.dp)) + ShimmerBox(modifier = Modifier.width(50.dp).height(12.dp)) + } + } +} + fun setupDrawerLayoutCompose(drawer: DrawerLayout) { val composeView = ComposeView(drawer.context) composeView.setContent { diff --git a/app/src/main/java/com/flowfoundation/wallet/page/profile/compose/SettingScreen.kt b/app/src/main/java/com/flowfoundation/wallet/page/profile/compose/SettingScreen.kt index e36cb99f..5ee9fccb 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/profile/compose/SettingScreen.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/profile/compose/SettingScreen.kt @@ -13,7 +13,9 @@ import androidx.compose.ui.Modifier import androidx.compose.ui.platform.LocalContext import androidx.compose.ui.res.colorResource import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.TextStyle import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.style.LineBreak import androidx.compose.ui.text.style.TextAlign import androidx.compose.ui.unit.dp import androidx.compose.ui.unit.sp @@ -302,6 +304,7 @@ fun SettingScreen( text = stringResource(R.string.free_gas_fee_desc), fontSize = 12.sp, color = colorResource(R.color.text_2), + style = TextStyle(lineBreak = LineBreak.Paragraph), modifier = Modifier .fillMaxWidth() .padding(top = 6.dp) diff --git a/app/src/main/java/com/flowfoundation/wallet/page/profile/subpage/developer/presenter/DeveloperModePresenter.kt b/app/src/main/java/com/flowfoundation/wallet/page/profile/subpage/developer/presenter/DeveloperModePresenter.kt index cc98319d..582681d7 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/profile/subpage/developer/presenter/DeveloperModePresenter.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/profile/subpage/developer/presenter/DeveloperModePresenter.kt @@ -33,7 +33,9 @@ import com.flowfoundation.wallet.utils.updateChainNetworkPreference import com.flowfoundation.wallet.utils.getWatchCollectibleAddress import com.flowfoundation.wallet.utils.setWatchCollectibleAddress import com.flowfoundation.wallet.utils.clearWatchCollectibleAddress +import com.flowfoundation.wallet.utils.isHideCOAWithZeroBalanceEnable import com.flowfoundation.wallet.utils.isWrapEOATxWithCadenceEnable +import com.flowfoundation.wallet.utils.setHideCOAWithZeroBalanceEnable import com.flowfoundation.wallet.utils.setWrapEOATxWithCadenceEnable import com.flowfoundation.wallet.widgets.ProgressDialog import kotlinx.coroutines.delay @@ -81,6 +83,7 @@ class DeveloperModePresenter( // Initialize Watch Collectible Address setupWatchCollectibleAddress() setupWrapEOATxWithCadence() + setupHideCOAWithZeroBalance() developerModePreference.setOnCheckedChangeListener { setDevelopContentVisible(it) @@ -178,6 +181,18 @@ class DeveloperModePresenter( } } + private fun setupHideCOAWithZeroBalance() { + ioScope { + val isHide = isHideCOAWithZeroBalanceEnable() + uiScope { + binding.hideCoaZeroBalance.setChecked(isHide) + binding.hideCoaZeroBalance.setOnCheckedChangeListener { + setHideCOAWithZeroBalanceEnable(it) + } + } + } + } + private fun setupWatchCollectibleAddress() { val savedAddress = getWatchCollectibleAddress() diff --git a/app/src/main/java/com/flowfoundation/wallet/page/wallet/presenter/WalletFragmentPresenter.kt b/app/src/main/java/com/flowfoundation/wallet/page/wallet/presenter/WalletFragmentPresenter.kt index f56f5ab0..289c933e 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/wallet/presenter/WalletFragmentPresenter.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/wallet/presenter/WalletFragmentPresenter.kt @@ -84,6 +84,8 @@ class WalletFragmentPresenter( model.data?.let { reportEvent("wallet_coin_list_loaded", mapOf("count" to it.size.toString())) adapter.setNewDiffData(it) + binding.shimmerCoinList.stopShimmer() + binding.shimmerCoinList.gone() binding.refreshLayout.isRefreshing = false bindUserInfo() } diff --git a/app/src/main/java/com/flowfoundation/wallet/page/wallet/presenter/WalletHeaderPresenter.kt b/app/src/main/java/com/flowfoundation/wallet/page/wallet/presenter/WalletHeaderPresenter.kt index 1124d983..dbc215f8 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/wallet/presenter/WalletHeaderPresenter.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/wallet/presenter/WalletHeaderPresenter.kt @@ -3,7 +3,6 @@ package com.flowfoundation.wallet.page.wallet.presenter import android.annotation.SuppressLint import android.view.View import android.widget.TextView -import android.widget.Toast import androidx.fragment.app.Fragment import androidx.fragment.app.FragmentActivity import androidx.lifecycle.ViewModelProvider @@ -68,6 +67,8 @@ class WalletHeaderPresenter( ).ifEmpty { "0" } ) ivHide.setImageResource(if (isHideBalance) R.drawable.ic_eye_off else R.drawable.ic_eye_on) + shimmerBalance.stopShimmer() + shimmerBalance.gone() } val count = if (model.coinCount > 0 ) model.coinCount else FungibleTokenListManager.getCurrentDisplayTokenListSnapshot().size @@ -80,6 +81,8 @@ class WalletHeaderPresenter( cvReceive.setOnClickListener { ReactNativeActivity.launch(view.context, RNBridge.ScreenType.RECEIVE) } val address = shortenEVMString(WalletManager.selectedWalletAddress().toAddress()) tvAddress.text = address + shimmerAddress.stopShimmer() + shimmerAddress.gone() ivCopy.setVisible(address.isNotBlank()) ivCopy.setOnClickListener { copyAddress( diff --git a/app/src/main/java/com/flowfoundation/wallet/utils/PreferenceUtils.kt b/app/src/main/java/com/flowfoundation/wallet/utils/PreferenceUtils.kt index 528a9486..0ea831e1 100644 --- a/app/src/main/java/com/flowfoundation/wallet/utils/PreferenceUtils.kt +++ b/app/src/main/java/com/flowfoundation/wallet/utils/PreferenceUtils.kt @@ -37,6 +37,7 @@ private val KEY_HIDE_WALLET_BALANCE = booleanPreferencesKey("KEY_HIDE_WALLET_BAL private val KEY_FREE_GAS_ENABLE = booleanPreferencesKey("KEY_FREE_GAS_ENABLE") private val KEY_WRAP_EOA_TX_WITH_CADENCE = booleanPreferencesKey("KEY_WRAP_EOA_TX_WITH_CADENCE") +private val KEY_HIDE_COA_WITH_ZERO_BALANCE = booleanPreferencesKey("KEY_HIDE_COA_WITH_ZERO_BALANCE") private const val KEY_IS_STAKING_GUIDE_PAGE_DISPLAYED = "KEY_IS_STAKING_GUIDE_PAGE_DISPLAYED" private val KEY_IS_MEOW_DOMAIN_CLAIMED = booleanPreferencesKey("KEY_IS_MEOW_DOMAIN_CLAIMED") @@ -163,7 +164,12 @@ suspend fun isWrapEOATxWithCadenceEnable(): Boolean = dataStore.data.map { it[KE fun setWrapEOATxWithCadenceEnable(isWrap: Boolean) { edit { dataStore.edit { it[KEY_WRAP_EOA_TX_WITH_CADENCE] = isWrap } } } +suspend fun isHideCOAWithZeroBalanceEnable(): Boolean = + dataStore.data.map { it[KEY_HIDE_COA_WITH_ZERO_BALANCE] ?: true }.first() +fun setHideCOAWithZeroBalanceEnable(isHide: Boolean) { + edit { dataStore.edit { it[KEY_HIDE_COA_WITH_ZERO_BALANCE] = isHide } } +} fun isStakingGuideDisplayed(): Boolean { return sharedPreferencesTraditional.getBoolean(KEY_IS_STAKING_GUIDE_PAGE_DISPLAYED, false) diff --git a/app/src/main/res/layout/activity_developer_mode_setting.xml b/app/src/main/res/layout/activity_developer_mode_setting.xml index 781c6f5e..8416522f 100644 --- a/app/src/main/res/layout/activity_developer_mode_setting.xml +++ b/app/src/main/res/layout/activity_developer_mode_setting.xml @@ -201,6 +201,31 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/app/src/main/res/layout/layout_wallet_coordinator_header.xml b/app/src/main/res/layout/layout_wallet_coordinator_header.xml index 091cbf9e..a806bef0 100644 --- a/app/src/main/res/layout/layout_wallet_coordinator_header.xml +++ b/app/src/main/res/layout/layout_wallet_coordinator_header.xml @@ -73,6 +73,41 @@ app:layout_constraintEnd_toEndOf="parent" app:layout_constraintTop_toTopOf="@id/tv_address" app:layout_constraintBottom_toBottomOf="@id/tv_address"/> + + + + + + + + @@ -330,4 +365,4 @@ - \ No newline at end of file + diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index a339434c..8be83dc3 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -654,6 +654,7 @@ Please try again later. Debug View Wrap EOA TX with Cadence + Hide COA With Zero Balance Export Log View Recovery Phrase Clear From 9262a5cff7ebf8fc3e296af0ae77b6932a42d2b1 Mon Sep 17 00:00:00 2001 From: Meng Date: Mon, 9 Mar 2026 16:41:55 +0800 Subject: [PATCH 08/27] fix: remove custom login delay --- .../wallet/firebase/auth/FirebaseAuth.kt | 19 ++++++++++++------- .../wallet/manager/account/AccountManager.kt | 10 ++++++---- .../wallet/page/walletrestore/Utils.kt | 5 ----- 3 files changed, 18 insertions(+), 16 deletions(-) diff --git a/app/src/main/java/com/flowfoundation/wallet/firebase/auth/FirebaseAuth.kt b/app/src/main/java/com/flowfoundation/wallet/firebase/auth/FirebaseAuth.kt index eaf3f68f..e344c9c9 100644 --- a/app/src/main/java/com/flowfoundation/wallet/firebase/auth/FirebaseAuth.kt +++ b/app/src/main/java/com/flowfoundation/wallet/firebase/auth/FirebaseAuth.kt @@ -42,6 +42,12 @@ fun firebaseCustomLogin(token: String, onComplete: FirebaseAuthCallback) { logd(TAG, "Attempting to sign in with custom token (length: ${token.length})") auth.signInWithCustomToken(token).addOnCompleteListener { task -> logd(TAG, "signInWithCustomToken completed - success: ${task.isSuccessful}") + // Capture currentUser immediately on the main thread before launching ioScope. + // Reading auth.currentUser inside ioScope is a race: a concurrent signInAnonymously() + // callback (triggered by HeaderInterceptor during auth transitions) can fire on the + // main thread between signInWithCustomToken completing and the IO coroutine reading + // currentUser, causing the anonymous user to overwrite the just-signed-in user. + val signedInUser = if (task.isSuccessful) auth.currentUser else null if (!task.isSuccessful) { logd(TAG, "ERROR: signInWithCustomToken failed - ${task.exception?.message}") } @@ -49,20 +55,19 @@ fun firebaseCustomLogin(token: String, onComplete: FirebaseAuthCallback) { ioScope { clearUserCache() if (task.isSuccessful) { - val newUser = auth.currentUser - logd(TAG, "Sign in successful, new user UID: ${newUser?.uid}") + logd(TAG, "Sign in successful, new user UID: ${signedInUser?.uid}") logd(TAG, "Requesting ID token refresh") - newUser?.getIdToken(true)?.addOnSuccessListener { _ -> + signedInUser?.getIdToken(true)?.addOnSuccessListener { _ -> logd(TAG, "ID token obtained successfully") uiScope { onComplete.invoke(true, null) } getFirebaseMessagingToken() - }?.addOnFailureListener { e -> - logd(TAG, "ERROR: Failed to get ID token - ${e.message}") - uiScope { onComplete.invoke(false, e) } - } + }?.addOnFailureListener { e -> + logd(TAG, "ERROR: Failed to get ID token - ${e.message}") + uiScope { onComplete.invoke(false, e) } + } } else { logd(TAG, "ERROR: Task unsuccessful, calling failure callback") val exception = task.exception diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt index 40cae41f..e45e1330 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt @@ -569,8 +569,9 @@ object AccountManager { logd(TAG, " Sign Algorithm: ${cryptoProvider.getSignatureAlgorithm()}") logd(TAG, " Key Weight: ${cryptoProvider.getKeyWeight()}") - // Get JWT with force refresh to avoid token expiration issues - val jwt = getFirebaseJwt() + // Get JWT with force refresh to ensure the newly-created anonymous user's token + // is propagated to Firebase backend before the server verifies it. + val jwt = getFirebaseJwt(forceRefresh = true) logd(TAG, "Retrieved JWT for account switch (length: ${jwt.length})") val publicKey = cryptoProvider.getPublicKey() @@ -723,8 +724,9 @@ object AccountManager { logd(TAG, " Sign Algorithm: ${cryptoProvider.getSignatureAlgorithm()}") logd(TAG, " Key Weight: ${cryptoProvider.getKeyWeight()}") - // Get JWT with force refresh to avoid token expiration issues - val jwt = getFirebaseJwt() + // Get JWT with force refresh to ensure the newly-created anonymous user's token + // is propagated to Firebase backend before the server verifies it. + val jwt = getFirebaseJwt(forceRefresh = true) logd(TAG, "Retrieved JWT for local account switch (length: ${jwt.length})") val publicKey = cryptoProvider.getPublicKey() diff --git a/app/src/main/java/com/flowfoundation/wallet/page/walletrestore/Utils.kt b/app/src/main/java/com/flowfoundation/wallet/page/walletrestore/Utils.kt index 390beabf..ba6362be 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/walletrestore/Utils.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/walletrestore/Utils.kt @@ -17,7 +17,6 @@ import com.flowfoundation.wallet.network.clearUserCache import com.flowfoundation.wallet.network.model.AccountKey import com.flowfoundation.wallet.network.model.WalletListData import com.flowfoundation.wallet.network.model.FlowAccountInfo -import com.flowfoundation.wallet.network.model.LoginRequest import com.flowfoundation.wallet.network.model.LoginV4Request import com.flowfoundation.wallet.network.retrofit import com.flowfoundation.wallet.utils.ioScope @@ -30,7 +29,6 @@ import com.flow.wallet.storage.FileSystemStorage import com.flowfoundation.wallet.firebase.auth.firebaseUid import com.flowfoundation.wallet.utils.Env import com.flowfoundation.wallet.wallet.DERIVATION_PATH -import kotlinx.coroutines.delay import kotlinx.coroutines.runBlocking import java.io.File @@ -245,9 +243,6 @@ suspend fun firebaseLogin(customToken: String, callback: (isSuccess: Boolean) -> } if (isSuccess) { - logd(TAG, "Auth cleanup successful, waiting 1 second before custom login") - // Add a delay to ensure Firebase auth state is cleared - delay(1000) logd(TAG, "Starting Firebase custom login with token") firebaseCustomLogin(customToken) { isSuccessful, errorMsg -> logd(TAG, "Firebase custom login completed - success: $isSuccessful, error: $errorMsg") From 0067b602f9ae3dcb504b8b278bbdecc385618c00 Mon Sep 17 00:00:00 2001 From: Meng Date: Tue, 10 Mar 2026 14:47:54 +0800 Subject: [PATCH 09/27] fix: switch jwt force refresh --- .../wallet/manager/account/AccountManager.kt | 14 ++++++++------ gradle.properties | 2 +- 2 files changed, 9 insertions(+), 7 deletions(-) diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt index e45e1330..13edc398 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt @@ -569,9 +569,10 @@ object AccountManager { logd(TAG, " Sign Algorithm: ${cryptoProvider.getSignatureAlgorithm()}") logd(TAG, " Key Weight: ${cryptoProvider.getKeyWeight()}") - // Get JWT with force refresh to ensure the newly-created anonymous user's token - // is propagated to Firebase backend before the server verifies it. - val jwt = getFirebaseJwt(forceRefresh = true) + // Use the cached token from the anonymous sign-in done in setToAnonymous(). + // forceRefresh=true would cause two separate network fetches (here and in HeaderInterceptor), + // returning tokens with different iat values, making signature verification fail on the server. + val jwt = getFirebaseJwt() logd(TAG, "Retrieved JWT for account switch (length: ${jwt.length})") val publicKey = cryptoProvider.getPublicKey() @@ -724,9 +725,10 @@ object AccountManager { logd(TAG, " Sign Algorithm: ${cryptoProvider.getSignatureAlgorithm()}") logd(TAG, " Key Weight: ${cryptoProvider.getKeyWeight()}") - // Get JWT with force refresh to ensure the newly-created anonymous user's token - // is propagated to Firebase backend before the server verifies it. - val jwt = getFirebaseJwt(forceRefresh = true) + // Use the cached token from the anonymous sign-in done in setToAnonymous(). + // forceRefresh=true would cause two separate network fetches (here and in HeaderInterceptor), + // returning tokens with different iat values, making signature verification fail on the server. + val jwt = getFirebaseJwt() logd(TAG, "Retrieved JWT for local account switch (length: ${jwt.length})") val publicKey = cryptoProvider.getPublicKey() diff --git a/gradle.properties b/gradle.properties index 1756a69d..1644431c 100644 --- a/gradle.properties +++ b/gradle.properties @@ -64,7 +64,7 @@ android.r8.dexing.parallel=true #android.bundle.enableUncompressedNativeLibs=false #android.experimental.enableArtProfiles=true -vCode=400000462 +vCode=400000463 vName=r3.1.0 # --- GitHub Packages (Flow Wallet Kit) --- From 9ab8ccb1c4c37da41e62c811d6076d336d57db69 Mon Sep 17 00:00:00 2001 From: Meng Date: Wed, 11 Mar 2026 11:23:18 +0800 Subject: [PATCH 10/27] feat: add new account & firebase login fix --- .../wallet/firebase/auth/FirebaseAuth.kt | 88 +++++----- .../wallet/manager/account/AccountManager.kt | 13 +- .../wallet/manager/config/AppConfig.kt | 7 +- .../wallet/network/AddAccountUtils.kt | 93 +++++++++++ .../wallet/network/ApiService.kt | 3 + .../wallet/network/UserRegisterUtils.kt | 31 +--- .../network/model/ManualAddressRequest.kt | 17 ++ .../page/account/AccountListActivity.kt | 106 +++++++++++-- .../page/account/AccountListViewModel.kt | 37 +++++ .../page/main/drawer/DrawerLayoutViewModel.kt | 46 +++++- .../main/presenter/DrawerLayoutContent.kt | 150 ++++++++++++++---- .../wallet/page/walletrestore/Utils.kt | 68 ++++---- 12 files changed, 494 insertions(+), 165 deletions(-) create mode 100644 app/src/main/java/com/flowfoundation/wallet/network/AddAccountUtils.kt create mode 100644 app/src/main/java/com/flowfoundation/wallet/network/model/ManualAddressRequest.kt diff --git a/app/src/main/java/com/flowfoundation/wallet/firebase/auth/FirebaseAuth.kt b/app/src/main/java/com/flowfoundation/wallet/firebase/auth/FirebaseAuth.kt index e344c9c9..47d08e22 100644 --- a/app/src/main/java/com/flowfoundation/wallet/firebase/auth/FirebaseAuth.kt +++ b/app/src/main/java/com/flowfoundation/wallet/firebase/auth/FirebaseAuth.kt @@ -10,9 +10,32 @@ import com.flowfoundation.wallet.utils.logd import com.flowfoundation.wallet.utils.uiScope import kotlin.coroutines.resume import kotlin.coroutines.suspendCoroutine +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock private const val TAG = "FirebaseAuth" +// Serialises all "currentUser == null → sign in" operations to prevent +// a concurrent getFirebaseJwt() from racing with setToAnonymous(). +private val authStateMutex = Mutex() + +/** + * Signs out the current non-anonymous user and signs in anonymously. + * Holds [authStateMutex] during signOut + signInAnonymously so that any + * concurrent [getFirebaseJwt] call waits instead of submitting a second + * signInAnonymously task that could later overwrite the custom-token user. + */ +suspend fun setToAnonymous(): Boolean { + if (!isAnonymousSignIn()) { + authStateMutex.withLock { + Firebase.auth.signOut() + signInAnonymously() + } + return isAnonymousSignIn() + } + return true +} + typealias FirebaseAuthCallback = (isSuccessful: Boolean, exception: Exception?) -> Unit fun isAnonymousSignIn(): Boolean { @@ -28,55 +51,20 @@ fun isUserSignIn(): Boolean { fun firebaseCustomLogin(token: String, onComplete: FirebaseAuthCallback) { logd(TAG, "=== firebaseCustomLogin START ===") val auth = Firebase.auth - val currentUser = auth.currentUser - logd(TAG, "Current Firebase user: ${currentUser?.uid ?: "null"}") - - // Always sign in with the new custom token, even if there's already a user - // This ensures we switch to the newly registered user - // Note: signInWithCustomToken automatically replaces the current user, no need to sign out first - if (currentUser != null) { - logd(TAG, "User already signed in, UID: ${currentUser.uid}, isAnonymous: ${currentUser.isAnonymous}") - logd(TAG, "Will replace with new user from custom token...") - } + logd(TAG, "Current Firebase user: ${auth.currentUser?.uid ?: "null"}") - logd(TAG, "Attempting to sign in with custom token (length: ${token.length})") auth.signInWithCustomToken(token).addOnCompleteListener { task -> - logd(TAG, "signInWithCustomToken completed - success: ${task.isSuccessful}") - // Capture currentUser immediately on the main thread before launching ioScope. - // Reading auth.currentUser inside ioScope is a race: a concurrent signInAnonymously() - // callback (triggered by HeaderInterceptor during auth transitions) can fire on the - // main thread between signInWithCustomToken completing and the IO coroutine reading - // currentUser, causing the anonymous user to overwrite the just-signed-in user. - val signedInUser = if (task.isSuccessful) auth.currentUser else null - if (!task.isSuccessful) { - logd(TAG, "ERROR: signInWithCustomToken failed - ${task.exception?.message}") - } - - ioScope { - clearUserCache() - if (task.isSuccessful) { - logd(TAG, "Sign in successful, new user UID: ${signedInUser?.uid}") - logd(TAG, "Requesting ID token refresh") - - signedInUser?.getIdToken(true)?.addOnSuccessListener { _ -> - logd(TAG, "ID token obtained successfully") - uiScope { - onComplete.invoke(true, null) - } - getFirebaseMessagingToken() - }?.addOnFailureListener { e -> - logd(TAG, "ERROR: Failed to get ID token - ${e.message}") - uiScope { onComplete.invoke(false, e) } - } - } else { - logd(TAG, "ERROR: Task unsuccessful, calling failure callback") - val exception = task.exception - logd(TAG, "Exception type: ${exception?.javaClass?.simpleName}") - logd(TAG, "Exception message: ${exception?.message}") - uiScope { - onComplete.invoke(false, exception) - } + if (task.isSuccessful) { + logd(TAG, "Sign in successful, new user UID: ${auth.currentUser?.uid}") + onComplete.invoke(true, null) + // Background cleanup — runs after the caller's callback has already returned. + ioScope { + clearUserCache() + getFirebaseMessagingToken() } + } else { + logd(TAG, "ERROR: signInWithCustomToken failed - ${task.exception?.message}") + onComplete.invoke(false, task.exception) } } } @@ -91,7 +79,13 @@ suspend fun getFirebaseJwt(forceRefresh: Boolean = false) = suspendCoroutine { c ioScope { val auth = Firebase.auth if (auth.currentUser == null) { - signInAnonymously() + authStateMutex.withLock { + // Re-check after acquiring lock: setToAnonymous() may have already + // completed and set currentUser while we were waiting. + if (Firebase.auth.currentUser == null) { + signInAnonymously() + } + } } val user = auth.currentUser diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt index 13edc398..9a899009 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt @@ -8,8 +8,7 @@ import com.flowfoundation.wallet.cache.AccountCacheManager import com.flowfoundation.wallet.cache.UserPrefixCacheManager import com.flowfoundation.wallet.firebase.auth.firebaseUid import com.flowfoundation.wallet.firebase.auth.getFirebaseJwt -import com.flowfoundation.wallet.firebase.auth.isAnonymousSignIn -import com.flowfoundation.wallet.firebase.auth.signInAnonymously +import com.flowfoundation.wallet.firebase.auth.setToAnonymous import com.flowfoundation.wallet.firebase.messaging.uploadPushToken import com.flowfoundation.wallet.manager.account.model.LocalSwitchAccount import com.flowfoundation.wallet.manager.app.chainNetWorkString @@ -40,8 +39,6 @@ import com.flowfoundation.wallet.utils.setRegistered import com.flowfoundation.wallet.utils.toast import com.flowfoundation.wallet.utils.uiScope import com.flowfoundation.wallet.wallet.Wallet -import com.google.firebase.auth.ktx.auth -import com.google.firebase.ktx.Firebase import com.google.gson.Gson import com.google.gson.reflect.TypeToken import kotlinx.serialization.Serializable @@ -654,14 +651,6 @@ object AccountManager { } } - private suspend fun setToAnonymous(): Boolean { - if (!isAnonymousSignIn()) { - Firebase.auth.signOut() - return signInAnonymously() - } - return true - } - private fun dispatchListeners(account: Account) { logd(TAG, "dispatchListeners: ${account.userInfo.username}") uiScope { diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/config/AppConfig.kt b/app/src/main/java/com/flowfoundation/wallet/manager/config/AppConfig.kt index d1b9a91d..9dbc6729 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/config/AppConfig.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/config/AppConfig.kt @@ -54,6 +54,8 @@ object AppConfig { fun checkBloctoKeyRotation() = isDev() || isTesting() || (config().getFeatures().bloctoKeyRotation ?: false) + fun canCreateNewAccount() = isDev() || isTesting() || (config().getFeatures().createNewAccount ?: false) + fun addressRegistry(network: Int): Map { return when (network) { NETWORK_TESTNET -> flowAddressRegistry().testnet @@ -228,7 +230,10 @@ private data class Features( @SerializedName("blocto_key_rotation") val bloctoKeyRotation: Boolean?, @SerializedName("coa_migration") - val coaMigration: Boolean? + val coaMigration: Boolean?, + + @SerializedName("create_new_account") + val createNewAccount: Boolean? ) private data class Payer( diff --git a/app/src/main/java/com/flowfoundation/wallet/network/AddAccountUtils.kt b/app/src/main/java/com/flowfoundation/wallet/network/AddAccountUtils.kt new file mode 100644 index 00000000..cd9ffd3b --- /dev/null +++ b/app/src/main/java/com/flowfoundation/wallet/network/AddAccountUtils.kt @@ -0,0 +1,93 @@ +package com.flowfoundation.wallet.network + +import com.flowfoundation.wallet.manager.account.AccountManager +import com.flowfoundation.wallet.manager.app.chainNetWorkString +import com.flowfoundation.wallet.manager.emoji.AccountEmojiManager +import com.flowfoundation.wallet.manager.key.CryptoProviderManager +import com.flowfoundation.wallet.manager.wallet.WalletManager +import com.flowfoundation.wallet.manager.walletdata.FlowWallet +import com.flowfoundation.wallet.network.model.ManualAddressRequest +import com.flowfoundation.wallet.utils.logd +import com.flowfoundation.wallet.utils.loge +import org.onflow.flow.ChainId + +private const val TAG = "AddAccountUtils" + +/** + * Add a new Flow address to the current account by calling POST /v2/user/manualaddress. + * Waits for blockchain confirmation via fetchAccountByCreationTxId. + * + * @return the new formatted address (with 0x prefix), or null on failure + */ +suspend fun addNewFlowAccount(): String? { + return try { + val cryptoProvider = CryptoProviderManager.getCurrentCryptoProvider() + if (cryptoProvider == null) { + loge(TAG, "Cannot get current crypto provider") + return null + } + + val publicKey = cryptoProvider.getPublicKey() + val hashAlgorithm = cryptoProvider.getHashAlgorithm().cadenceIndex + val signatureAlgorithm = cryptoProvider.getSignatureAlgorithm().cadenceIndex + + logd(TAG, "Adding new account with publicKey: $publicKey, hashAlgo: $hashAlgorithm, signAlgo: $signatureAlgorithm") + + val service = retrofit().create(ApiService::class.java) + val request = ManualAddressRequest( + hashAlgorithm = hashAlgorithm, + publicKey = publicKey, + signatureAlgorithm = signatureAlgorithm, + weight = 1000 + ) + + val response = service.createManualAddress(request) + val txId = response.data?.txid + if (txId.isNullOrBlank()) { + loge(TAG, "No txId returned from createManualAddress") + return null + } + + logd(TAG, "Got txId: $txId, waiting for blockchain confirmation...") + + val chainId = when (chainNetWorkString()) { + "mainnet" -> ChainId.Mainnet + "testnet" -> ChainId.Testnet + else -> ChainId.Mainnet + } + + val walletForSDK = WalletManager.wallet() + if (walletForSDK == null) { + loge(TAG, "No wallet available from WalletManager") + return null + } + + logd(TAG, "Calling fetchAccountByCreationTxId with txId: $txId on chainId: $chainId") + val fetchedAccount = walletForSDK.fetchAccountByCreationTxId(txId, chainId) + val createdAddress = fetchedAccount.address + + logd(TAG, "New account fetched at address: $createdAddress") + + val formattedAddress = if (createdAddress.startsWith("0x")) createdAddress else "0x$createdAddress" + val emojiInfo = AccountEmojiManager.getEmojiByAddress(formattedAddress) + + val flowWallet = FlowWallet( + address = formattedAddress, + name = emojiInfo.emojiName, + emojiId = emojiInfo.emojiId, + chainIdString = chainNetWorkString(), + linkedWallets = emptyList() + ) + + AccountManager.updateCurrentAccount { account -> + account.copy(walletNodes = account.walletNodes + flowWallet) + } + + logd(TAG, "New FlowWallet added to account: $formattedAddress") + formattedAddress + } catch (e: Exception) { + loge(TAG, "Failed to add new Flow account: ${e.message}") + e.printStackTrace() + null + } +} diff --git a/app/src/main/java/com/flowfoundation/wallet/network/ApiService.kt b/app/src/main/java/com/flowfoundation/wallet/network/ApiService.kt index 9a17abd4..15524f10 100644 --- a/app/src/main/java/com/flowfoundation/wallet/network/ApiService.kt +++ b/app/src/main/java/com/flowfoundation/wallet/network/ApiService.kt @@ -17,6 +17,9 @@ interface ApiService { @POST("/v2/user/address") suspend fun createWalletV2(): CreateWalletV2Response + @POST("/v2/user/manualaddress") + suspend fun createManualAddress(@Body param: ManualAddressRequest): CreateWalletV2Response + @GET("/v1/user/check") suspend fun checkUsername(@Query("username") username: String): UsernameCheckResponse diff --git a/app/src/main/java/com/flowfoundation/wallet/network/UserRegisterUtils.kt b/app/src/main/java/com/flowfoundation/wallet/network/UserRegisterUtils.kt index 1c0155db..568586d2 100644 --- a/app/src/main/java/com/flowfoundation/wallet/network/UserRegisterUtils.kt +++ b/app/src/main/java/com/flowfoundation/wallet/network/UserRegisterUtils.kt @@ -11,8 +11,7 @@ import com.flowfoundation.wallet.R import com.flowfoundation.wallet.firebase.auth.firebaseCustomLogin import com.flowfoundation.wallet.firebase.auth.firebaseUid import com.flowfoundation.wallet.firebase.auth.getFirebaseJwt -import com.flowfoundation.wallet.firebase.auth.isAnonymousSignIn -import com.flowfoundation.wallet.firebase.auth.signInAnonymously +import com.flowfoundation.wallet.firebase.auth.setToAnonymous import com.flowfoundation.wallet.manager.account.Account import com.flowfoundation.wallet.manager.account.AccountManager import com.flowfoundation.wallet.manager.account.DeviceInfoManager @@ -58,9 +57,6 @@ import com.flowfoundation.wallet.utils.storeWalletPassword import com.flowfoundation.wallet.utils.toast import com.flowfoundation.wallet.utils.updateChainNetworkPreference import com.flowfoundation.wallet.wallet.Wallet -import com.google.firebase.auth.ktx.auth -import com.google.firebase.ktx.Firebase -import com.google.firebase.messaging.FirebaseMessaging import com.google.gson.Gson import com.google.gson.reflect.TypeToken import com.nftco.flow.sdk.HashAlgorithm @@ -527,16 +523,13 @@ private suspend fun registerOutblockUserInternal( } private fun registerFirebase(user: RegisterResponse, callback: (isSuccess: Boolean) -> Unit) { - FirebaseMessaging.getInstance().deleteToken() - Firebase.auth.currentUser?.delete()?.addOnCompleteListener { - logd(TAG, "delete user finish exception:${it.exception}") - if (it.isSuccessful) { - firebaseCustomLogin(user.data.customToken) { isSuccessful, _ -> - if (isSuccessful) { - MixpanelManager.identifyUserProfile() - callback(true) - } else callback(false) - } + // signInWithCustomToken atomically replaces the current anonymous user without going through + // null. The prior delete() call created a null window that raced with background + // getFirebaseJwt() → signInAnonymously() calls. FCM token is refreshed by firebaseCustomLogin. + firebaseCustomLogin(user.data.customToken) { isSuccessful, _ -> + if (isSuccessful) { + MixpanelManager.identifyUserProfile() + callback(true) } else callback(false) } } @@ -598,14 +591,6 @@ fun generatePrefix(text: String): String { return bytes.joinToString("") { "%02x".format(it) } } -private suspend fun setToAnonymous(): Boolean { - if (!isAnonymousSignIn()) { - Firebase.auth.signOut() - return signInAnonymously() - } - return true -} - // create user failed, resume account private suspend fun resumeAccount() { if (!setToAnonymous()) { diff --git a/app/src/main/java/com/flowfoundation/wallet/network/model/ManualAddressRequest.kt b/app/src/main/java/com/flowfoundation/wallet/network/model/ManualAddressRequest.kt new file mode 100644 index 00000000..7d8cf6c2 --- /dev/null +++ b/app/src/main/java/com/flowfoundation/wallet/network/model/ManualAddressRequest.kt @@ -0,0 +1,17 @@ +package com.flowfoundation.wallet.network.model + +import com.google.gson.annotations.SerializedName + +data class ManualAddressRequest( + @SerializedName("hashAlgorithm") + val hashAlgorithm: Int, + + @SerializedName("publicKey") + val publicKey: String, + + @SerializedName("signatureAlgorithm") + val signatureAlgorithm: Int, + + @SerializedName("weight") + val weight: Int +) diff --git a/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListActivity.kt b/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListActivity.kt index bf251451..fc617227 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListActivity.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListActivity.kt @@ -7,16 +7,24 @@ import androidx.activity.compose.setContent import androidx.compose.foundation.background import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size import androidx.compose.foundation.layout.statusBarsPadding +import androidx.compose.foundation.layout.width import androidx.compose.foundation.lazy.LazyColumn import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.material.icons.Icons import androidx.compose.material.icons.automirrored.filled.ArrowBack import androidx.compose.material.icons.filled.Add +import androidx.compose.material3.CircularProgressIndicator import androidx.compose.material3.ExperimentalMaterial3Api import androidx.compose.material3.Icon import androidx.compose.material3.IconButton @@ -30,9 +38,20 @@ import androidx.compose.runtime.collectAsState import androidx.compose.runtime.getValue import androidx.compose.runtime.remember import androidx.compose.runtime.DisposableEffect +import androidx.compose.animation.core.LinearEasing +import androidx.compose.animation.core.RepeatMode +import androidx.compose.animation.core.animateFloat +import androidx.compose.animation.core.infiniteRepeatable +import androidx.compose.animation.core.rememberInfiniteTransition +import androidx.compose.animation.core.tween +import androidx.compose.ui.Alignment +import androidx.compose.ui.draw.alpha +import androidx.compose.ui.draw.clip +import androidx.compose.ui.draw.rotate +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.res.painterResource import androidx.compose.ui.Modifier import androidx.compose.ui.platform.LocalContext -import androidx.compose.ui.platform.LocalLifecycleOwner import androidx.compose.ui.res.colorResource import androidx.lifecycle.Lifecycle import androidx.lifecycle.LifecycleEventObserver @@ -47,7 +66,6 @@ import androidx.lifecycle.viewmodel.compose.viewModel import com.flowfoundation.wallet.R import com.flowfoundation.wallet.base.activity.BaseActivity import com.flowfoundation.wallet.manager.wallet.WalletManager -import com.flowfoundation.wallet.page.dialog.profile.ProfileSwitchDialog import com.flowfoundation.wallet.page.wallet.view.AccountItemSection import com.flowfoundation.wallet.page.profile.subpage.wallet.WalletSettingActivity import com.flowfoundation.wallet.page.profile.subpage.wallet.childaccountdetail.ChildAccountDetailActivity @@ -66,10 +84,7 @@ class AccountListActivity : BaseActivity() { setContent { AccountListScreen( - onBackPressed = { finish() }, - onAddPressed = { - ProfileSwitchDialog().show(supportFragmentManager, "profile_switch") - } + onBackPressed = { finish() } ) } } @@ -85,12 +100,13 @@ class AccountListActivity : BaseActivity() { @Composable fun AccountListScreen( onBackPressed: () -> Unit = {}, - onAddPressed: () -> Unit = {}, viewModel: AccountListViewModel = viewModel() ) { val accounts by viewModel.accounts.collectAsState() val balanceMap by viewModel.balanceMap.collectAsState() val hiddenAccounts by viewModel.hiddenAccounts.collectAsState() + val isAddingAccount by viewModel.isAddingAccount.collectAsState() + val canAddAccount by viewModel.canAddAccount.collectAsState() val context = LocalContext.current val activity = remember { getActivityFromContext(context) as FragmentActivity } val lifecycleOwner = androidx.lifecycle.compose.LocalLifecycleOwner.current @@ -138,10 +154,14 @@ fun AccountListScreen( } }, actions = { - IconButton(onClick = onAddPressed) { + IconButton( + onClick = { viewModel.addAccount() }, + enabled = canAddAccount, + modifier = Modifier.alpha(if (canAddAccount) 1f else 0f) + ) { Icon( imageVector = Icons.Default.Add, - contentDescription = "Add Profile", + contentDescription = "Add Account", tint = colorResource(id = R.color.text) ) } @@ -186,7 +206,75 @@ fun AccountListScreen( } ) } + if (isAddingAccount) { + item { LoadingAccountListRow() } + } } } } } + +@Composable +private fun LoadingAccountListRow() { + val infiniteTransition = rememberInfiniteTransition(label = "loading") + val rotation by infiniteTransition.animateFloat( + initialValue = 0f, + targetValue = 360f, + animationSpec = infiniteRepeatable( + animation = tween(durationMillis = 2400, easing = LinearEasing), + repeatMode = RepeatMode.Restart + ), + label = "loading_rotation" + ) + Row( + verticalAlignment = Alignment.CenterVertically, + modifier = Modifier + .fillMaxWidth() + .padding(vertical = 12.dp) + ) { + Box( + modifier = Modifier.size(45.dp), + contentAlignment = Alignment.Center + ) { + CircularProgressIndicator( + progress = { 0.25f }, + modifier = Modifier.size(45.dp).rotate(rotation), + color = colorResource(id = R.color.accent_green), + trackColor = colorResource(id = R.color.accent_green_8), + strokeWidth = 7.dp + ) + Icon( + painter = painterResource(id = R.drawable.ic_coin_flow), + contentDescription = null, + modifier = Modifier.size(30.dp), + tint = Color.Unspecified + ) + } + Spacer(modifier = Modifier.width(9.dp)) + Column { + Box( + modifier = Modifier + .width(60.dp) + .height(14.dp) + .clip(RoundedCornerShape(4.dp)) + .background(colorResource(id = R.color.bg_card)) + ) + Spacer(modifier = Modifier.height(2.dp)) + Box( + modifier = Modifier + .width(100.dp) + .height(12.dp) + .clip(RoundedCornerShape(4.dp)) + .background(colorResource(id = R.color.bg_card)) + ) + Spacer(modifier = Modifier.height(2.dp)) + Box( + modifier = Modifier + .width(80.dp) + .height(12.dp) + .clip(RoundedCornerShape(4.dp)) + .background(colorResource(id = R.color.bg_card)) + ) + } + } +} diff --git a/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt b/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt index fac6a07b..54a5a243 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt @@ -1,6 +1,7 @@ package com.flowfoundation.wallet.page.account import androidx.lifecycle.ViewModel +import com.flowfoundation.wallet.R import com.flowfoundation.wallet.firebase.auth.firebaseUid import com.flowfoundation.wallet.manager.account.AccountManager import com.flowfoundation.wallet.manager.account.AccountVisibilityManager @@ -13,13 +14,18 @@ import com.flowfoundation.wallet.manager.walletdata.COAWallet import com.flowfoundation.wallet.manager.walletdata.ChildWallet import com.flowfoundation.wallet.manager.walletdata.EOAWallet import com.flowfoundation.wallet.manager.walletdata.FlowWallet +import com.flowfoundation.wallet.manager.config.AppConfig +import com.flowfoundation.wallet.manager.key.AndroidKeystoreCryptoProvider +import com.flowfoundation.wallet.manager.key.CryptoProviderManager import com.flowfoundation.wallet.network.ApiService +import com.flowfoundation.wallet.network.addNewFlowAccount import com.flowfoundation.wallet.network.retrofitApi import com.flowfoundation.wallet.page.main.model.WalletAccountData import com.flowfoundation.wallet.page.main.model.LinkedAccountData import com.flowfoundation.wallet.utils.formatLargeBalanceNumber import com.flowfoundation.wallet.utils.isHideCOAWithZeroBalanceEnable import com.flowfoundation.wallet.utils.ioScope +import com.flowfoundation.wallet.utils.toast import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.StateFlow import kotlinx.coroutines.flow.asStateFlow @@ -36,6 +42,12 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { private val _hiddenAccounts = MutableStateFlow>(emptySet()) val hiddenAccounts: StateFlow> = _hiddenAccounts.asStateFlow() + private val _isAddingAccount = MutableStateFlow(false) + val isAddingAccount: StateFlow = _isAddingAccount.asStateFlow() + + private val _canAddAccount = MutableStateFlow(false) + val canAddAccount: StateFlow = _canAddAccount.asStateFlow() + private val service by lazy { retrofitApi().create(ApiService::class.java) } // Cache for verified EVM addresses that should be included in linkedAccounts @@ -145,12 +157,37 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { _hiddenAccounts.value = hiddenAccountsSet } + val flowWalletCount = walletNodes.filterIsInstance() + .count { it.chainIdString == currentNetwork } + val cryptoProvider = CryptoProviderManager.getCurrentCryptoProvider() + _canAddAccount.value = AppConfig.canCreateNewAccount() + && flowWalletCount < 5 + && cryptoProvider != null + && cryptoProvider !is AndroidKeystoreCryptoProvider + if (refreshBalance) { fetchAllBalances(addressList, pendingEvmAddresses) } } } + fun addAccount() { + ioScope { + _isAddingAccount.value = true + try { + val result = addNewFlowAccount() + if (result == null) { + _isAddingAccount.value = false + toast(msgRes = R.string.common_error_hint) + } else { + refreshWalletList(false) + } + } finally { + _isAddingAccount.value = false + } + } + } + private fun fetchAllBalances(addressList: List, pendingEvmAddresses: List> = emptyList()) { ioScope { val balanceMap = cadenceGetAllFlowBalance(addressList) ?: return@ioScope diff --git a/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt b/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt index 1173b28d..465d237e 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt @@ -1,7 +1,7 @@ package com.flowfoundation.wallet.page.main.drawer import androidx.lifecycle.ViewModel -import com.flowfoundation.wallet.firebase.auth.firebaseUid +import com.flowfoundation.wallet.R import com.flowfoundation.wallet.manager.account.Account import com.flowfoundation.wallet.manager.account.AccountManager import com.flowfoundation.wallet.manager.app.chainNetWorkString @@ -14,7 +14,11 @@ import com.flowfoundation.wallet.manager.walletdata.EOAWallet import com.flowfoundation.wallet.manager.walletdata.ChildWallet import com.flowfoundation.wallet.manager.walletdata.COAWallet import com.flowfoundation.wallet.manager.wallet.WalletManager +import com.flowfoundation.wallet.manager.config.AppConfig +import com.flowfoundation.wallet.manager.key.AndroidKeystoreCryptoProvider +import com.flowfoundation.wallet.manager.key.CryptoProviderManager import com.flowfoundation.wallet.network.ApiService +import com.flowfoundation.wallet.network.addNewFlowAccount import com.flowfoundation.wallet.network.retrofitApi import com.flowfoundation.wallet.utils.formatLargeBalanceNumber import com.flowfoundation.wallet.utils.isHideCOAWithZeroBalanceEnable @@ -24,6 +28,7 @@ import com.flowfoundation.wallet.manager.account.AccountVisibilityManager import com.flowfoundation.wallet.manager.account.OnAccountUpdate import com.flowfoundation.wallet.page.main.model.LinkedAccountData import com.flowfoundation.wallet.page.main.model.WalletAccountData +import com.flowfoundation.wallet.utils.toast import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.StateFlow import kotlinx.coroutines.flow.asStateFlow @@ -43,6 +48,12 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { private val _balanceMap = MutableStateFlow>(emptyMap()) val balanceMap: StateFlow> = _balanceMap.asStateFlow() + private val _isAddingAccount = MutableStateFlow(false) + val isAddingAccount: StateFlow = _isAddingAccount.asStateFlow() + + private val _canAddAccount = MutableStateFlow(false) + val canAddAccount: StateFlow = _canAddAccount.asStateFlow() + private val service by lazy { retrofitApi().create(ApiService::class.java) } // Cache for verified EVM addresses that should be included in linkedAccounts @@ -143,8 +154,11 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { } } - // Filter out hidden accounts for the current user - val userId = firebaseUid() + // Filter out hidden accounts for the current user. + // Use AccountManager (already updated before listeners fire) rather than + // firebaseUid() (reads Firebase.auth.currentUser which can still be anonymous + // during the auth transition window of an account switch). + val userId = AccountManager.get()?.wallet?.id val filteredAccounts = if (userId != null) { AccountVisibilityManager.filterVisibleAccounts( userId, @@ -156,12 +170,38 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { _accounts.value = filteredAccounts loadEvmStatus() + + val flowWalletCount = walletNodes.filterIsInstance() + .count { it.chainIdString == currentNetwork } + val cryptoProvider = CryptoProviderManager.getCurrentCryptoProvider() + _canAddAccount.value = AppConfig.canCreateNewAccount() + && flowWalletCount < 5 + && cryptoProvider != null + && cryptoProvider !is AndroidKeystoreCryptoProvider + if (refreshBalance) { fetchAllBalances(addressList, pendingEvmAddresses) } } } + fun addAccount() { + ioScope { + _isAddingAccount.value = true + try { + val result = addNewFlowAccount() + if (result == null) { + _isAddingAccount.value = false + toast(msgRes = R.string.common_error_hint) + } else { + refreshWalletList(false) + } + } finally { + _isAddingAccount.value = false + } + } + } + private fun fetchAllBalances(addressList: List, pendingEvmAddresses: List> = emptyList()) { ioScope { val balanceMap = cadenceGetAllFlowBalance(addressList) ?: return@ioScope diff --git a/app/src/main/java/com/flowfoundation/wallet/page/main/presenter/DrawerLayoutContent.kt b/app/src/main/java/com/flowfoundation/wallet/page/main/presenter/DrawerLayoutContent.kt index 5db7f729..8c1a7078 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/main/presenter/DrawerLayoutContent.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/main/presenter/DrawerLayoutContent.kt @@ -21,6 +21,8 @@ import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.foundation.text.InlineTextContent import androidx.compose.foundation.text.appendInlineContent import androidx.compose.foundation.verticalScroll +import androidx.compose.material3.CircularProgressIndicator +import androidx.compose.ui.draw.rotate import androidx.compose.material3.HorizontalDivider import androidx.compose.material3.Icon import androidx.compose.material3.IconButton @@ -115,6 +117,8 @@ fun DrawerLayoutCompose(drawer: DrawerLayout) { val showEvmLayout by viewModel.showEvmLayout.collectAsStateWithLifecycle() val accounts by viewModel.accounts.collectAsStateWithLifecycle() val balanceMap by viewModel.balanceMap.collectAsStateWithLifecycle() + val isAddingAccount by viewModel.isAddingAccount.collectAsStateWithLifecycle() + val canAddAccount by viewModel.canAddAccount.collectAsStateWithLifecycle() LaunchedEffect(Unit) { viewModel.loadData() @@ -169,6 +173,7 @@ fun DrawerLayoutCompose(drawer: DrawerLayout) { AccountListSection( accounts = accounts, balanceMap = balanceMap, + isAddingAccount = isAddingAccount, onCopyClick = onCopyClick@{ address -> if (EVMWalletManager.isEVMWalletAddress(address)) { CopyCOAAddressDialog(context, address).show() @@ -208,13 +213,8 @@ fun DrawerLayoutCompose(drawer: DrawerLayout) { onImportWalletClick = { WalletRestoreActivity.launch(activity) }, - onAddProfileClick = { - if (isTestnet()) { - SwitchNetworkDialog(context, DialogType.CREATE).show() - } else { - ReactNativeActivity.launchWithRoute(context, RNBridge.ScreenType.ONBOARDING, RNBridge.InitialRoute.PROFILE_TYPE_SELECTION) - } - } + onAddAccountClick = { viewModel.addAccount() }, + canAddAccount = canAddAccount ) } } @@ -695,6 +695,7 @@ fun AccountListSection( balanceMap: Map, onCopyClick: (String) -> Unit, onAccountClick: (String) -> Unit, + isAddingAccount: Boolean = false, modifier: Modifier = Modifier ) { val scrollState = rememberScrollState() @@ -728,6 +729,10 @@ fun AccountListSection( fontSize = 14.sp, ) + if (isAddingAccount) { + LoadingWalletAccountRow() + } + if (accounts.isEmpty()) { repeat(2) { ShimmerWalletAccountRow() @@ -756,37 +761,120 @@ fun AccountListSection( @Composable fun BottomSection( onImportWalletClick: () -> Unit, - onAddProfileClick: () -> Unit + onAddAccountClick: () -> Unit = {}, + canAddAccount: Boolean = false ) { + Column { + if (canAddAccount) { + Row( + modifier = Modifier + .fillMaxWidth() + .padding(top = 16.dp) + .clickable(onClick = onAddAccountClick), + verticalAlignment = Alignment.CenterVertically + ) { + Box( + modifier = Modifier + .size(40.dp) + .background( + color = colorResource(id = R.color.bg_card), + shape = CircleShape + ), + contentAlignment = Alignment.Center + ) { + Icon( + painter = painterResource(id = R.drawable.ic_baseline_add_24), + contentDescription = "Add Account", + tint = colorResource(id = R.color.text_1) + ) + } + Spacer(modifier = Modifier.width(16.dp)) + Text( + text = stringResource(id = R.string.add_account), + color = colorResource(id = R.color.text_2), + fontSize = 16.sp, + fontWeight = FontWeight.SemiBold + ) + } + } + Row( + modifier = Modifier + .fillMaxWidth() + .padding(top = 16.dp) + .clickable(onClick = onImportWalletClick), + verticalAlignment = Alignment.CenterVertically + ) { + Box( + modifier = Modifier + .size(40.dp) + .background( + color = colorResource(id = R.color.bg_card), + shape = CircleShape + ), + contentAlignment = Alignment.Center + ) { + Icon( + painter = painterResource(id = R.drawable.ic_import_wallet), + contentDescription = "Recover Profile", + tint = colorResource(id = R.color.text_1) + ) + } + Spacer(modifier = Modifier.width(16.dp)) + Text( + text = stringResource(id = R.string.recover_profile), + color = colorResource(id = R.color.text_2), + fontSize = 16.sp, + fontWeight = FontWeight.SemiBold + ) + } + + } +} + +@Composable +private fun LoadingWalletAccountRow() { + val infiniteTransition = rememberInfiniteTransition(label = "loading") + val rotation by infiniteTransition.animateFloat( + initialValue = 0f, + targetValue = 360f, + animationSpec = infiniteRepeatable( + animation = tween(durationMillis = 2400, easing = LinearEasing), + repeatMode = RepeatMode.Restart + ), + label = "loading_rotation" + ) Row( + verticalAlignment = Alignment.CenterVertically, modifier = Modifier .fillMaxWidth() - .padding(top = 16.dp), - verticalAlignment = Alignment.CenterVertically + .padding(vertical = 12.dp) ) { - Box(modifier = Modifier - .size(40.dp) - .background( - color = colorResource(id = R.color.bg_card), - shape = CircleShape - ) - .clickable(onClick = onAddProfileClick), + Box( + modifier = Modifier.size(45.dp), contentAlignment = Alignment.Center ) { + CircularProgressIndicator( + progress = { 0.25f }, + modifier = Modifier.size(45.dp).rotate(rotation), + color = colorResource(id = R.color.accent_green), + trackColor = colorResource(id = R.color.accent_green_8), + strokeWidth = 7.dp + ) Icon( - painter = painterResource(id = R.drawable.ic_baseline_add_24), - contentDescription = "Add Account", - tint = colorResource(id = R.color.text_1) + painter = painterResource(id = R.drawable.ic_coin_flow), + contentDescription = null, + modifier = Modifier.size(30.dp), + tint = Color.Unspecified ) } - Spacer(modifier = Modifier.width(16.dp)) - Text( - text = stringResource(id = R.string.recover_profile), - color = colorResource(id = R.color.text_2), - fontSize = 16.sp, - fontWeight = FontWeight.SemiBold, - modifier = Modifier.clickable(onClick = onImportWalletClick) - ) + Spacer(modifier = Modifier.width(9.dp)) + Column { + ShimmerBox(modifier = Modifier.width(60.dp).height(14.dp)) + Spacer(modifier = Modifier.height(2.dp)) + ShimmerBox(modifier = Modifier.width(100.dp).height(12.dp)) + Spacer(modifier = Modifier.height(2.dp)) + ShimmerBox(modifier = Modifier.width(80.dp).height(12.dp)) + } } } @@ -825,11 +913,11 @@ private fun ShimmerWalletAccountRow() { ) Spacer(modifier = Modifier.width(9.dp)) Column { - ShimmerBox(modifier = Modifier.width(100.dp).height(14.dp)) + ShimmerBox(modifier = Modifier.width(60.dp).height(14.dp)) Spacer(modifier = Modifier.height(2.dp)) - ShimmerBox(modifier = Modifier.width(70.dp).height(12.dp)) + ShimmerBox(modifier = Modifier.width(100.dp).height(12.dp)) Spacer(modifier = Modifier.height(2.dp)) - ShimmerBox(modifier = Modifier.width(50.dp).height(12.dp)) + ShimmerBox(modifier = Modifier.width(80.dp).height(12.dp)) } } } diff --git a/app/src/main/java/com/flowfoundation/wallet/page/walletrestore/Utils.kt b/app/src/main/java/com/flowfoundation/wallet/page/walletrestore/Utils.kt index ba6362be..ce22ca6a 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/walletrestore/Utils.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/walletrestore/Utils.kt @@ -3,10 +3,9 @@ package com.flowfoundation.wallet.page.walletrestore import androidx.annotation.WorkerThread import com.google.firebase.auth.ktx.auth import com.google.firebase.ktx.Firebase -import com.flowfoundation.wallet.firebase.auth.deleteAnonymousUser import com.flowfoundation.wallet.firebase.auth.firebaseCustomLogin import com.flowfoundation.wallet.firebase.auth.getFirebaseJwt -import com.flowfoundation.wallet.firebase.auth.isAnonymousSignIn +import com.flowfoundation.wallet.firebase.auth.setToAnonymous import com.flowfoundation.wallet.manager.account.Account import com.flowfoundation.wallet.manager.account.AccountManager import com.flowfoundation.wallet.manager.account.DeviceInfoManager @@ -135,6 +134,14 @@ fun requestWalletRestoreLogin( logd(TAG, "HDWalletCryptoProvider created successfully with public key: ${publicKey.take(20)}...") + // Ensure we are in anonymous state before fetching the UID, mirroring iOS behaviour. + // signInWithCustomToken will atomically replace the anonymous user later. + if (!setToAnonymous()) { + loge(TAG, "setToAnonymous failed before wallet restore login") + callback.invoke(false, ERROR_UID) + return@ioScope + } + getFirebaseUid { uid -> if (uid.isNullOrBlank()) { callback.invoke(false, ERROR_UID) @@ -145,16 +152,17 @@ fun requestWalletRestoreLogin( val deviceInfoRequest = DeviceInfoManager.getDeviceInfoRequest() val service = retrofit().create(ApiService::class.java) - // Test signature creation before making the request - val testSignature = try { - val jwt = getFirebaseJwt() + // Fetch JWT once; reuse for both Flow and EVM signatures. + val jwt = getFirebaseJwt() + + val flowSignature = try { cryptoProvider.getUserSignature(jwt) } catch (e: Exception) { loge(TAG, "Failed to create test signature: ${e.message}") throw RuntimeException("Crypto provider signature creation failed: ${e.message}") } - if (testSignature.isBlank()) { + if (flowSignature.isBlank()) { throw RuntimeException("Crypto provider returned empty signature") } @@ -165,9 +173,10 @@ fun requestWalletRestoreLogin( hashAlgo = cryptoProvider.getHashAlgorithm().cadenceIndex, signAlgo = cryptoProvider.getSignatureAlgorithm().cadenceIndex ) + val evmAccountInfo = cryptoProvider.getEvmAccountInfo(jwt) val loginRequest = LoginV4Request( - flowAccountInfo = FlowAccountInfo(accountKey = accountKey, signature = testSignature), - evmAccountInfo = null, // Wallet restore doesn't have mnemonic for EVM + flowAccountInfo = FlowAccountInfo(accountKey = accountKey, signature = flowSignature), + evmAccountInfo = evmAccountInfo, deviceInfo = deviceInfoRequest ) val resp = service.loginV4(loginRequest) @@ -225,40 +234,21 @@ fun requestWalletRestoreLogin( suspend fun firebaseLogin(customToken: String, callback: (isSuccess: Boolean) -> Unit) { logd(TAG, "=== firebaseLogin START ===") logd(TAG, "Custom token received, length: ${customToken.length}") - - val isAnonymous = isAnonymousSignIn() - logd(TAG, "Current Firebase auth state - isAnonymous: $isAnonymous") logd(TAG, "Current user UID: ${Firebase.auth.currentUser?.uid}") - val isSuccess = if (isAnonymous) { - logd(TAG, "Attempting to delete anonymous user") - val deleteResult = deleteAnonymousUser() - logd(TAG, "Delete anonymous user result: $deleteResult") - deleteResult - } else { - logd(TAG, "Signing out existing Firebase user") - Firebase.auth.signOut() - logd(TAG, "Firebase sign out completed") - true - } - - if (isSuccess) { - logd(TAG, "Starting Firebase custom login with token") - firebaseCustomLogin(customToken) { isSuccessful, errorMsg -> - logd(TAG, "Firebase custom login completed - success: $isSuccessful, error: $errorMsg") - if (isSuccessful) { - logd(TAG, "Firebase login successful, identifying user profile with Mixpanel") - MixpanelManager.identifyUserProfile() - logd(TAG, "Calling success callback") - callback(true) - } else { - logd(TAG, "ERROR: Firebase custom login failed - $errorMsg") - callback(false) - } + // signInWithCustomToken atomically replaces the current user (anonymous or otherwise) + // without going through a null state. Prior delete/signOut calls created a null window + // that raced with background getFirebaseJwt() → signInAnonymously() calls. + firebaseCustomLogin(customToken) { isSuccessful, errorMsg -> + logd(TAG, "Firebase custom login completed - success: $isSuccessful, error: $errorMsg") + if (isSuccessful) { + logd(TAG, "Firebase login successful, new UID: ${Firebase.auth.currentUser?.uid}") + MixpanelManager.identifyUserProfile() + callback(true) + } else { + logd(TAG, "ERROR: Firebase custom login failed - $errorMsg") + callback(false) } - } else { - logd(TAG, "ERROR: Auth cleanup failed, calling failure callback") - callback(false) } } From 53f3a323385d025257d930750b32e072306d9191 Mon Sep 17 00:00:00 2001 From: Meng Date: Wed, 11 Mar 2026 12:11:39 +0800 Subject: [PATCH 11/27] fix: add new account with 0 balance --- .../manager/emoji/AccountEmojiManager.kt | 26 +++++++++++++++++++ .../manager/walletdata/WalletDataManager.kt | 6 ++++- .../page/account/AccountListViewModel.kt | 19 +++++++------- .../dialog/profile/ProfileSwitchViewModel.kt | 13 +++------- .../page/main/drawer/DrawerLayoutViewModel.kt | 19 +++++++------- 5 files changed, 53 insertions(+), 30 deletions(-) diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/emoji/AccountEmojiManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/emoji/AccountEmojiManager.kt index aa919a5f..4e653595 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/emoji/AccountEmojiManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/emoji/AccountEmojiManager.kt @@ -38,6 +38,7 @@ object AccountEmojiManager { ) } + @Synchronized fun getEmojiByAddress(address: String?): WalletEmojiInfo { val currentUserName = AccountManager.userInfo()?.username val randomEmoji = getRandomEmoji(currentUserName, address) @@ -123,6 +124,31 @@ object AccountEmojiManager { } } + /** + * Get or assign an emoji for [address] within a specific account's own emoji list. + * Used for non-current accounts to avoid polluting the current account's emoji state. + * + * [emojiList] is mutated in-place when a new address is encountered and the result + * is persisted to the correct account via [AccountManager.updateWalletEmojiInfo]. + */ + @Synchronized + fun getEmojiByAddressForAccount( + address: String, + username: String, + emojiList: MutableList + ): WalletEmojiInfo { + val existing = emojiList.firstOrNull { it.address == address } + if (existing != null) return existing + + val usedIds = emojiList.map { it.emojiId } + val available = getEmojiList().filter { it.id !in usedIds } + val emoji = if (available.isEmpty()) Emoji.PENGUIN else available.random() + val info = WalletEmojiInfo(address, emoji.id, emoji.defaultName) + emojiList.add(info) + AccountManager.updateWalletEmojiInfo(username, emojiList.toMutableList()) + return info + } + fun clear() { accountEmojiList.clear() listeners.clear() diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/walletdata/WalletDataManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/walletdata/WalletDataManager.kt index 5242527e..014b6423 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/walletdata/WalletDataManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/walletdata/WalletDataManager.kt @@ -375,7 +375,11 @@ object WalletDataManager { // Build Wallet Nodes val nodes = mutableListOf() - fun getEmojiInfo(address: String) = AccountEmojiManager.getEmojiByAddress(address) + val accountUsername = account.userInfo.username + val accountEmojiList = (account.walletEmojiList ?: emptyList()).toMutableList() + fun getEmojiInfo(address: String) = AccountEmojiManager.getEmojiByAddressForAccount( + address, accountUsername, accountEmojiList + ) // EOA - WalletCreationHelper.createWalletFromAccount() sets isEoaDisabled // based on key type (Secure Enclave = disabled, others = enabled) diff --git a/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt b/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt index 54a5a243..0755c3a7 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt @@ -73,13 +73,12 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { walletNodes.forEach { mainNode -> when (mainNode) { is EOAWallet -> { - val emojiInfo = AccountEmojiManager.getEmojiByAddress(mainNode.address) addressList.add(mainNode.address) accounts.add( WalletAccountData( address = mainNode.address, - name = emojiInfo.emojiName, - emojiId = emojiInfo.emojiId, + name = mainNode.name, + emojiId = mainNode.emojiId, isSelected = WalletManager.selectedWalletAddress().equals(mainNode.address, ignoreCase = true), isEOAAccount = true ) @@ -87,7 +86,6 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { } is FlowWallet -> { if (mainNode.chainIdString == currentNetwork) { - val emojiInfo = AccountEmojiManager.getEmojiByAddress(mainNode.address) val linkedAccounts = mutableListOf() mainNode.linkedWallets.forEach { linkedWallet -> @@ -99,7 +97,7 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { address = linkedWallet.address, name = linkedWallet.name, icon = linkedWallet.icon, - emojiId = AccountEmojiManager.getEmojiByAddress(linkedWallet.address).emojiId, + emojiId = linkedWallet.emojiId, isSelected = WalletManager.selectedWalletAddress().equals(linkedWallet.address, ignoreCase = true), isCOAAccount = false ) @@ -112,13 +110,12 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { if (evmAddress !in verifiedEvmAddresses) { pendingEvmAddresses.add(Pair(evmAddress, mainNode.address)) } else { - val linkedEmojiInfo = AccountEmojiManager.getEmojiByAddress(evmAddress) linkedAccounts.add( LinkedAccountData( address = evmAddress, - name = linkedEmojiInfo.emojiName, + name = linkedWallet.name, icon = null, - emojiId = linkedEmojiInfo.emojiId, + emojiId = linkedWallet.emojiId, isSelected = WalletManager.selectedWalletAddress().equals(evmAddress, ignoreCase = true), isCOAAccount = true ) @@ -131,8 +128,8 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { accounts.add( WalletAccountData( address = mainNode.address, - name = emojiInfo.emojiName, - emojiId = emojiInfo.emojiId, + name = mainNode.name, + emojiId = mainNode.emojiId, isSelected = WalletManager.selectedWalletAddress().equals(mainNode.address, ignoreCase = true), linkedAccounts = linkedAccounts, isEOAAccount = false @@ -180,6 +177,8 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { _isAddingAccount.value = false toast(msgRes = R.string.common_error_hint) } else { + // New accounts always have 0 balance; inject immediately for instant UI feedback + _balanceMap.value = _balanceMap.value + (result to "0 FLOW") refreshWalletList(false) } } finally { diff --git a/app/src/main/java/com/flowfoundation/wallet/page/dialog/profile/ProfileSwitchViewModel.kt b/app/src/main/java/com/flowfoundation/wallet/page/dialog/profile/ProfileSwitchViewModel.kt index f1688a32..0cfcd51d 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/dialog/profile/ProfileSwitchViewModel.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/dialog/profile/ProfileSwitchViewModel.kt @@ -5,7 +5,6 @@ import com.flowfoundation.wallet.manager.account.Account import com.flowfoundation.wallet.manager.account.AccountManager import com.flowfoundation.wallet.manager.account.model.LocalSwitchAccount import com.flowfoundation.wallet.manager.app.chainNetWorkString -import com.flowfoundation.wallet.manager.emoji.AccountEmojiManager import com.flowfoundation.wallet.manager.flowjvm.cadenceGetAllFlowBalance import com.flowfoundation.wallet.network.ApiService import com.flowfoundation.wallet.network.retrofitApi @@ -102,8 +101,7 @@ class ProfileSwitchViewModel : ViewModel() { flowWallets.forEach { flowWallet -> // Main account - val emojiInfo = AccountEmojiManager.getEmojiByAddress(flowWallet.address) - avatars.add(AvatarData.Emoji(emojiInfo.emojiId)) + avatars.add(AvatarData.Emoji(flowWallet.emojiId)) flowWallet.linkedWallets.forEach { linked -> when (linked) { @@ -111,8 +109,7 @@ class ProfileSwitchViewModel : ViewModel() { if (linked.icon.isNotEmpty()) { avatars.add(AvatarData.Icon(linked.icon)) } else { - val childEmojiInfo = AccountEmojiManager.getEmojiByAddress(linked.address) - avatars.add(AvatarData.Emoji(childEmojiInfo.emojiId)) + avatars.add(AvatarData.Emoji(linked.emojiId)) } } is COAWallet -> { @@ -128,8 +125,7 @@ class ProfileSwitchViewModel : ViewModel() { // Add EOA address avatar profile.walletNodes.filterIsInstance().forEach { eoa -> - val emojiInfo = AccountEmojiManager.getEmojiByAddress(eoa.address) - avatars.add(AvatarData.Emoji(emojiInfo.emojiId)) + avatars.add(AvatarData.Emoji(eoa.emojiId)) } return ProfileItemData(profile, avatars, emptyMap()) @@ -196,8 +192,7 @@ class ProfileSwitchViewModel : ViewModel() { if (shouldShowCoa) { // Add if not present if (!verifiedCoaAvatars.containsKey(coaAddress)) { - val emojiInfo = AccountEmojiManager.getEmojiByAddress(coaAddress) - val avatarData = AvatarData.Emoji(emojiInfo.emojiId) + val avatarData = AvatarData.Emoji(coaWallet.emojiId) verifiedCoaAvatars[coaAddress] = avatarData currentAvatars.add(avatarData) } diff --git a/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt b/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt index 465d237e..3e87f919 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt @@ -85,13 +85,12 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { walletNodes.forEach { mainNode -> when (mainNode) { is EOAWallet -> { - val emojiInfo = AccountEmojiManager.getEmojiByAddress(mainNode.address) addressList.add(mainNode.address) accounts.add( WalletAccountData( address = mainNode.address, - name = emojiInfo.emojiName, - emojiId = emojiInfo.emojiId, + name = mainNode.name, + emojiId = mainNode.emojiId, isSelected = WalletManager.selectedWalletAddress().equals(mainNode.address, ignoreCase = true), isEOAAccount = true ) @@ -99,7 +98,6 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { } is FlowWallet -> { if (mainNode.chainIdString == currentNetwork) { - val emojiInfo = AccountEmojiManager.getEmojiByAddress(mainNode.address) val linkedAccounts = mutableListOf() mainNode.linkedWallets.forEach { linkedWallet -> @@ -111,7 +109,7 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { address = linkedWallet.address, name = linkedWallet.name, icon = linkedWallet.icon, - emojiId = AccountEmojiManager.getEmojiByAddress(linkedWallet.address).emojiId, + emojiId = linkedWallet.emojiId, isSelected = WalletManager.selectedWalletAddress().equals(linkedWallet.address, ignoreCase = true), isCOAAccount = false ) @@ -123,13 +121,12 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { if (evmAddress !in verifiedEvmAddresses) { pendingEvmAddresses.add(Pair(evmAddress, mainNode.address)) } else { - val linkedEmojiInfo = AccountEmojiManager.getEmojiByAddress(evmAddress) linkedAccounts.add( LinkedAccountData( address = evmAddress, - name = linkedEmojiInfo.emojiName, + name = linkedWallet.name, icon = null, - emojiId = linkedEmojiInfo.emojiId, + emojiId = linkedWallet.emojiId, isSelected = WalletManager.selectedWalletAddress().equals(evmAddress, ignoreCase = true), isCOAAccount = true ) @@ -142,8 +139,8 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { accounts.add( WalletAccountData( address = mainNode.address, - name = emojiInfo.emojiName, - emojiId = emojiInfo.emojiId, + name = mainNode.name, + emojiId = mainNode.emojiId, isSelected = WalletManager.selectedWalletAddress().equals(mainNode.address, ignoreCase = true), linkedAccounts = linkedAccounts ) @@ -194,6 +191,8 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { _isAddingAccount.value = false toast(msgRes = R.string.common_error_hint) } else { + // New accounts always have 0 balance; inject immediately for instant UI feedback + _balanceMap.value = _balanceMap.value + (result to "0 FLOW") refreshWalletList(false) } } finally { From 2514979def30c27de2b266c025232d9a9f89a9f1 Mon Sep 17 00:00:00 2001 From: Meng Date: Wed, 11 Mar 2026 23:25:47 +0800 Subject: [PATCH 12/27] fix: create wallet with eoa status --- .../wallet/manager/LaunchManager.kt | 2 +- .../manager/wallet/WalletCreationHelper.kt | 83 +++++++++---------- .../wallet/manager/wallet/WalletManager.kt | 11 +-- .../manager/walletdata/WalletDataManager.kt | 34 +++++--- .../page/profile/compose/SettingComponents.kt | 2 +- 5 files changed, 66 insertions(+), 66 deletions(-) diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/LaunchManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/LaunchManager.kt index 27d6975a..22b2c358 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/LaunchManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/LaunchManager.kt @@ -41,6 +41,7 @@ object LaunchManager { application.startServiceSafe(Intent(application, MessagingService::class.java)) PageLifecycleObserver.init(application) safeRun { System.loadLibrary("TrustWalletCore") } + safeRun { instabugInitialize(application) } refreshChainNetwork { safeRun { MixpanelManager.init(application) } safeRun { WalletConnect.init(application) } @@ -48,7 +49,6 @@ object LaunchManager { safeRun { FlowCadenceApi.refreshConfig() } safeRun { asyncInit() } safeRun { firebaseInitialize(application) } - safeRun { instabugInitialize(application) } safeRun { crowdinInitialize(application) } safeRun { setNightMode() } safeRun { runWorker() } diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletCreationHelper.kt b/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletCreationHelper.kt index babb9f93..fe858645 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletCreationHelper.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletCreationHelper.kt @@ -26,6 +26,11 @@ import org.onflow.flow.ChainId import org.onflow.flow.models.SigningAlgorithm import org.onflow.flow.models.hexToBytes +data class WalletCreationResult( + val wallet: Wallet, + val canDeriveEoa: Boolean +) + /** * Helper class for creating Wallet objects from Account information * Provides reusable wallet creation logic for WalletManager and WalletDataManager @@ -42,8 +47,7 @@ object WalletCreationHelper { * 2. Prefix-based (legacy/hardware): Has prefix for hardware-backed or legacy keys * 3. Mnemonic-based: Fallback to HD wallet mnemonic via AccountWalletManager */ - suspend fun createWalletFromAccount(account: Account, isCurrentAccount: Boolean = true): - Wallet? { + suspend fun createWalletFromAccount(account: Account, isCurrentAccount: Boolean = true): WalletCreationResult? { return try { logd(TAG, "Creating wallet from account: ${account.userInfo.username}") val userId = account.wallet?.id @@ -54,26 +58,26 @@ object WalletCreationHelper { val seedPhraseKey = KeyStorageManager.getSeedPhraseKey(userId) if (seedPhraseKey != null) { logd(TAG, "New storage: seed phrase key found for uid: $userId") - return createWalletFromSeedPhraseKey(seedPhraseKey, isCurrentAccount) + return createWalletFromSeedPhraseKey(seedPhraseKey) } // PrivateKey object retrieved directly → no intermediate string reconstruction val privateKey = KeyStorageManager.getPrivateKeyObject(userId) if (privateKey != null) { logd(TAG, "New storage: private key object found for uid: $userId") - val wallet = createWalletFromPrivateKey(privateKey, isCurrentAccount) + val result = createWalletFromPrivateKey(privateKey) checkAndNotifyMnemonicRestoreIfNeeded(isCurrentAccount) - return wallet + return result } // Android Keystore prefix → reconstruct provider at app layer val akPrefix = KeyStorageManager.getAndroidKeystorePrefix(userId) if (!akPrefix.isNullOrBlank()) { logd(TAG, "New storage: AK prefix found for uid: $userId") - return createWalletFromPrefix(akPrefix, isCurrentAccount) + return createWalletFromPrefix(akPrefix) } } // Create wallet based on account's key information only - val wallet = when { + val result = when { // Handle keystore-based accounts !account.keyStoreInfo.isNullOrBlank() -> { logd(TAG, "Creating keystore-based wallet for account: ${account.userInfo.username}") @@ -83,23 +87,23 @@ object WalletCreationHelper { // Handle prefix-based accounts (hardware-backed or legacy) !account.prefix.isNullOrBlank() -> { logd(TAG, "Creating prefix-based wallet for account: ${account.userInfo.username}") - createWalletFromPrefix(account.prefix!!, isCurrentAccount) + createWalletFromPrefix(account.prefix!!) } // Handle mnemonic-based accounts (including cleaner architecture RN seed phrase accounts) else -> { logd(TAG, "Creating HD wallet from mnemonic for account: ${account.userInfo.username}") - createWalletFromHDMnemonic(userId ?: "", isCurrentAccount) + createWalletFromHDMnemonic(userId ?: "") } } - if (wallet != null) { + if (result != null) { logd(TAG, "Successfully created wallet for account: ${account.userInfo.username}") } else { logd(TAG, "Failed to create wallet for account: ${account.userInfo.username}") } - wallet + result } catch (e: Exception) { logd(TAG, "Error creating wallet for account ${account.userInfo.username}: ${e.message}") null @@ -109,7 +113,7 @@ object WalletCreationHelper { /** * Create wallet from keystore information */ - private suspend fun createWalletFromKeystore(keyStoreInfo: String, userId: String?, isCurrentAccount: Boolean): Wallet { + private suspend fun createWalletFromKeystore(keyStoreInfo: String, userId: String?, isCurrentAccount: Boolean): WalletCreationResult { val ks = Gson().fromJson(keyStoreInfo, KeystoreAddress::class.java) val storage = getStorage() // Check if we have an encrypted mnemonic (HD Wallet restore) @@ -126,14 +130,12 @@ object WalletCreationHelper { derivationPath = DERIVATION_PATH, storage = storage ) - if (isCurrentAccount) { - WalletManager.setEoaDisabled(false) - } - return WalletFactory.createKeyWallet( + val wallet = WalletFactory.createKeyWallet( seedPhraseKey, setOf(ChainId.Mainnet, ChainId.Testnet), storage ) + return WalletCreationResult(wallet, canDeriveEoa = true) } else { logd(TAG, "Failed to decrypt mnemonic, using private key mode") } @@ -146,7 +148,7 @@ object WalletCreationHelper { } // Fallback to private key mode - return createWalletFromKeystorePrivateKey(ks, storage, isCurrentAccount) + return createWalletFromKeystorePrivateKey(ks, storage) } /** @@ -159,7 +161,7 @@ object WalletCreationHelper { * Note: Mnemonic-only accounts (cleaner architecture) are handled separately by createWalletFromHDMnemonic * and should not reach this function. */ - private fun createWalletFromPrefix(prefix: String, isCurrentAccount: Boolean): Wallet? { + private fun createWalletFromPrefix(prefix: String): WalletCreationResult? { val storage = getStorage() return try { @@ -167,14 +169,12 @@ object WalletCreationHelper { if (privateKey != null) { // Prefix-based key - cannot derive EOA (no mnemonic) logd(TAG, "Prefix-based key found for prefix: $prefix - EOA disabled") - if (isCurrentAccount) { - WalletManager.setEoaDisabled(true) - } - WalletFactory.createKeyWallet( + val wallet = WalletFactory.createKeyWallet( privateKey, setOf(ChainId.Mainnet, ChainId.Testnet), storage ) + WalletCreationResult(wallet, canDeriveEoa = false) } else { logd(TAG, "Private key not found for prefix: $prefix") null @@ -182,16 +182,14 @@ object WalletCreationHelper { } catch (e: HardwareBackedKeyException) { // Secure Enclave (hardware-backed) key - cannot derive EOA logd(TAG, "Hardware-backed key detected for prefix: $prefix - EOA disabled") - if (isCurrentAccount) { - WalletManager.setEoaDisabled(true) - } if (e.prefix != null) { val provider = AndroidKeystoreCryptoProvider(e.prefix) - WalletFactory.createProxyWallet( + val wallet = WalletFactory.createProxyWallet( provider, setOf(ChainId.Mainnet, ChainId.Testnet), storage ) + WalletCreationResult(wallet, canDeriveEoa = false) } else { logd(TAG, "Hardware-backed key prefix is null") null @@ -203,7 +201,7 @@ object WalletCreationHelper { * Create wallet from HD wallet mnemonic * HD wallets can derive EOA addresses. */ - private fun createWalletFromHDMnemonic(accountId: String, isCurrentAccount: Boolean): Wallet? { + private fun createWalletFromHDMnemonic(accountId: String): WalletCreationResult? { val storage = getStorage() val mnemonic = AccountWalletManager.getHDWalletMnemonicByUID(accountId) if (mnemonic != null) { @@ -213,16 +211,13 @@ object WalletCreationHelper { derivationPath = DERIVATION_PATH, storage = storage ) - // HD wallet (mnemonic-based) - can derive EOA - if (isCurrentAccount) { - WalletManager.setEoaDisabled(false) - } logd(TAG, "HD wallet from mnemonic - EOA enabled") - return WalletFactory.createKeyWallet( + val wallet = WalletFactory.createKeyWallet( seedPhraseKey, setOf(ChainId.Mainnet, ChainId.Testnet), storage ) + return WalletCreationResult(wallet, canDeriveEoa = true) } else { logd(TAG, "HD wallet key not found for account ID: $accountId") return null @@ -233,20 +228,20 @@ object WalletCreationHelper { * Create wallet from a [SeedPhraseKey] object loaded directly from key storage. * Avoids reconstructing the key from a mnemonic string. */ - private fun createWalletFromSeedPhraseKey(seedPhraseKey: SeedPhraseKey, isCurrentAccount: Boolean): Wallet { + private fun createWalletFromSeedPhraseKey(seedPhraseKey: SeedPhraseKey): WalletCreationResult { val storage = getStorage() - if (isCurrentAccount) WalletManager.setEoaDisabled(false) - return WalletFactory.createKeyWallet(seedPhraseKey, setOf(ChainId.Mainnet, ChainId.Testnet), storage) + val wallet = WalletFactory.createKeyWallet(seedPhraseKey, setOf(ChainId.Mainnet, ChainId.Testnet), storage) + return WalletCreationResult(wallet, canDeriveEoa = true) } /** * Create wallet from a [PrivateKey] object loaded directly from key storage. * Cannot derive EOA addresses (no mnemonic available). */ - private fun createWalletFromPrivateKey(privateKey: PrivateKey, isCurrentAccount: Boolean): Wallet { + private fun createWalletFromPrivateKey(privateKey: PrivateKey): WalletCreationResult { val storage = getStorage() - if (isCurrentAccount) WalletManager.setEoaDisabled(true) - return WalletFactory.createKeyWallet(privateKey, setOf(ChainId.Mainnet, ChainId.Testnet), storage) + val wallet = WalletFactory.createKeyWallet(privateKey, setOf(ChainId.Mainnet, ChainId.Testnet), storage) + return WalletCreationResult(wallet, canDeriveEoa = false) } /** @@ -260,8 +255,7 @@ object WalletCreationHelper { val response = service.checkUserMnemonicStatus() logd(TAG, "Checked user mnemonic status: ${response.data}") if (response.data?.isExist == true) { - logd(TAG, "Mnemonic restore required. Disabling EOA and notifying UI.") - WalletManager.setEoaDisabled(true) + logd(TAG, "Mnemonic restore required. Notifying UI.") LocalBroadcastManager.getInstance(com.flowfoundation.wallet.utils.Env.getApp()) .sendBroadcast(android.content.Intent("ACTION_RESTORE_MNEMONIC")) } @@ -274,7 +268,7 @@ object WalletCreationHelper { * Create wallet from keystore private key * Private key imports cannot derive EOA addresses (no mnemonic available). */ - private fun createWalletFromKeystorePrivateKey(ks: KeystoreAddress, storage: StorageProtocol, isCurrentAccount: Boolean): Wallet { + private fun createWalletFromKeystorePrivateKey(ks: KeystoreAddress, storage: StorageProtocol): WalletCreationResult { val keyHex = ks.privateKey.removePrefix("0x") require(keyHex.length == 64) { "Private key must be 32-byte hex" } @@ -282,16 +276,13 @@ object WalletCreationHelper { importPrivateKey(keyHex.hexToBytes(), KeyFormat.RAW) } - // Keystore private key import - cannot derive EOA (no mnemonic available) - if (isCurrentAccount) { - WalletManager.setEoaDisabled(true) - } logd(TAG, "Keystore private key import - EOA disabled") - return WalletFactory.createKeyWallet( + val wallet = WalletFactory.createKeyWallet( key, setOf(ChainId.Mainnet, ChainId.Testnet), storage ) + return WalletCreationResult(wallet, canDeriveEoa = false) } } diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletManager.kt index 903280d8..985980be 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletManager.kt @@ -33,12 +33,11 @@ object WalletManager { private const val ADDRESS_CACHE_DURATION = 100L // Cache duration in milliseconds private val initializationLock = Object() - private var _isEoaDisabled = false + private var _canDeriveEoa = false private var lastRotationCheckTime = 0L private const val ROTATION_CHECK_COOLDOWN = 2000L - fun isEoaDisabled() = _isEoaDisabled - fun setEoaDisabled(disabled: Boolean) { _isEoaDisabled = disabled } + fun canDeriveEoa() = _canDeriveEoa /** * Get EOA address @@ -66,14 +65,15 @@ object WalletManager { } // Use WalletCreationHelper to create wallet from account - val newWallet = runBlocking { + val result = runBlocking { WalletCreationHelper.createWalletFromAccount(account) } ?: run { logd(TAG, "Failed to create wallet from account") return false } - currentWallet = newWallet + currentWallet = result.wallet + _canDeriveEoa = result.canDeriveEoa logd(TAG, "Wallet created successfully: ${getCurrentFlowWalletAddress()}") val address = getCurrentFlowWalletAddress() ?: run { @@ -463,6 +463,7 @@ object WalletManager { selectedWalletAddressRef.set("") currentWallet = null lastAddressCheck = 0 + _canDeriveEoa = false } } } diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/walletdata/WalletDataManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/walletdata/WalletDataManager.kt index 014b6423..cc9babed 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/walletdata/WalletDataManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/walletdata/WalletDataManager.kt @@ -145,17 +145,23 @@ object WalletDataManager { logd(TAG, "Updating current account data: ${currentAccount.userInfo.username}") // Try to reuse the singleton Wallet instance from WalletManager - var wallet = WalletManager.wallet() + val existingWallet = WalletManager.wallet() + val wallet: Wallet? + val canDeriveEoa: Boolean - if (wallet == null) { + if (existingWallet == null) { logd(TAG, "WalletManager.wallet() is null, attempting to create temporary instance") - wallet = WalletCreationHelper.createWalletFromAccount(currentAccount) + val result = WalletCreationHelper.createWalletFromAccount(currentAccount) + wallet = result?.wallet + canDeriveEoa = result?.canDeriveEoa ?: false } else { logd(TAG, "Reusing WalletManager instance: ${WalletManager.getCurrentFlowWalletAddress()}") + wallet = existingWallet + canDeriveEoa = WalletManager.canDeriveEoa() } if (wallet != null) { - updateCurrentAccountData(currentAccount, wallet) + updateCurrentAccountData(currentAccount, wallet, canDeriveEoa) } else { logd(TAG, "Failed to obtain wallet instance for current account") } @@ -232,7 +238,7 @@ object WalletDataManager { /** * Update data for the current account using provided Wallet */ - private suspend fun updateCurrentAccountData(account: Account, wallet: Wallet) { + private suspend fun updateCurrentAccountData(account: Account, wallet: Wallet, canDeriveEoa: Boolean) { try { logd(TAG, "Refreshing wallet accounts for ${account.userInfo.username}...") wallet.refreshAccounts() @@ -263,9 +269,9 @@ object WalletDataManager { logd(TAG, "Fetching data for ${allBlockchainData.size} BlockchainData entries for node construction") fun getEmojiInfo(address: String) = AccountEmojiManager.getEmojiByAddress(address) - // EOA Wallet - WalletCreationHelper.createWalletFromAccount() sets isEoaDisabled - // based on key type (Secure Enclave = disabled, others = enabled) - if (!WalletManager.isEoaDisabled()) { + // EOA Wallet - canDeriveEoa is determined per-wallet by WalletCreationHelper + // based on key type (Secure Enclave / private key = false, seed phrase = true) + if (canDeriveEoa) { val eoa = deriveEoaAddress(wallet) logd(TAG, "Generated EOA address: $eoa") if (eoa.isNotEmpty()) { @@ -366,7 +372,9 @@ object WalletDataManager { return try { logd(TAG, "Updating non-current account: ${account.userInfo.username}") - val wallet = WalletCreationHelper.createWalletFromAccount(account, false) + val result = WalletCreationHelper.createWalletFromAccount(account, false) + val wallet = result?.wallet + val canDeriveEoa = result?.canDeriveEoa ?: false if (wallet != null) { logd(TAG, "Refreshing wallet accounts for non-current account ${account.userInfo.username}...") wallet.refreshAccounts() @@ -381,9 +389,9 @@ object WalletDataManager { address, accountUsername, accountEmojiList ) - // EOA - WalletCreationHelper.createWalletFromAccount() sets isEoaDisabled - // based on key type (Secure Enclave = disabled, others = enabled) - if (!WalletManager.isEoaDisabled()) { + // EOA - canDeriveEoa is determined per-wallet by WalletCreationHelper + // based on key type (Secure Enclave / private key = false, seed phrase = true) + if (canDeriveEoa) { val eoa = deriveEoaAddress(wallet) if (eoa.isNotEmpty()) { logd(TAG, "Adding EOA for non-current account: $eoa") @@ -395,7 +403,7 @@ object WalletDataManager { )) } } else { - logd(TAG, "Skipping EOA for non-current account (isEoaDisabled=${WalletManager.isEoaDisabled()})") + logd(TAG, "Skipping EOA for non-current account (canDeriveEoa=false)") } kotlinx.coroutines.supervisorScope { diff --git a/app/src/main/java/com/flowfoundation/wallet/page/profile/compose/SettingComponents.kt b/app/src/main/java/com/flowfoundation/wallet/page/profile/compose/SettingComponents.kt index 5639718c..ebe74b3e 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/profile/compose/SettingComponents.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/profile/compose/SettingComponents.kt @@ -138,7 +138,7 @@ fun SettingSwitchItem( modifier = Modifier .fillMaxWidth() .clickable { onCheckedChange(!isChecked) } - .padding(horizontal = 16.dp, vertical = 12.dp), + .padding(horizontal = 16.dp, vertical = 8.dp), verticalAlignment = Alignment.CenterVertically ) { // Icon From f766b5a5ff1facc0b6e6160405fc02ec26e3a8b7 Mon Sep 17 00:00:00 2001 From: Meng Date: Thu, 12 Mar 2026 15:20:51 +0800 Subject: [PATCH 13/27] fix: luciq http interceptor --- .../flowfoundation/wallet/network/NetworkConst.kt | 14 +++++++++----- .../wallet/network/functions/Functions.kt | 8 +++++--- gradle.properties | 2 +- 3 files changed, 15 insertions(+), 9 deletions(-) diff --git a/app/src/main/java/com/flowfoundation/wallet/network/NetworkConst.kt b/app/src/main/java/com/flowfoundation/wallet/network/NetworkConst.kt index 1f689fe3..731c59fa 100644 --- a/app/src/main/java/com/flowfoundation/wallet/network/NetworkConst.kt +++ b/app/src/main/java/com/flowfoundation/wallet/network/NetworkConst.kt @@ -6,7 +6,8 @@ import com.flowfoundation.wallet.network.interceptor.HeaderInterceptor import com.flowfoundation.wallet.network.interceptor.PayerServiceInterceptor import com.flowfoundation.wallet.utils.isDev import com.flowfoundation.wallet.utils.isTesting -import ai.luciq.library.okhttplogger.LuciqOkhttpInterceptor +import ai.luciq.library.okhttp.v2.LuciqOkHttpInterceptor +import ai.luciq.library.okhttp.v2.LuciqOkHttpEventListener import okhttp3.OkHttpClient import okhttp3.logging.HttpLoggingInterceptor import retrofit2.Retrofit @@ -24,7 +25,8 @@ fun retrofit( ): Retrofit { val client = OkHttpClient.Builder().apply { addInterceptor(HeaderInterceptor(network = network)) - addInterceptor(LuciqOkhttpInterceptor()) + addInterceptor(LuciqOkHttpInterceptor()) + eventListenerFactory(LuciqOkHttpEventListener.Factory()) callTimeout(20, TimeUnit.SECONDS) connectTimeout(20, TimeUnit.SECONDS) @@ -52,8 +54,9 @@ fun retrofitApi(): Retrofit { fun cadenceScriptApi(): Retrofit { val client = OkHttpClient.Builder().apply { addInterceptor(HeaderInterceptor(false)) - addInterceptor(PayerServiceInterceptor()) // Add payer service interceptor - addInterceptor(LuciqOkhttpInterceptor()) + addInterceptor(PayerServiceInterceptor()) + addInterceptor(LuciqOkHttpInterceptor()) + eventListenerFactory(LuciqOkHttpEventListener.Factory()) addInterceptor(GzipRequestInterceptor()) addInterceptor(GzipResponseInterceptor()) callTimeout(20, TimeUnit.SECONDS) @@ -74,7 +77,8 @@ fun cadenceScriptApi(): Retrofit { fun retrofitWithHost(host: String, disableConverter: Boolean = false, ignoreAuthorization: Boolean = true): Retrofit { val client = OkHttpClient.Builder().apply { addInterceptor(HeaderInterceptor(ignoreAuthorization)) - addInterceptor(LuciqOkhttpInterceptor()) + addInterceptor(LuciqOkHttpInterceptor()) + eventListenerFactory(LuciqOkHttpEventListener.Factory()) callTimeout(20, TimeUnit.SECONDS) connectTimeout(20, TimeUnit.SECONDS) readTimeout(20, TimeUnit.SECONDS) diff --git a/app/src/main/java/com/flowfoundation/wallet/network/functions/Functions.kt b/app/src/main/java/com/flowfoundation/wallet/network/functions/Functions.kt index b2c94d4d..1970d43f 100644 --- a/app/src/main/java/com/flowfoundation/wallet/network/functions/Functions.kt +++ b/app/src/main/java/com/flowfoundation/wallet/network/functions/Functions.kt @@ -5,7 +5,8 @@ import com.flowfoundation.wallet.firebase.analytics.reportEvent import com.flowfoundation.wallet.network.interceptor.HeaderInterceptor import com.flowfoundation.wallet.network.interceptor.PayerServiceInterceptor import com.flowfoundation.wallet.utils.* -import ai.luciq.library.okhttplogger.LuciqOkhttpInterceptor +import ai.luciq.library.okhttp.v2.LuciqOkHttpInterceptor +import ai.luciq.library.okhttp.v2.LuciqOkHttpEventListener import kotlinx.coroutines.suspendCancellableCoroutine import okhttp3.MediaType.Companion.toMediaType import okhttp3.OkHttpClient @@ -44,8 +45,9 @@ private suspend fun executeHttp(host: String, functionName: String, data: Any? = writeTimeout(10, TimeUnit.SECONDS) addInterceptor(HeaderInterceptor()) - addInterceptor(PayerServiceInterceptor()) // Add payer service interceptor - addInterceptor(LuciqOkhttpInterceptor()) + addInterceptor(PayerServiceInterceptor()) + addInterceptor(LuciqOkHttpInterceptor()) + eventListenerFactory(LuciqOkHttpEventListener.Factory()) if (isTesting()) { addInterceptor(HttpLoggingInterceptor().apply { level = HttpLoggingInterceptor.Level.BODY }) } diff --git a/gradle.properties b/gradle.properties index 1644431c..c7b15042 100644 --- a/gradle.properties +++ b/gradle.properties @@ -64,7 +64,7 @@ android.r8.dexing.parallel=true #android.bundle.enableUncompressedNativeLibs=false #android.experimental.enableArtProfiles=true -vCode=400000463 +vCode=400000465 vName=r3.1.0 # --- GitHub Packages (Flow Wallet Kit) --- From 4be161159fd7f9ac92b0cbe4b8c92f1c3771d4cb Mon Sep 17 00:00:00 2001 From: Meng Date: Mon, 16 Mar 2026 14:00:51 +0800 Subject: [PATCH 14/27] feat: inbox entrance --- .../manager/cadence/CadenceApiManager.kt | 35 ++++--- .../wallet/manager/cadence/CadenceApiModel.kt | 5 +- .../wallet/manager/flowjvm/CadenceExecutor.kt | 13 ++- .../wallet/manager/flowjvm/CadenceScript.kt | 11 ++- .../wallet/manager/inbox/InboxManager.kt | 99 +++++++++++++++++++ .../page/account/AccountListViewModel.kt | 2 +- .../wallet/page/main/MainActivity.kt | 2 + .../page/main/drawer/DrawerLayoutViewModel.kt | 2 +- .../nftlist/presenter/NFTFragmentPresenter.kt | 28 +++++- .../notification/model/WalletNotification.kt | 5 +- .../presenter/NotificationItemPresenter.kt | 16 ++- .../wallet/presenter/WalletHeaderPresenter.kt | 26 ++++- .../wallet/reactnative/ReactNativeActivity.kt | 6 ++ .../wallet/reactnative/bridge/BridgeModels.kt | 4 +- .../reactnative/bridge/NativeFRWBridge.kt | 17 ++-- app/src/main/res/drawable/bg_inbox_badge.xml | 5 + app/src/main/res/drawable/ic_inbox.xml | 14 +++ app/src/main/res/layout/fragment_nft.xml | 36 ++++++- .../layout_wallet_coordinator_header.xml | 37 ++++++- 19 files changed, 329 insertions(+), 34 deletions(-) create mode 100644 app/src/main/java/com/flowfoundation/wallet/manager/inbox/InboxManager.kt create mode 100644 app/src/main/res/drawable/bg_inbox_badge.xml create mode 100644 app/src/main/res/drawable/ic_inbox.xml diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/cadence/CadenceApiManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/cadence/CadenceApiManager.kt index bc0f4196..c25bae31 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/cadence/CadenceApiManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/cadence/CadenceApiManager.kt @@ -81,7 +81,7 @@ object CadenceApiManager { } } ?: "" logd(TAG, "Response body length: ${responseBody.length}") - + val isSignatureValid = try { verifySignature(signature, responseBody.toByteArray()) } catch (e: Exception) { @@ -90,7 +90,7 @@ object CadenceApiManager { ErrorReporter.reportWithMixpanel(CadenceError.SIGNATURE_VERIFICATION_ERROR, e) false } - + if (!isSignatureValid) { loge(TAG, "Invalid script signature - continuing with cached scripts") loge(TAG, "Response preview (first 200 chars): ${responseBody.take(200)}") @@ -138,40 +138,40 @@ object CadenceApiManager { loge(TAG, "Empty signature provided for verification") return false } - + // Clean the signature - remove any whitespace and non-hex characters val cleanSignature = signature.trim().replace(Regex("[^0-9a-fA-F]"), "") - + if (cleanSignature.isBlank()) { loge(TAG, "Signature contains no valid hex characters: ${signature.take(50)}...") return false } - + // Check if signature contains only valid hex characters val hexPattern = "^[0-9a-fA-F]+$".toRegex() if (!hexPattern.matches(cleanSignature)) { loge(TAG, "Invalid signature format after cleaning - contains non-hex characters: ${cleanSignature.take(50)}...") return false } - + // Validate signature length (should be even number for hex) if (cleanSignature.length % 2 != 0) { loge(TAG, "Invalid signature length - not even number of hex chars: ${cleanSignature.length}") return false } - + // Validate expected signature length for ECDSA (typically 64 bytes = 128 hex chars) if (cleanSignature.length != 128) { logd(TAG, "Warning: Unexpected signature length: ${cleanSignature.length} (expected 128)") } - + val hashedData = Hash.sha256(data) val pubKeyBytes = BuildConfig.X_SIGNATURE_KEY.decodeHex().toByteArray() val public = PublicKey(pubKeyBytes, PublicKeyType.NIST256P1EXTENDED) - + val signatureBytes = cleanSignature.decodeHex().toByteArray() val isValid = public.verify(signatureBytes, hashedData) - + logd(TAG, "Signature verification result: $isValid") isValid } catch (e: IllegalArgumentException) { @@ -308,6 +308,16 @@ object CadenceApiManager { return script } + fun getCadenceLostAndFoundScript(method: String): String { + val script = getCadenceScript()?.lostAndFound?.get(method)?.decodeBase64()?.utf8() + if (script.isNullOrBlank()) { + loge(TAG, "Failed to get lostAndFound script for method: $method, falling back to " + + "assets") + return getFallbackScriptFromAssets(method, "lostAndFound") + } + return script + } + private fun getFallbackScriptFromAssets(method: String, category: String): String { return try { val assetsData = Gson().fromJson( @@ -318,7 +328,7 @@ object CadenceApiManager { NETWORK_TESTNET -> assetsData.data?.scripts?.testnet else -> assetsData.data?.scripts?.mainnet } - + val scriptContent = when (category) { "basic" -> script?.basic?.get(method) "collection" -> script?.collection?.get(method) @@ -331,9 +341,10 @@ object CadenceApiManager { "nft" -> script?.nft?.get(method) "swap" -> script?.swap?.get(method) as? String "bridge" -> script?.bridge?.get(method) + "lostAndFound" -> script?.lostAndFound?.get(method) else -> null }?.decodeBase64()?.utf8() - + scriptContent ?: run { loge(TAG, "No fallback script found for method: $method, category: $category") "" diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/cadence/CadenceApiModel.kt b/app/src/main/java/com/flowfoundation/wallet/manager/cadence/CadenceApiModel.kt index 5378d9b8..5156de1c 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/cadence/CadenceApiModel.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/cadence/CadenceApiModel.kt @@ -31,5 +31,6 @@ data class CadenceScript( val evm: Map?, val nft: Map?, val swap: Map?, - val bridge: Map? -) \ No newline at end of file + val bridge: Map?, + val lostAndFound: Map? +) diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/flowjvm/CadenceExecutor.kt b/app/src/main/java/com/flowfoundation/wallet/manager/flowjvm/CadenceExecutor.kt index 624d2c13..681b7f72 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/flowjvm/CadenceExecutor.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/flowjvm/CadenceExecutor.kt @@ -27,6 +27,8 @@ import com.flowfoundation.wallet.utils.reportCadenceErrorToDebugView import com.flowfoundation.wallet.wallet.toAddress import org.onflow.flow.AddressRegistry import org.onflow.flow.infrastructure.Cadence +import org.onflow.flow.infrastructure.Cadence.Companion.address +import org.onflow.flow.infrastructure.Cadence.Companion.array import org.onflow.flow.infrastructure.Cadence.Companion.string import java.math.BigDecimal @@ -58,12 +60,21 @@ suspend fun cadenceQueryAddressByDomainFind(domain: String): String? { suspend fun cadenceGetAllFlowBalance(list: List): Map? { logd(TAG, "cadenceGetAllFlowBalance()") val result = CadenceScript.CADENCE_GET_ALL_FLOW_BALANCE.executeCadence { - arg { Cadence.array(list.map { string(it) }) } + arg { array(list.map { string(it) }) } } logd(TAG, "cadenceGetAllFlowBalance response:${result?.encode()}") return result?.decode>().parseBigDecimalMap() } +suspend fun cadenceQueryInboxUnclaimedNumber(list: List): Int? { + logd(TAG, "cadenceQueryInboxUnclaimedNumber()") + val result = CadenceScript.CADENCE_BATCH_QUERY_UNCLAIMED_NUMBER.executeCadence { + arg { array(list.map { address(it) }) } + } + logd(TAG, "cadenceQueryInboxUnclaimedNumber response:${result?.encode()}") + return result?.decode() +} + suspend fun cadenceQueryTokenBalanceWithAddress(token: FungibleToken?, address: String?): BigDecimal? { if (token == null || address == null) { return null diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/flowjvm/CadenceScript.kt b/app/src/main/java/com/flowfoundation/wallet/manager/flowjvm/CadenceScript.kt index 421a1c4a..9af8d013 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/flowjvm/CadenceScript.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/flowjvm/CadenceScript.kt @@ -107,7 +107,10 @@ enum class CadenceScript(val scriptId: String, val type: CadenceScriptType) { // DOMAIN CADENCE_CLAIM_INBOX_TOKEN("claimFTFromInbox", CadenceScriptType.DOMAIN), - CADENCE_CLAIM_INBOX_NFT("claimNFTFromInbox", CadenceScriptType.DOMAIN); + CADENCE_CLAIM_INBOX_NFT("claimNFTFromInbox", CadenceScriptType.DOMAIN), + + // LOST_AND_FOUND + CADENCE_BATCH_QUERY_UNCLAIMED_NUMBER("batchQueryUnclaimedNumber", CadenceScriptType.LOST_AND_FOUND); fun getScript(): String { return when (type) { @@ -124,6 +127,7 @@ enum class CadenceScript(val scriptId: String, val type: CadenceScriptType) { CadenceScriptType.NFT -> CadenceApiManager.getCadenceNFTScript(scriptId) CadenceScriptType.SWAP -> CadenceApiManager.getCadenceSwapScript(scriptId) CadenceScriptType.BRIDGE -> CadenceApiManager.getCadenceBridgeScript(scriptId) + CadenceScriptType.LOST_AND_FOUND -> CadenceApiManager.getCadenceLostAndFoundScript(scriptId) } } } @@ -141,5 +145,6 @@ enum class CadenceScriptType { EVM, NFT, SWAP, - BRIDGE; -} \ No newline at end of file + BRIDGE, + LOST_AND_FOUND; +} diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/inbox/InboxManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/inbox/InboxManager.kt new file mode 100644 index 00000000..62b478ad --- /dev/null +++ b/app/src/main/java/com/flowfoundation/wallet/manager/inbox/InboxManager.kt @@ -0,0 +1,99 @@ +package com.flowfoundation.wallet.manager.inbox + +import com.flowfoundation.wallet.manager.flowjvm.cadenceQueryInboxUnclaimedNumber +import com.flowfoundation.wallet.manager.notification.WalletNotificationManager +import com.flowfoundation.wallet.manager.wallet.WalletManager +import com.flowfoundation.wallet.page.notification.model.DisplayType +import com.flowfoundation.wallet.page.notification.model.Priority +import com.flowfoundation.wallet.page.notification.model.Type +import com.flowfoundation.wallet.page.notification.model.WalletNotification +import com.flowfoundation.wallet.utils.ioScope +import com.flowfoundation.wallet.utils.logd +import com.flowfoundation.wallet.utils.uiScope +import java.lang.ref.WeakReference +import java.util.concurrent.CopyOnWriteArrayList + +object InboxManager { + + private const val TAG = "InboxManager" + + private val listeners = CopyOnWriteArrayList>() + + @Volatile + var unclaimedCount: Int = 0 + private set + + private var inboxNotification: WalletNotification? = null + + fun refresh() { + ioScope { + if (WalletManager.isChildAccountSelected() || WalletManager.isEVMAccountSelected()) { + updateCount(0) + return@ioScope + } + + val address = WalletManager.selectedWalletAddress() + if (address.isBlank()) { + updateCount(0) + return@ioScope + } + + val count = cadenceQueryInboxUnclaimedNumber(listOf(address)) ?: 0 + logd(TAG, "refresh() unclaimed count: $count for $address") + updateCount(count) + } + } + + fun addListener(callback: OnInboxCountUpdate) { + if (listeners.firstOrNull { it.get() == callback } != null) { + return + } + uiScope { + listeners.add(WeakReference(callback)) + } + } + + fun formatBadgeCount(count: Int): String { + return if (count >= 1000) "${count / 1000}k" else count.toString() + } + + fun clearNotificationRef() { + inboxNotification = null + } + + private fun updateCount(count: Int) { + unclaimedCount = count + manageNotification(count) + dispatchListeners() + } + + private fun manageNotification(count: Int) { + if (count > 0 && inboxNotification == null) { + val notification = WalletNotification( + id = "inbox_${System.currentTimeMillis()}", + icon = "https://raw.githubusercontent.com/Outblock/Assets/main/ft/flow/logo.png", + title = "Assets available to claim", + body = "Go to view.", + priority = Priority.URGENT, + type = Type.INBOX, + displayType = DisplayType.CLICK + ) + inboxNotification = notification + WalletNotificationManager.addNotification(notification) + } else if (count <= 0 && inboxNotification != null) { + inboxNotification?.let { WalletNotificationManager.removeNotification(it) } + inboxNotification = null + } + } + + private fun dispatchListeners() { + uiScope { + listeners.removeAll { it.get() == null } + listeners.forEach { it.get()?.onInboxCountUpdate(unclaimedCount) } + } + } +} + +interface OnInboxCountUpdate { + fun onInboxCountUpdate(count: Int) +} diff --git a/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt b/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt index 0755c3a7..3037217c 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt @@ -178,7 +178,7 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { toast(msgRes = R.string.common_error_hint) } else { // New accounts always have 0 balance; inject immediately for instant UI feedback - _balanceMap.value = _balanceMap.value + (result to "0 FLOW") + _balanceMap.value += (result to "0 FLOW") refreshWalletList(false) } } finally { diff --git a/app/src/main/java/com/flowfoundation/wallet/page/main/MainActivity.kt b/app/src/main/java/com/flowfoundation/wallet/page/main/MainActivity.kt index 1e1ac84c..367af258 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/main/MainActivity.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/main/MainActivity.kt @@ -31,6 +31,7 @@ import com.flowfoundation.wallet.utils.isRegistered import com.flowfoundation.wallet.utils.uiScope import ai.luciq.bug.BugReporting import ai.luciq.library.Luciq +import com.flowfoundation.wallet.manager.inbox.InboxManager import com.flowfoundation.wallet.manager.wallet.WalletManager class MainActivity : BaseActivity() { @@ -132,6 +133,7 @@ class MainActivity : BaseActivity() { RootDetectedDialog.show(supportFragmentManager) super.onResume() checkPendingAction() + InboxManager.refresh() } private fun checkPendingAction() { diff --git a/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt b/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt index 3e87f919..419fb3ba 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt @@ -192,7 +192,7 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { toast(msgRes = R.string.common_error_hint) } else { // New accounts always have 0 balance; inject immediately for instant UI feedback - _balanceMap.value = _balanceMap.value + (result to "0 FLOW") + _balanceMap.value += (result to "0 FLOW") refreshWalletList(false) } } finally { diff --git a/app/src/main/java/com/flowfoundation/wallet/page/nft/nftlist/presenter/NFTFragmentPresenter.kt b/app/src/main/java/com/flowfoundation/wallet/page/nft/nftlist/presenter/NFTFragmentPresenter.kt index 75d3d724..9434220e 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/nft/nftlist/presenter/NFTFragmentPresenter.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/nft/nftlist/presenter/NFTFragmentPresenter.kt @@ -9,7 +9,10 @@ import com.zackratos.ultimatebarx.ultimatebarx.statusBarHeight import com.flowfoundation.wallet.R import com.flowfoundation.wallet.base.presenter.BasePresenter import com.flowfoundation.wallet.databinding.FragmentNftBinding +import com.flowfoundation.wallet.manager.inbox.InboxManager +import com.flowfoundation.wallet.manager.inbox.OnInboxCountUpdate import com.flowfoundation.wallet.manager.wallet.WalletManager +import com.flowfoundation.wallet.reactnative.ReactNativeActivity import com.flowfoundation.wallet.page.nft.collectionlist.NftCollectionListActivity import com.flowfoundation.wallet.page.nft.nftlist.NFTFragment import com.flowfoundation.wallet.page.nft.nftlist.NftViewModel @@ -17,7 +20,9 @@ import com.flowfoundation.wallet.page.nft.nftlist.adapter.NftListPageAdapter import com.flowfoundation.wallet.page.nft.nftlist.model.NFTFragmentModel import com.flowfoundation.wallet.utils.ScreenUtils import com.flowfoundation.wallet.utils.extensions.res2color +import com.flowfoundation.wallet.utils.extensions.gone import com.flowfoundation.wallet.utils.extensions.setVisible +import com.flowfoundation.wallet.utils.extensions.visible import com.flowfoundation.wallet.utils.startShimmer import java.lang.Float.min import android.view.Gravity @@ -26,7 +31,7 @@ import android.view.Gravity class NFTFragmentPresenter( private val fragment: NFTFragment, private val binding: FragmentNftBinding, -) : BasePresenter { +) : BasePresenter, OnInboxCountUpdate { private val viewModel by lazy { ViewModelProvider(fragment.requireActivity())[NftViewModel::class.java] } @@ -47,6 +52,12 @@ class NFTFragmentPresenter( binding.viewToggleButton.setOnClickListener { view -> showCustomPopupMenu(view) } + + binding.flInboxNft.setOnClickListener { + ReactNativeActivity.launchClaimTokens(fragment.requireContext()) + } + InboxManager.addListener(this@NFTFragmentPresenter) + updateInboxBadge(InboxManager.unclaimedCount) } startShimmer(binding.shimmerLayout.shimmerLayout) @@ -127,4 +138,19 @@ class NFTFragmentPresenter( } private fun isGridTabSelected() = true + + override fun onInboxCountUpdate(count: Int) { + updateInboxBadge(count) + } + + private fun updateInboxBadge(count: Int) { + val show = count > 0 && !WalletManager.isEVMAccountSelected() && !WalletManager.isChildAccountSelected() + binding.flInboxNft.setVisible(show) + if (show) { + binding.tvInboxBadgeNft.visible() + binding.tvInboxBadgeNft.text = InboxManager.formatBadgeCount(count) + } else { + binding.tvInboxBadgeNft.gone() + } + } } \ No newline at end of file diff --git a/app/src/main/java/com/flowfoundation/wallet/page/notification/model/WalletNotification.kt b/app/src/main/java/com/flowfoundation/wallet/page/notification/model/WalletNotification.kt index 54738d3c..0bbd23d1 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/notification/model/WalletNotification.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/notification/model/WalletNotification.kt @@ -75,7 +75,10 @@ enum class Type { IMAGE, @SerializedName("pending_request") - PENDING_REQUEST + PENDING_REQUEST, + + @SerializedName("inbox") + INBOX } enum class Priority { diff --git a/app/src/main/java/com/flowfoundation/wallet/page/notification/presenter/NotificationItemPresenter.kt b/app/src/main/java/com/flowfoundation/wallet/page/notification/presenter/NotificationItemPresenter.kt index 2a266b41..d4ffcac7 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/notification/presenter/NotificationItemPresenter.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/notification/presenter/NotificationItemPresenter.kt @@ -9,16 +9,19 @@ import com.bumptech.glide.Glide import com.bumptech.glide.load.resource.bitmap.CenterCrop import com.bumptech.glide.load.resource.bitmap.CircleCrop import com.bumptech.glide.load.resource.drawable.DrawableTransitionOptions +import com.flowfoundation.wallet.R import com.flowfoundation.wallet.base.activity.BaseActivity import com.flowfoundation.wallet.base.presenter.BasePresenter import com.flowfoundation.wallet.base.recyclerview.BaseViewHolder import com.flowfoundation.wallet.databinding.ItemWalletNotificationBinding +import com.flowfoundation.wallet.manager.inbox.InboxManager import com.flowfoundation.wallet.manager.notification.WalletNotificationManager import com.flowfoundation.wallet.manager.walletconnect.dispatch import com.flowfoundation.wallet.manager.walletconnect.getWalletConnectPendingRequests import com.flowfoundation.wallet.manager.walletconnect.model.toWcRequest import com.flowfoundation.wallet.page.browser.openBrowser import com.flowfoundation.wallet.page.notification.model.DisplayType +import com.flowfoundation.wallet.reactnative.ReactNativeActivity import com.flowfoundation.wallet.page.notification.model.Type import com.flowfoundation.wallet.page.notification.model.WalletNotification import com.flowfoundation.wallet.page.profile.subpage.walletconnect.session.WalletConnectSessionActivity @@ -43,8 +46,11 @@ class NotificationItemPresenter( if (model.icon.isNullOrEmpty()) { ivIcon.gone() } else { - Glide.with(ivIcon).load(model.icon()).transform(CenterCrop(), CircleCrop()) - .into(ivIcon) + if (model.type == Type.INBOX) { + ivIcon.setImageResource(R.drawable.ic_inbox) + } else { + Glide.with(ivIcon).load(model.icon()).transform(CenterCrop(), CircleCrop()).into(ivIcon) + } ivIcon.visible() } tvTitle.text = model.title.orEmpty() @@ -78,6 +84,12 @@ class NotificationItemPresenter( WalletNotificationManager.removeNotification(model) } binding.root.setOnClickListener { + if (model.type == Type.INBOX) { + ReactNativeActivity.launchClaimTokens(view.context) + WalletNotificationManager.removeNotification(model) + InboxManager.clearNotificationRef() + return@setOnClickListener + } if (model.type == Type.PENDING_REQUEST) { logd("NotificationItemPresenter", "click pending request") diff --git a/app/src/main/java/com/flowfoundation/wallet/page/wallet/presenter/WalletHeaderPresenter.kt b/app/src/main/java/com/flowfoundation/wallet/page/wallet/presenter/WalletHeaderPresenter.kt index dbc215f8..f8c170a6 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/wallet/presenter/WalletHeaderPresenter.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/wallet/presenter/WalletHeaderPresenter.kt @@ -14,6 +14,8 @@ import com.flowfoundation.wallet.base.recyclerview.BaseViewHolder import com.flowfoundation.wallet.databinding.LayoutWalletCoordinatorHeaderBinding import com.flowfoundation.wallet.manager.app.isTestnet import com.flowfoundation.wallet.manager.config.AppConfig +import com.flowfoundation.wallet.manager.inbox.InboxManager +import com.flowfoundation.wallet.manager.inbox.OnInboxCountUpdate import com.flowfoundation.wallet.manager.evm.EVMWalletManager import com.flowfoundation.wallet.manager.notification.WalletNotificationManager import com.flowfoundation.wallet.manager.token.FungibleTokenListManager @@ -45,7 +47,7 @@ import java.util.Date class WalletHeaderPresenter( private val fragment: Fragment, private val view: View, -) : BaseViewHolder(view), BasePresenter { +) : BaseViewHolder(view), BasePresenter, OnInboxCountUpdate { private val binding by lazy { LayoutWalletCoordinatorHeaderBinding.bind(view) } @@ -89,11 +91,16 @@ class WalletHeaderPresenter( WalletManager.selectedWalletAddress().toAddress() ) } + InboxManager.addListener(this@WalletHeaderPresenter) + flInbox.setOnClickListener { ReactNativeActivity.launchClaimTokens(view.context) } + updateInboxBadge(InboxManager.unclaimedCount) + if (WalletManager.isChildAccountSelected()) { cvSwap.gone() cvBuy.gone() flManageToken.gone() flAddToken.gone() + flInbox.gone() } else { flAddToken.setOnClickListener { if (WalletManager.isEVMAccountSelected()) { @@ -195,6 +202,23 @@ class WalletHeaderPresenter( } } + override fun onInboxCountUpdate(count: Int) { + updateInboxBadge(count) + } + + private fun updateInboxBadge(count: Int) { + with(binding) { + val show = count > 0 && !WalletManager.isChildAccountSelected() + flInbox.setVisible(show) + if (show) { + tvInboxBadge.visible() + tvInboxBadge.text = InboxManager.formatBadgeCount(count) + } else { + tvInboxBadge.gone() + } + } + } + private fun TextView.diffSetText(text: String?) { if (text != this.text.toString()) { this.text = text diff --git a/app/src/main/java/com/flowfoundation/wallet/reactnative/ReactNativeActivity.kt b/app/src/main/java/com/flowfoundation/wallet/reactnative/ReactNativeActivity.kt index c3ad8740..1ede5a29 100644 --- a/app/src/main/java/com/flowfoundation/wallet/reactnative/ReactNativeActivity.kt +++ b/app/src/main/java/com/flowfoundation/wallet/reactnative/ReactNativeActivity.kt @@ -166,6 +166,8 @@ class ReactNativeActivity : ReactActivity() { RNBridge.ScreenType.ONBOARDING -> RNBridge.InitialRoute.GET_STARTED.routeName RNBridge.ScreenType.RECEIVE -> "Receive" RNBridge.ScreenType.ACTIVITY -> RNBridge.InitialRoute.HOME.routeName + RNBridge.ScreenType.CLAIM_TOKENS -> "ClaimTokens" + else -> RNBridge.InitialRoute.HOME.routeName } } @@ -306,6 +308,10 @@ class ReactNativeActivity : ReactActivity() { * @param fromAccount can be null - if null, will generate from selected wallet address * @param targetAddress can be null - if null, user will select target in RN */ + fun launchClaimTokens(context: Context) { + launch(context, RNBridge.ScreenType.CLAIM_TOKENS) + } + fun launchWalletSend(context: Context, fromAccount: RNBridge.WalletAccount?, targetAddress: String?) { val address = WalletManager.selectedWalletAddress().toAddress() val network = chainNetWorkString() diff --git a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/BridgeModels.kt b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/BridgeModels.kt index 01961b94..079916bd 100644 --- a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/BridgeModels.kt +++ b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/BridgeModels.kt @@ -24,7 +24,9 @@ class RNBridge { @SerializedName("onboarding") ONBOARDING, @SerializedName("receive") RECEIVE, @SerializedName("activity") ACTIVITY, - @SerializedName("keystore-migration") KEYSTORE_MIGRATION + @SerializedName("keystore-migration") KEYSTORE_MIGRATION, + @SerializedName("migration") MIGRATION, + @SerializedName("claimTokens") CLAIM_TOKENS } enum class AccountTypeType { diff --git a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/NativeFRWBridge.kt b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/NativeFRWBridge.kt index d40a14cc..e3a5fac2 100644 --- a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/NativeFRWBridge.kt +++ b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/NativeFRWBridge.kt @@ -87,8 +87,6 @@ class NativeFRWBridge(reactContext: ReactApplicationContext) : NativeFRWBridgeSp } init { - logd(TAG, "NativeFRWBridge initialized with context: ${reactContext != null}") - logd(TAG, "React context is active: ${reactContext.hasActiveCatalystInstance()}") ActivityManager.setReactContext(reactContext) System.loadLibrary("TrustWalletCore") } @@ -445,6 +443,8 @@ class NativeFRWBridge(reactContext: ReactApplicationContext) : NativeFRWBridgeSp override fun closeRN(id: String?) = uiHandler.closeRN(id) + override fun closeRNWithNFT(id: String?) {} + override fun getSignKeyIndex(): Double = accountHandler.getSignKeyIndex() override fun isFreeGasEnabled(promise: Promise) = utilsHandler.isFreeGasEnabled(promise) @@ -453,6 +453,13 @@ class NativeFRWBridge(reactContext: ReactApplicationContext) : NativeFRWBridgeSp override fun getSelectedAccount(promise: Promise) = accountHandler.getSelectedAccount(promise, ::bridgeModelToWritableMap) + override fun getMigrationAssets( + sourceAddress: String?, + promise: Promise? + ) {} + + override fun refreshCoaAfterMigration(promise: Promise?) {} + override fun getCurrency(): WritableMap = utilsHandler.getCurrency(::bridgeModelToWritableMap) override fun getTokenRate(token: String): String = utilsHandler.getTokenRate(token) @@ -477,8 +484,7 @@ class NativeFRWBridge(reactContext: ReactApplicationContext) : NativeFRWBridgeSp try { val jsonObject = JSONObject(jsonString) jsonObject.keys().forEach { key -> - val value = jsonObject.get(key) - when (value) { + when (val value = jsonObject.get(key)) { is String -> map.putString(key, value) is Boolean -> map.putBoolean(key, value) is Int -> map.putInt(key, value) @@ -506,8 +512,7 @@ class NativeFRWBridge(reactContext: ReactApplicationContext) : NativeFRWBridgeSp val array = WritableNativeArray() try { for (i in 0 until jsonArray.length()) { - val value = jsonArray.get(i) - when (value) { + when (val value = jsonArray.get(i)) { is String -> array.pushString(value) is Boolean -> array.pushBoolean(value) is Int -> array.pushInt(value) diff --git a/app/src/main/res/drawable/bg_inbox_badge.xml b/app/src/main/res/drawable/bg_inbox_badge.xml new file mode 100644 index 00000000..ca391871 --- /dev/null +++ b/app/src/main/res/drawable/bg_inbox_badge.xml @@ -0,0 +1,5 @@ + + + + + diff --git a/app/src/main/res/drawable/ic_inbox.xml b/app/src/main/res/drawable/ic_inbox.xml new file mode 100644 index 00000000..e6ba0c6a --- /dev/null +++ b/app/src/main/res/drawable/ic_inbox.xml @@ -0,0 +1,14 @@ + + + diff --git a/app/src/main/res/layout/fragment_nft.xml b/app/src/main/res/layout/fragment_nft.xml index 3a840c01..bf5d0d70 100644 --- a/app/src/main/res/layout/fragment_nft.xml +++ b/app/src/main/res/layout/fragment_nft.xml @@ -80,12 +80,46 @@ android:background="@color/contrast_text" android:scaleType="centerInside" android:src="@drawable/ic_add_white" - app:layout_constraintEnd_toStartOf="@id/view_toggle_button" + app:layout_constraintEnd_toStartOf="@id/fl_inbox_nft" app:layout_constraintBottom_toBottomOf="parent" app:layout_constraintTop_toTopOf="parent" app:round="32dp" tools:ignore="ContentDescription" /> + + + + + + + + + + Date: Mon, 16 Mar 2026 15:00:40 +0800 Subject: [PATCH 15/27] fix: screen type --- .../flowfoundation/wallet/reactnative/ReactNativeActivity.kt | 4 ++-- .../flowfoundation/wallet/reactnative/bridge/BridgeModels.kt | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/app/src/main/java/com/flowfoundation/wallet/reactnative/ReactNativeActivity.kt b/app/src/main/java/com/flowfoundation/wallet/reactnative/ReactNativeActivity.kt index 1ede5a29..0580d871 100644 --- a/app/src/main/java/com/flowfoundation/wallet/reactnative/ReactNativeActivity.kt +++ b/app/src/main/java/com/flowfoundation/wallet/reactnative/ReactNativeActivity.kt @@ -166,7 +166,7 @@ class ReactNativeActivity : ReactActivity() { RNBridge.ScreenType.ONBOARDING -> RNBridge.InitialRoute.GET_STARTED.routeName RNBridge.ScreenType.RECEIVE -> "Receive" RNBridge.ScreenType.ACTIVITY -> RNBridge.InitialRoute.HOME.routeName - RNBridge.ScreenType.CLAIM_TOKENS -> "ClaimTokens" + RNBridge.ScreenType.CLAIMTOKENS -> "ClaimTokens" else -> RNBridge.InitialRoute.HOME.routeName } } @@ -309,7 +309,7 @@ class ReactNativeActivity : ReactActivity() { * @param targetAddress can be null - if null, user will select target in RN */ fun launchClaimTokens(context: Context) { - launch(context, RNBridge.ScreenType.CLAIM_TOKENS) + launch(context, RNBridge.ScreenType.CLAIMTOKENS) } fun launchWalletSend(context: Context, fromAccount: RNBridge.WalletAccount?, targetAddress: String?) { diff --git a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/BridgeModels.kt b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/BridgeModels.kt index 079916bd..e7d11596 100644 --- a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/BridgeModels.kt +++ b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/BridgeModels.kt @@ -26,7 +26,7 @@ class RNBridge { @SerializedName("activity") ACTIVITY, @SerializedName("keystore-migration") KEYSTORE_MIGRATION, @SerializedName("migration") MIGRATION, - @SerializedName("claimTokens") CLAIM_TOKENS + @SerializedName("claimTokens") CLAIMTOKENS } enum class AccountTypeType { From 3719f221319c96e03b8679569d0462beb01a258e Mon Sep 17 00:00:00 2001 From: Meng Date: Wed, 18 Mar 2026 00:57:30 +0800 Subject: [PATCH 16/27] fix: display token after claim --- .../manager/token/FungibleTokenListManager.kt | 167 ++++++------------ .../wallet/page/main/MainActivity.kt | 14 +- .../presenter/ManageTokenItemPresenter.kt | 4 +- 3 files changed, 67 insertions(+), 118 deletions(-) diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/token/FungibleTokenListManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/token/FungibleTokenListManager.kt index ea0c0589..6ee0371c 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/token/FungibleTokenListManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/token/FungibleTokenListManager.kt @@ -136,16 +136,6 @@ object FungibleTokenListManager { return@launch } - tokenListCache[address]?.let { cachedList -> - if (cachedList.displayTokenList.isNotEmpty()) { - currentDisplayTokenList.clear() - val filteredList = applyFilters(cachedList.displayTokenList.distinctBy { it.contractId() }) - currentDisplayTokenList.addAll(filteredList) - dispatchListeners() - logd(TAG, "Loaded token list from cache for address: $address") - } - } - updateTokenList(address) } } @@ -174,37 +164,14 @@ object FungibleTokenListManager { logd(TAG, "Fetching token list for address: $address, currency: ${currency.name}, network: $network") val freshList = provider.getTokenList(address, currency, network) + val hiddenIds = getHiddenTokenIds(address) - if (currentDisplayTokenList.isEmpty()) { - val filteredList = applyFilters(freshList.distinctBy { it.contractId() }) - currentDisplayTokenList.addAll(filteredList) - updateDisplayTokenListCache(address) - dispatchListeners() - logd(TAG, "Initial load from provider for token list for address: $address. Count: ${currentDisplayTokenList.size}") - return - } - val freshTokensMap = freshList.associateBy { it.contractId() } - - val updatedFinalTokens = mutableListOf() - for (existingToken in currentDisplayTokenList) { - freshTokensMap[existingToken.contractId()]?.let { updatedVersionOfExistingToken -> - updatedFinalTokens.add(updatedVersionOfExistingToken) - } - } - contractId?.let { targetId -> - freshTokensMap[targetId]?.takeIf { freshToken -> - currentDisplayTokenList.none { it.contractId() == targetId } - }?.let { newToken -> - updatedFinalTokens.add(newToken) - logd(TAG, "Added new token by contractId: $targetId") - } - } + val visibleTokens = freshList.filter { it.contractId() !in hiddenIds } + val filteredList = applyFilters(visibleTokens.distinctBy { it.contractId() }) currentDisplayTokenList.clear() - val finalFilteredList = applyFilters(updatedFinalTokens.distinctBy { it.contractId() }) - currentDisplayTokenList.addAll(finalFilteredList) - updateDisplayTokenListCache(address) - logd(TAG, "Successfully updated token list for address: $address. Count: ${currentDisplayTokenList.size}") + currentDisplayTokenList.addAll(filteredList) + logd(TAG, "Updated token list for address: $address. Count: ${currentDisplayTokenList.size}, hidden: ${hiddenIds.size}") dispatchListeners() } catch (e: Exception) { loge("Error reloading token list for address: $address", e) @@ -212,15 +179,22 @@ object FungibleTokenListManager { } private fun updateDisplayTokenListCache(address: String) { - val oldItem = tokenListCache[address] - if (oldItem != null) { - tokenListCache[address] = oldItem.copy(displayTokenList = ArrayList(currentDisplayTokenList)) - } else { - tokenListCache[address] = DisplayTokenListCache(displayTokenList = ArrayList(currentDisplayTokenList)) - } DisplayTokenCacheManager.cache(tokenListCache) } + private fun getHiddenTokenIds(address: String = WalletManager.selectedWalletAddress()): Set { + return tokenListCache[address]?.hiddenTokenIds ?: emptySet() + } + + private fun rebuildDisplayList(address: String) { + val allTokens = getCurrentTokenListSnapshot() + val hiddenIds = getHiddenTokenIds(address) + val visibleTokens = allTokens.filter { it.contractId() !in hiddenIds } + val filteredList = applyFilters(visibleTokens.distinctBy { it.contractId() }) + currentDisplayTokenList.clear() + currentDisplayTokenList.addAll(filteredList) + } + private fun applyFilters(tokens: List): List { var filteredList = tokens @@ -248,30 +222,10 @@ object FungibleTokenListManager { if (address.isBlank()) { return } - logd(TAG, "setHideDustTokens: hide=$hide, currentDisplayTokenList.size=${currentDisplayTokenList.size}") - currentDisplayTokenList.forEach { token -> - logd(TAG, "setHideDustTokens: Before - ${token.symbol} balance=${token.tokenBalanceInUSD()}") - } + logd(TAG, "setHideDustTokens: hide=$hide") val oldItem = tokenListCache[address] ?: DisplayTokenListCache() - if (hide) { - val filteredList = currentDisplayTokenList.filter { it.tokenBalanceInUSD() > BigDecimal(0.01) } - logd(TAG, "setHideDustTokens: Filtered out ${currentDisplayTokenList.size - filteredList.size} dust tokens") - currentDisplayTokenList.clear() - currentDisplayTokenList.addAll(filteredList) - tokenListCache[address] = oldItem.copy(hideDustTokens = true, displayTokenList = filteredList) - } else { - val tokenList = getCurrentTokenListSnapshot() - val displayListSnapshot = currentDisplayTokenList.toList() - currentDisplayTokenList.clear() - if (isOnlyShowVerifiedTokens()) { - val filteredList = tokenList.filter { it.isVerified }.filter { verified -> displayListSnapshot.any { it.isSameToken(verified.contractId()) } } - currentDisplayTokenList.addAll(filteredList) - } else { - currentDisplayTokenList.addAll(tokenList) - } - tokenListCache[address] = - oldItem.copy(hideDustTokens = false, displayTokenList = currentDisplayTokenList) - } + tokenListCache[address] = oldItem.copy(hideDustTokens = hide) + rebuildDisplayList(address) DisplayTokenCacheManager.cache(tokenListCache) dispatchListeners() } @@ -282,24 +236,8 @@ object FungibleTokenListManager { return } val oldItem = tokenListCache[address] ?: DisplayTokenListCache() - if (show) { - val filteredList = currentDisplayTokenList.filter { it.isVerified } - currentDisplayTokenList.clear() - currentDisplayTokenList.addAll(filteredList) - tokenListCache[address] = - oldItem.copy(onlyShowVerifiedTokens = true, displayTokenList = filteredList) - } else { - val tokenList = getCurrentTokenListSnapshot() - val displayListSnapshot = currentDisplayTokenList.toList() - currentDisplayTokenList.clear() - if (isHideDustTokens()) { - val filteredList = tokenList.filter { it.tokenBalanceInUSD() > BigDecimal(0.01) }.filter { verified -> displayListSnapshot.any{ it.isSameToken(verified.contractId()) } } - currentDisplayTokenList.addAll(filteredList) - } else { - currentDisplayTokenList.addAll(tokenList) - } - tokenListCache[address] = oldItem.copy(onlyShowVerifiedTokens = false, displayTokenList = currentDisplayTokenList) - } + tokenListCache[address] = oldItem.copy(onlyShowVerifiedTokens = show) + rebuildDisplayList(address) DisplayTokenCacheManager.cache(tokenListCache) dispatchListeners() } @@ -346,43 +284,42 @@ object FungibleTokenListManager { fun isTokenAdded(contractId: String) = getCurrentTokenListSnapshot().any { it.isSameToken(contractId) } - fun addDisplayToken(token: FungibleToken) { + fun showToken(token: FungibleToken) { ioScope { - if (currentDisplayTokenList.any { it.isSameToken(token.contractId()) }) { - logd(TAG, "Token ${token.contractId()} already in display list.") - return@ioScope - } + val address = WalletManager.selectedWalletAddress() + if (address.isBlank()) return@ioScope - // Check if token should be filtered out - val shouldShow = applyFilters(listOf(token)).isNotEmpty() - if (!shouldShow) { - logd(TAG, "Token ${token.contractId()} filtered out (dust/unverified), not adding to display list.") - return@ioScope - } + val oldItem = tokenListCache[address] ?: DisplayTokenListCache() + val newHidden = oldItem.hiddenTokenIds - token.contractId() + tokenListCache[address] = oldItem.copy(hiddenTokenIds = newHidden) - currentDisplayTokenList.add(token) - val address = WalletManager.selectedWalletAddress() - if (address.isNotBlank()) { - updateDisplayTokenListCache(address) + if (currentDisplayTokenList.none { it.isSameToken(token.contractId()) }) { + val shouldShow = applyFilters(listOf(token)).isNotEmpty() + if (shouldShow) { + currentDisplayTokenList.add(token) + } } + + updateDisplayTokenListCache(address) dispatchDisplayUpdated(token, true) - logd(TAG, "Added token ${token.contractId()} to display list. New count: ${currentDisplayTokenList.size}") + logd(TAG, "Showed token ${token.contractId()}. Hidden count: ${newHidden.size}") } } - fun removeDisplayToken(token: FungibleToken) { + fun hideToken(token: FungibleToken) { ioScope { - val removed = currentDisplayTokenList.removeAll { it.isSameToken(token.contractId()) } - if (removed) { - val address = WalletManager.selectedWalletAddress() - if (address.isNotBlank()) { - updateDisplayTokenListCache(address) - } - dispatchDisplayUpdated(token, false) - logd(TAG, "Removed token ${token.contractId()} from display list. New count: ${currentDisplayTokenList.size}") - } else { - logd(TAG, "Token ${token.contractId()} not found in display list for removal.") - } + val address = WalletManager.selectedWalletAddress() + if (address.isBlank()) return@ioScope + + val oldItem = tokenListCache[address] ?: DisplayTokenListCache() + val newHidden = oldItem.hiddenTokenIds + token.contractId() + tokenListCache[address] = oldItem.copy(hiddenTokenIds = newHidden) + + currentDisplayTokenList.removeAll { it.isSameToken(token.contractId()) } + + updateDisplayTokenListCache(address) + dispatchDisplayUpdated(token, false) + logd(TAG, "Hid token ${token.contractId()}. Hidden count: ${newHidden.size}") } } @@ -415,6 +352,6 @@ data class DisplayTokenListCache( val hideDustTokens: Boolean = false, @SerializedName("onlyShowVerifiedTokens") val onlyShowVerifiedTokens: Boolean = false, - @SerializedName("displayTokenList") - val displayTokenList: List = emptyList() + @SerializedName("hiddenTokenIds") + val hiddenTokenIds: Set = emptySet() ) diff --git a/app/src/main/java/com/flowfoundation/wallet/page/main/MainActivity.kt b/app/src/main/java/com/flowfoundation/wallet/page/main/MainActivity.kt index 367af258..dec14675 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/main/MainActivity.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/main/MainActivity.kt @@ -32,9 +32,12 @@ import com.flowfoundation.wallet.utils.uiScope import ai.luciq.bug.BugReporting import ai.luciq.library.Luciq import com.flowfoundation.wallet.manager.inbox.InboxManager +import com.flowfoundation.wallet.manager.transaction.OnTransactionStateChange +import com.flowfoundation.wallet.manager.transaction.TransactionState +import com.flowfoundation.wallet.manager.transaction.TransactionStateManager import com.flowfoundation.wallet.manager.wallet.WalletManager -class MainActivity : BaseActivity() { +class MainActivity : BaseActivity(), OnTransactionStateChange { private lateinit var contentPresenter: MainContentPresenter @@ -85,6 +88,7 @@ class MainActivity : BaseActivity() { } configurationInstabugBugReport() LocalBroadcastManager.getInstance(this).registerReceiver(restoreMnemonicReceiver, IntentFilter("ACTION_RESTORE_MNEMONIC")) + TransactionStateManager.addOnTransactionStateChange(this) WalletManager.checkKeyRotation(this) WalletManager.checkKeystoreMigration(this) } @@ -136,6 +140,14 @@ class MainActivity : BaseActivity() { InboxManager.refresh() } + override fun onTransactionStateChange() { + val transactionList = TransactionStateManager.getTransactionStateList() + val transaction = transactionList.lastOrNull { it.type == TransactionState.TYPE_SEND } + if (transaction?.isSuccess() == true) { + InboxManager.refresh() + } + } + private fun checkPendingAction() { if (PendingActionHelper.hasPendingDeepLink(this)) { val pendingDeeplink = PendingActionHelper.getPendingDeepLink(this) diff --git a/app/src/main/java/com/flowfoundation/wallet/page/token/manage/presenter/ManageTokenItemPresenter.kt b/app/src/main/java/com/flowfoundation/wallet/page/token/manage/presenter/ManageTokenItemPresenter.kt index ceeff200..9e808b94 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/token/manage/presenter/ManageTokenItemPresenter.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/token/manage/presenter/ManageTokenItemPresenter.kt @@ -35,9 +35,9 @@ class ManageTokenItemPresenter( switchDisplay.isChecked = FungibleTokenListManager.isDisplayToken(contractId = model.contractId()) switchDisplay.setOnCheckedChangeListener { _, isChecked -> if (isChecked) { - FungibleTokenListManager.addDisplayToken(model) + FungibleTokenListManager.showToken(model) } else { - FungibleTokenListManager.removeDisplayToken(model) + FungibleTokenListManager.hideToken(model) } } } From 7b21aff1c9f9faad13ba54b4a4a8b4b3da68d83d Mon Sep 17 00:00:00 2001 From: Meng Date: Wed, 18 Mar 2026 13:07:55 +0800 Subject: [PATCH 17/27] feat: add new eoa account --- app/build.gradle | 2 +- .../manager/evm/DAppEVMConnectionManager.kt | 14 +- .../wallet/manager/evm/Utils.kt | 7 +- .../wallet/manager/wallet/WalletManager.kt | 12 ++ .../WalletConnectRequestDispatcher.kt | 6 +- .../wallet/manager/walletdata/MainWallet.kt | 4 +- .../manager/walletdata/WalletDataManager.kt | 69 ++++++-- .../wallet/network/AddAccountUtils.kt | 48 +++++ .../page/account/AccountListActivity.kt | 17 +- .../page/account/AccountListViewModel.kt | 35 +++- .../page/dialog/common/AddNewAccountDialog.kt | 166 ++++++++++++++++++ .../page/main/drawer/DrawerLayoutViewModel.kt | 35 +++- .../main/presenter/DrawerLayoutContent.kt | 14 +- .../bridge/handlers/WalletBridgeHandler.kt | 3 +- .../widgets/webview/evm/EvmInterface.kt | 6 +- .../res/drawable/ic_add_cadence_account.xml | 14 ++ .../main/res/drawable/ic_add_eoa_account.xml | 14 ++ app/src/main/res/values/strings.xml | 2 + 18 files changed, 425 insertions(+), 43 deletions(-) create mode 100644 app/src/main/java/com/flowfoundation/wallet/page/dialog/common/AddNewAccountDialog.kt create mode 100644 app/src/main/res/drawable/ic_add_cadence_account.xml create mode 100644 app/src/main/res/drawable/ic_add_eoa_account.xml diff --git a/app/build.gradle b/app/build.gradle index bbc9a386..6b2a882e 100644 --- a/app/build.gradle +++ b/app/build.gradle @@ -352,7 +352,7 @@ dependencies { api fileTree(dir: "libs", include: ["*.aar", "*.jar"], exclude: ["trustwalletcore.aar"]) // Fetch Flow Wallet Kit from GitHub Packages - implementation 'com.github.onflow.flow-wallet-kit:flow-wallet-android:0.2.5' + implementation 'com.github.onflow.flow-wallet-kit:flow-wallet-android:0.2.6' implementation "org.jetbrains.kotlin:kotlin-stdlib:1.9.22" /** Android Architecture **/ implementation 'androidx.core:core-ktx:1.13.1' diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/evm/DAppEVMConnectionManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/evm/DAppEVMConnectionManager.kt index 39355a95..ce3b1920 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/evm/DAppEVMConnectionManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/evm/DAppEVMConnectionManager.kt @@ -1,7 +1,9 @@ package com.flowfoundation.wallet.manager.evm +import com.flowfoundation.wallet.manager.account.AccountManager import com.flowfoundation.wallet.manager.flowjvm.cadenceQueryCOATokenBalance import com.flowfoundation.wallet.manager.wallet.WalletManager +import com.flowfoundation.wallet.manager.walletdata.EOAWallet import com.flowfoundation.wallet.utils.formatPrice import com.flowfoundation.wallet.utils.Env import com.flowfoundation.wallet.utils.ioScope @@ -107,12 +109,12 @@ object DAppEVMConnectionManager { } } - // Load EOA account - val eoaAddress = WalletManager.getEOAAddress() - if (!eoaAddress.isNullOrEmpty()) { - logd(TAG, "Found EOA account: $eoaAddress") - // EOA balance is hidden as per requirements - accounts.add(DAppEVMAccount(eoaAddress, DAppEVMAccountType.EOA, null)) + // Load all EOA accounts + val eoaWallets = AccountManager.walletNodes() + ?.filterIsInstance() ?: emptyList() + eoaWallets.forEach { eoaWallet -> + logd(TAG, "Found EOA account: ${eoaWallet.address} (index=${eoaWallet.index})") + accounts.add(DAppEVMAccount(eoaWallet.address, DAppEVMAccountType.EOA, null)) } _availableAccounts.value = accounts diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/evm/Utils.kt b/app/src/main/java/com/flowfoundation/wallet/manager/evm/Utils.kt index b2770eb7..e3cfc3bc 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/evm/Utils.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/evm/Utils.kt @@ -257,11 +257,13 @@ Unit) { return@ioScope } val singer = cryptoProvider.getSigner(HashingAlgorithm.SHA2_256) + val eoaIndex = WalletManager.getSelectedEOAIndex() val result = WalletManager.wallet()?.ethSignTransactionAndSendByCadence( input = input, fromAddress = address, signers = listOf(singer), - flowAddress = FlowAddress(WalletManager.getCurrentFlowWalletAddress().orEmpty()) + flowAddress = FlowAddress(WalletManager.getCurrentFlowWalletAddress().orEmpty()), + index = eoaIndex ) if (result == null) { logd("EOATransaction", "ERROR: Failed to sign transaction") @@ -275,7 +277,8 @@ Unit) { callback.invoke(txHash) } else { - val output = WalletManager.wallet()?.ethSignTransaction(input) + val eoaIndex = WalletManager.getSelectedEOAIndex() + val output = WalletManager.wallet()?.ethSignTransaction(input, index = eoaIndex) if (output == null) { logd("EOATransaction", "ERROR: Failed to sign transaction") diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletManager.kt index 985980be..c61cc1d2 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletManager.kt @@ -55,6 +55,18 @@ object WalletManager { return null } + /** + * Get the BIP44 derivation index for the currently selected EOA wallet. + * Returns 0 if no EOA is selected or found. + */ + fun getSelectedEOAIndex(): Int { + val selectedAddress = selectedWalletAddress() + return AccountManager.walletNodes() + ?.filterIsInstance() + ?.firstOrNull { it.address.equals(selectedAddress, ignoreCase = true) } + ?.index ?: 0 + } + private fun initializeWallet(): Boolean { logd(TAG, "initializeWallet() called") diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/walletconnect/WalletConnectRequestDispatcher.kt b/app/src/main/java/com/flowfoundation/wallet/manager/walletconnect/WalletConnectRequestDispatcher.kt index 509590c8..50937320 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/walletconnect/WalletConnectRequestDispatcher.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/walletconnect/WalletConnectRequestDispatcher.kt @@ -188,7 +188,8 @@ suspend fun WCRequest.evmSignTypedData() { EVMSignTypedDataDialog.observe { isApprove -> ioScope { val result = if (DAppEVMConnectionManager.isCurrentEOAAccount()) { - val data = WalletManager.wallet()?.ethSignTypedData(message) + val eoaIndex = WalletManager.getSelectedEOAIndex() + val data = WalletManager.wallet()?.ethSignTypedData(message, index = eoaIndex) Numeric.toHexString(data) } else { signTypedData(hashData) @@ -290,7 +291,8 @@ private suspend fun WCRequest.evmSignMessage() { val result = if (EVMWalletManager.isEVMWalletAddress(fromAddress)) { signEthereumMessage(message) } else { - val data = WalletManager.wallet()?.ethSignPersonalMessage(hexMessage.hexToBytes()) + val eoaIndex = WalletManager.getSelectedEOAIndex() + val data = WalletManager.wallet()?.ethSignPersonalMessage(hexMessage.hexToBytes(), index = eoaIndex) Numeric.toHexString(data) } if (isApprove) approve(result) else reject() diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/walletdata/MainWallet.kt b/app/src/main/java/com/flowfoundation/wallet/manager/walletdata/MainWallet.kt index 4b86455b..c1c64025 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/walletdata/MainWallet.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/walletdata/MainWallet.kt @@ -33,7 +33,9 @@ data class EOAWallet( @SerializedName("name") override val name: String, @SerializedName("emojiId") - override val emojiId: Int + override val emojiId: Int, + @SerializedName("index") + val index: Int = 0 ) : MainWallet() // Linked Wallets (Children / COA) diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/walletdata/WalletDataManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/walletdata/WalletDataManager.kt index cc9babed..118ac81e 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/walletdata/WalletDataManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/walletdata/WalletDataManager.kt @@ -272,16 +272,32 @@ object WalletDataManager { // EOA Wallet - canDeriveEoa is determined per-wallet by WalletCreationHelper // based on key type (Secure Enclave / private key = false, seed phrase = true) if (canDeriveEoa) { - val eoa = deriveEoaAddress(wallet) - logd(TAG, "Generated EOA address: $eoa") - if (eoa.isNotEmpty()) { - logd(TAG, "Adding EOA for account: $eoa") - val eoaEmojiInfo = getEmojiInfo(eoa) - nodes.add(EOAWallet( - address = eoa, - name = eoaEmojiInfo.emojiName, - emojiId = eoaEmojiInfo.emojiId - )) + val existingEOAs = account.walletNodes.filterIsInstance() + if (existingEOAs.isNotEmpty()) { + // Preserve all existing EOA wallets with their indices + existingEOAs.forEach { existingEoa -> + val eoaEmojiInfo = getEmojiInfo(existingEoa.address) + nodes.add(EOAWallet( + address = existingEoa.address, + name = eoaEmojiInfo.emojiName, + emojiId = eoaEmojiInfo.emojiId, + index = existingEoa.index + )) + } + logd(TAG, "Preserved ${existingEOAs.size} existing EOA wallets") + } else { + val eoa = deriveEoaAddress(wallet) + logd(TAG, "Generated EOA address: $eoa") + if (eoa.isNotEmpty()) { + logd(TAG, "Adding EOA for account: $eoa") + val eoaEmojiInfo = getEmojiInfo(eoa) + nodes.add(EOAWallet( + address = eoa, + name = eoaEmojiInfo.emojiName, + emojiId = eoaEmojiInfo.emojiId, + index = 0 + )) + } } } @@ -392,15 +408,30 @@ object WalletDataManager { // EOA - canDeriveEoa is determined per-wallet by WalletCreationHelper // based on key type (Secure Enclave / private key = false, seed phrase = true) if (canDeriveEoa) { - val eoa = deriveEoaAddress(wallet) - if (eoa.isNotEmpty()) { - logd(TAG, "Adding EOA for non-current account: $eoa") - val eoaEmojiInfo = getEmojiInfo(eoa) - nodes.add(EOAWallet( - address = eoa, - name = eoaEmojiInfo.emojiName, - emojiId = eoaEmojiInfo.emojiId - )) + val existingEOAs = account.walletNodes.filterIsInstance() + if (existingEOAs.isNotEmpty()) { + existingEOAs.forEach { existingEoa -> + val eoaEmojiInfo = getEmojiInfo(existingEoa.address) + nodes.add(EOAWallet( + address = existingEoa.address, + name = eoaEmojiInfo.emojiName, + emojiId = eoaEmojiInfo.emojiId, + index = existingEoa.index + )) + } + logd(TAG, "Preserved ${existingEOAs.size} existing EOA wallets for non-current account") + } else { + val eoa = deriveEoaAddress(wallet) + if (eoa.isNotEmpty()) { + logd(TAG, "Adding EOA for non-current account: $eoa") + val eoaEmojiInfo = getEmojiInfo(eoa) + nodes.add(EOAWallet( + address = eoa, + name = eoaEmojiInfo.emojiName, + emojiId = eoaEmojiInfo.emojiId, + index = 0 + )) + } } } else { logd(TAG, "Skipping EOA for non-current account (canDeriveEoa=false)") diff --git a/app/src/main/java/com/flowfoundation/wallet/network/AddAccountUtils.kt b/app/src/main/java/com/flowfoundation/wallet/network/AddAccountUtils.kt index cd9ffd3b..8f9a024e 100644 --- a/app/src/main/java/com/flowfoundation/wallet/network/AddAccountUtils.kt +++ b/app/src/main/java/com/flowfoundation/wallet/network/AddAccountUtils.kt @@ -5,6 +5,7 @@ import com.flowfoundation.wallet.manager.app.chainNetWorkString import com.flowfoundation.wallet.manager.emoji.AccountEmojiManager import com.flowfoundation.wallet.manager.key.CryptoProviderManager import com.flowfoundation.wallet.manager.wallet.WalletManager +import com.flowfoundation.wallet.manager.walletdata.EOAWallet import com.flowfoundation.wallet.manager.walletdata.FlowWallet import com.flowfoundation.wallet.network.model.ManualAddressRequest import com.flowfoundation.wallet.utils.logd @@ -91,3 +92,50 @@ suspend fun addNewFlowAccount(): String? { null } } + +/** + * Add a new EOA (Externally Owned Account) wallet by deriving the next BIP44 index. + * This is a purely local operation (no network request needed). + * + * @return the new EOA address, or null on failure + */ +suspend fun addNewEOAAccount(): String? { + return try { + val wallet = WalletManager.wallet() + if (wallet == null) { + loge(TAG, "No wallet available from WalletManager") + return null + } + + val existingEOAs = AccountManager.walletNodes() + ?.filterIsInstance() ?: emptyList() + val nextIndex = if (existingEOAs.isEmpty()) 0 else existingEOAs.maxOf { it.index } + 1 + + logd(TAG, "Deriving EOA address at index $nextIndex") + val address = wallet.ethAddress(nextIndex) + if (address.isBlank()) { + loge(TAG, "Derived empty EOA address at index $nextIndex") + return null + } + + val emojiInfo = AccountEmojiManager.getEmojiByAddress(address) + + val eoaWallet = EOAWallet( + address = address, + name = emojiInfo.emojiName, + emojiId = emojiInfo.emojiId, + index = nextIndex + ) + + AccountManager.updateCurrentAccount { account -> + account.copy(walletNodes = account.walletNodes + eoaWallet) + } + + logd(TAG, "New EOAWallet added to account: $address (index=$nextIndex)") + address + } catch (e: Exception) { + loge(TAG, "Failed to add new EOA account: ${e.message}") + e.printStackTrace() + null + } +} diff --git a/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListActivity.kt b/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListActivity.kt index fc617227..4e6adbf9 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListActivity.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListActivity.kt @@ -65,6 +65,7 @@ import androidx.lifecycle.compose.LocalLifecycleOwner import androidx.lifecycle.viewmodel.compose.viewModel import com.flowfoundation.wallet.R import com.flowfoundation.wallet.base.activity.BaseActivity +import com.flowfoundation.wallet.page.dialog.common.AddNewAccountDialog import com.flowfoundation.wallet.manager.wallet.WalletManager import com.flowfoundation.wallet.page.wallet.view.AccountItemSection import com.flowfoundation.wallet.page.profile.subpage.wallet.WalletSettingActivity @@ -107,6 +108,7 @@ fun AccountListScreen( val hiddenAccounts by viewModel.hiddenAccounts.collectAsState() val isAddingAccount by viewModel.isAddingAccount.collectAsState() val canAddAccount by viewModel.canAddAccount.collectAsState() + val canAddEOAAccount by viewModel.canAddEOAAccount.collectAsState() val context = LocalContext.current val activity = remember { getActivityFromContext(context) as FragmentActivity } val lifecycleOwner = androidx.lifecycle.compose.LocalLifecycleOwner.current @@ -154,10 +156,19 @@ fun AccountListScreen( } }, actions = { + val canAdd = canAddAccount || canAddEOAAccount IconButton( - onClick = { viewModel.addAccount() }, - enabled = canAddAccount, - modifier = Modifier.alpha(if (canAddAccount) 1f else 0f) + onClick = { + AddNewAccountDialog.show( + activity.supportFragmentManager, + canAddCadence = canAddAccount, + canAddEOA = canAddEOAAccount, + onCadence = { viewModel.addCadenceAccount() }, + onEOA = { viewModel.addEOAAccount() } + ) + }, + enabled = canAdd, + modifier = Modifier.alpha(if (canAdd) 1f else 0f) ) { Icon( imageVector = Icons.Default.Add, diff --git a/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt b/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt index 3037217c..92026e07 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt @@ -18,6 +18,8 @@ import com.flowfoundation.wallet.manager.config.AppConfig import com.flowfoundation.wallet.manager.key.AndroidKeystoreCryptoProvider import com.flowfoundation.wallet.manager.key.CryptoProviderManager import com.flowfoundation.wallet.network.ApiService +import com.flowfoundation.wallet.manager.key.HDWalletCryptoProvider +import com.flowfoundation.wallet.network.addNewEOAAccount import com.flowfoundation.wallet.network.addNewFlowAccount import com.flowfoundation.wallet.network.retrofitApi import com.flowfoundation.wallet.page.main.model.WalletAccountData @@ -25,6 +27,7 @@ import com.flowfoundation.wallet.page.main.model.LinkedAccountData import com.flowfoundation.wallet.utils.formatLargeBalanceNumber import com.flowfoundation.wallet.utils.isHideCOAWithZeroBalanceEnable import com.flowfoundation.wallet.utils.ioScope +import com.flowfoundation.wallet.utils.logd import com.flowfoundation.wallet.utils.toast import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.StateFlow @@ -48,6 +51,9 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { private val _canAddAccount = MutableStateFlow(false) val canAddAccount: StateFlow = _canAddAccount.asStateFlow() + private val _canAddEOAAccount = MutableStateFlow(false) + val canAddEOAAccount: StateFlow = _canAddEOAAccount.asStateFlow() + private val service by lazy { retrofitApi().create(ApiService::class.java) } // Cache for verified EVM addresses that should be included in linkedAccounts @@ -162,13 +168,21 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { && cryptoProvider != null && cryptoProvider !is AndroidKeystoreCryptoProvider + val eoaWalletCount = walletNodes.filterIsInstance().size + val canCreate = AppConfig.canCreateNewAccount() + val canDerive = WalletManager.canDeriveEoa() + val eoaUnderLimit = eoaWalletCount < 5 + val isHDProvider = cryptoProvider is HDWalletCryptoProvider + _canAddEOAAccount.value = canCreate && canDerive && eoaUnderLimit && isHDProvider + logd("AccountListViewModel", "canAddEOA: canCreate=$canCreate, canDerive=$canDerive, eoaCount=$eoaWalletCount(<5=$eoaUnderLimit), isHDProvider=$isHDProvider => ${_canAddEOAAccount.value}") + if (refreshBalance) { fetchAllBalances(addressList, pendingEvmAddresses) } } } - fun addAccount() { + fun addCadenceAccount() { ioScope { _isAddingAccount.value = true try { @@ -177,7 +191,24 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { _isAddingAccount.value = false toast(msgRes = R.string.common_error_hint) } else { - // New accounts always have 0 balance; inject immediately for instant UI feedback + _balanceMap.value += (result to "0 FLOW") + refreshWalletList(false) + } + } finally { + _isAddingAccount.value = false + } + } + } + + fun addEOAAccount() { + ioScope { + _isAddingAccount.value = true + try { + val result = addNewEOAAccount() + if (result == null) { + _isAddingAccount.value = false + toast(msgRes = R.string.common_error_hint) + } else { _balanceMap.value += (result to "0 FLOW") refreshWalletList(false) } diff --git a/app/src/main/java/com/flowfoundation/wallet/page/dialog/common/AddNewAccountDialog.kt b/app/src/main/java/com/flowfoundation/wallet/page/dialog/common/AddNewAccountDialog.kt new file mode 100644 index 00000000..ebe53142 --- /dev/null +++ b/app/src/main/java/com/flowfoundation/wallet/page/dialog/common/AddNewAccountDialog.kt @@ -0,0 +1,166 @@ +package com.flowfoundation.wallet.page.dialog.common + +import android.os.Bundle +import android.view.LayoutInflater +import android.view.View +import android.view.ViewGroup +import androidx.compose.foundation.background +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.HorizontalDivider +import androidx.compose.material3.Icon +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.alpha +import androidx.compose.ui.platform.ComposeView +import androidx.compose.ui.res.colorResource +import androidx.compose.ui.res.painterResource +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import androidx.fragment.app.FragmentManager +import com.flowfoundation.wallet.R +import com.google.android.material.bottomsheet.BottomSheetDialogFragment + +class AddNewAccountDialog : BottomSheetDialogFragment() { + + override fun onCreateView( + inflater: LayoutInflater, + container: ViewGroup?, + savedInstanceState: Bundle? + ): View { + return ComposeView(requireContext()).apply { + setContent { + AddNewAccountContent( + canAddCadence = canAddCadence, + canAddEOA = canAddEOA, + onCadenceClick = { + dismiss() + onCadenceClick?.invoke() + }, + onEOAClick = { + dismiss() + onEOAClick?.invoke() + } + ) + } + } + } + + override fun onDestroyView() { + super.onDestroyView() + onCadenceClick = null + onEOAClick = null + } + + companion object { + private var onCadenceClick: (() -> Unit)? = null + private var onEOAClick: (() -> Unit)? = null + private var canAddCadence: Boolean = true + private var canAddEOA: Boolean = true + + fun show( + fragmentManager: FragmentManager, + canAddCadence: Boolean = true, + canAddEOA: Boolean = true, + onCadence: () -> Unit, + onEOA: () -> Unit + ) { + this.onCadenceClick = onCadence + this.onEOAClick = onEOA + this.canAddCadence = canAddCadence + this.canAddEOA = canAddEOA + AddNewAccountDialog().showNow(fragmentManager, "AddNewAccountDialog") + } + } +} + +@Composable +private fun AddNewAccountContent( + canAddCadence: Boolean, + canAddEOA: Boolean, + onCadenceClick: () -> Unit, + onEOAClick: () -> Unit +) { + + Column( + modifier = Modifier + .fillMaxWidth() + .background( + color = colorResource(id = R.color.deep_bg), + shape = RoundedCornerShape(topStart = 16.dp, topEnd = 16.dp) + ) + .padding(18.dp) + ) { + Column( + modifier = Modifier + .fillMaxWidth() + .background( + color = colorResource(id = R.color.bg_card), + shape = RoundedCornerShape(topStart = 16.dp, topEnd = 16.dp) + ) + .padding(horizontal = 18.dp) + ) { + Row( + modifier = Modifier + .fillMaxWidth() + .alpha(if (canAddCadence) 1f else 0.4f) + .clickable(enabled = canAddCadence) { onCadenceClick() } + .padding(vertical = 16.dp), + verticalAlignment = Alignment.CenterVertically + ) { + Icon( + painter = painterResource(id = R.drawable.ic_add_cadence_account), + contentDescription = null, + tint = colorResource(id = R.color.text_1), + modifier = Modifier.size(20.dp) + ) + Spacer(modifier = Modifier.width(12.dp)) + Text( + text = stringResource(R.string.create_new_cadence_account), + color = colorResource(id = R.color.text_1), + fontSize = 16.sp, + fontWeight = FontWeight.Medium + ) + } + + HorizontalDivider( + color = colorResource(id = R.color.border_line_stroke), + modifier = Modifier.fillMaxWidth() + ) + + Row( + modifier = Modifier + .fillMaxWidth() + .alpha(if (canAddEOA) 1f else 0.4f) + .clickable(enabled = canAddEOA) { onEOAClick() } + .padding(vertical = 16.dp), + verticalAlignment = Alignment.CenterVertically + ) { + Icon( + painter = painterResource(id = R.drawable.ic_add_eoa_account), + contentDescription = null, + tint = colorResource(id = R.color.text_1), + modifier = Modifier.size(20.dp) + ) + Spacer(modifier = Modifier.width(12.dp)) + Text( + text = stringResource(R.string.create_new_eoa_account), + color = colorResource(id = R.color.text_1), + fontSize = 16.sp, + fontWeight = FontWeight.Medium + ) + } + } + } +} diff --git a/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt b/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt index 419fb3ba..84c3a9fd 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt @@ -18,11 +18,14 @@ import com.flowfoundation.wallet.manager.config.AppConfig import com.flowfoundation.wallet.manager.key.AndroidKeystoreCryptoProvider import com.flowfoundation.wallet.manager.key.CryptoProviderManager import com.flowfoundation.wallet.network.ApiService +import com.flowfoundation.wallet.manager.key.HDWalletCryptoProvider +import com.flowfoundation.wallet.network.addNewEOAAccount import com.flowfoundation.wallet.network.addNewFlowAccount import com.flowfoundation.wallet.network.retrofitApi import com.flowfoundation.wallet.utils.formatLargeBalanceNumber import com.flowfoundation.wallet.utils.isHideCOAWithZeroBalanceEnable import com.flowfoundation.wallet.utils.ioScope +import com.flowfoundation.wallet.utils.logd import com.flowfoundation.wallet.network.model.UserInfoData import com.flowfoundation.wallet.manager.account.AccountVisibilityManager import com.flowfoundation.wallet.manager.account.OnAccountUpdate @@ -54,6 +57,9 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { private val _canAddAccount = MutableStateFlow(false) val canAddAccount: StateFlow = _canAddAccount.asStateFlow() + private val _canAddEOAAccount = MutableStateFlow(false) + val canAddEOAAccount: StateFlow = _canAddEOAAccount.asStateFlow() + private val service by lazy { retrofitApi().create(ApiService::class.java) } // Cache for verified EVM addresses that should be included in linkedAccounts @@ -176,13 +182,21 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { && cryptoProvider != null && cryptoProvider !is AndroidKeystoreCryptoProvider + val eoaWalletCount = walletNodes.filterIsInstance().size + val canCreate = AppConfig.canCreateNewAccount() + val canDerive = WalletManager.canDeriveEoa() + val eoaUnderLimit = eoaWalletCount < 5 + val isHDProvider = cryptoProvider is HDWalletCryptoProvider + _canAddEOAAccount.value = canCreate && canDerive && eoaUnderLimit && isHDProvider + logd("DrawerLayoutViewModel", "canAddEOA: canCreate=$canCreate, canDerive=$canDerive, eoaCount=$eoaWalletCount(<5=$eoaUnderLimit), isHDProvider=$isHDProvider => ${_canAddEOAAccount.value}") + if (refreshBalance) { fetchAllBalances(addressList, pendingEvmAddresses) } } } - fun addAccount() { + fun addCadenceAccount() { ioScope { _isAddingAccount.value = true try { @@ -191,7 +205,24 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { _isAddingAccount.value = false toast(msgRes = R.string.common_error_hint) } else { - // New accounts always have 0 balance; inject immediately for instant UI feedback + _balanceMap.value += (result to "0 FLOW") + refreshWalletList(false) + } + } finally { + _isAddingAccount.value = false + } + } + } + + fun addEOAAccount() { + ioScope { + _isAddingAccount.value = true + try { + val result = addNewEOAAccount() + if (result == null) { + _isAddingAccount.value = false + toast(msgRes = R.string.common_error_hint) + } else { _balanceMap.value += (result to "0 FLOW") refreshWalletList(false) } diff --git a/app/src/main/java/com/flowfoundation/wallet/page/main/presenter/DrawerLayoutContent.kt b/app/src/main/java/com/flowfoundation/wallet/page/main/presenter/DrawerLayoutContent.kt index 8c1a7078..3c095d5f 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/main/presenter/DrawerLayoutContent.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/main/presenter/DrawerLayoutContent.kt @@ -77,6 +77,7 @@ import com.flowfoundation.wallet.manager.transaction.TransactionStateManager import com.flowfoundation.wallet.manager.wallet.WalletManager import com.flowfoundation.wallet.network.clearWebViewCache import com.flowfoundation.wallet.network.model.UserInfoData +import com.flowfoundation.wallet.page.dialog.common.AddNewAccountDialog import com.flowfoundation.wallet.page.dialog.profile.ProfileSwitchDialog import com.flowfoundation.wallet.page.evm.EnableEVMActivity import com.flowfoundation.wallet.page.main.MainActivity @@ -119,6 +120,7 @@ fun DrawerLayoutCompose(drawer: DrawerLayout) { val balanceMap by viewModel.balanceMap.collectAsStateWithLifecycle() val isAddingAccount by viewModel.isAddingAccount.collectAsStateWithLifecycle() val canAddAccount by viewModel.canAddAccount.collectAsStateWithLifecycle() + val canAddEOAAccount by viewModel.canAddEOAAccount.collectAsStateWithLifecycle() LaunchedEffect(Unit) { viewModel.loadData() @@ -213,8 +215,16 @@ fun DrawerLayoutCompose(drawer: DrawerLayout) { onImportWalletClick = { WalletRestoreActivity.launch(activity) }, - onAddAccountClick = { viewModel.addAccount() }, - canAddAccount = canAddAccount + onAddAccountClick = { + AddNewAccountDialog.show( + activity.supportFragmentManager, + canAddCadence = canAddAccount, + canAddEOA = canAddEOAAccount, + onCadence = { viewModel.addCadenceAccount() }, + onEOA = { viewModel.addEOAAccount() } + ) + }, + canAddAccount = canAddAccount || canAddEOAAccount ) } } diff --git a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/WalletBridgeHandler.kt b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/WalletBridgeHandler.kt index 14ee004e..60fe6f8b 100644 --- a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/WalletBridgeHandler.kt +++ b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/WalletBridgeHandler.kt @@ -49,7 +49,8 @@ class WalletBridgeHandler(private val reactContext: ReactApplicationContext) { ioScope { try { logd(TAG, "ethSign() called with hexData: $hexData") - val signature = WalletManager.wallet()?.ethSignDigest(hexData?.hexToBytes() ?: throw IllegalArgumentException("hexData is null")) + val eoaIndex = WalletManager.getSelectedEOAIndex() + val signature = WalletManager.wallet()?.ethSignDigest(hexData?.hexToBytes() ?: throw IllegalArgumentException("hexData is null"), index = eoaIndex) if (signature != null && signature.isNotEmpty()) { val result = Numeric.toHexString(signature) logd(TAG, "ethSign() - signature $result") diff --git a/app/src/main/java/com/flowfoundation/wallet/widgets/webview/evm/EvmInterface.kt b/app/src/main/java/com/flowfoundation/wallet/widgets/webview/evm/EvmInterface.kt index 6628d54a..da1fe7bb 100644 --- a/app/src/main/java/com/flowfoundation/wallet/widgets/webview/evm/EvmInterface.kt +++ b/app/src/main/java/com/flowfoundation/wallet/widgets/webview/evm/EvmInterface.kt @@ -283,7 +283,8 @@ class EvmInterface( val signature = if (EVMWalletManager.isEVMWalletAddress(fromAddress)) { signEthereumMessage(signMessage) } else { - val result = WalletManager.wallet()?.ethSignPersonalMessage(data) + val eoaIndex = WalletManager.getSelectedEOAIndex() + val result = WalletManager.wallet()?.ethSignPersonalMessage(data, index = eoaIndex) Numeric.toHexString(result) } webView.sendResult(network, signature, id) @@ -310,7 +311,8 @@ class EvmInterface( val signature = if (EVMWalletManager.isEVMWalletAddress(fromAddress)) { signTypedData(data) } else { - val result = WalletManager.wallet()?.ethSignTypedData(raw) + val eoaIndex = WalletManager.getSelectedEOAIndex() + val result = WalletManager.wallet()?.ethSignTypedData(raw, index = eoaIndex) Numeric.toHexString(result) } webView.sendResult(network, signature, id) diff --git a/app/src/main/res/drawable/ic_add_cadence_account.xml b/app/src/main/res/drawable/ic_add_cadence_account.xml new file mode 100644 index 00000000..23997f14 --- /dev/null +++ b/app/src/main/res/drawable/ic_add_cadence_account.xml @@ -0,0 +1,14 @@ + + + diff --git a/app/src/main/res/drawable/ic_add_eoa_account.xml b/app/src/main/res/drawable/ic_add_eoa_account.xml new file mode 100644 index 00000000..c94851b5 --- /dev/null +++ b/app/src/main/res/drawable/ic_add_eoa_account.xml @@ -0,0 +1,14 @@ + + + diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 8be83dc3..02db1dd1 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -189,6 +189,8 @@ Hold to Send The transaction is processing Something went wrong, please try again later. + Create a new Flow Cadence account + Create a new Flow EVM account Pending Success Failed From 5564bdfba3b6d0286bb4f680ed359d2eca21027e Mon Sep 17 00:00:00 2001 From: Meng Date: Wed, 18 Mar 2026 17:56:57 +0800 Subject: [PATCH 18/27] feat: add inbox feature flag --- .../com/flowfoundation/wallet/manager/config/AppConfig.kt | 7 +++++-- .../flowfoundation/wallet/manager/inbox/InboxManager.kt | 4 ++++ .../wallet/reactnative/bridge/BridgeModels.kt | 5 ++++- .../reactnative/bridge/handlers/UtilsBridgeHandler.kt | 4 +++- 4 files changed, 16 insertions(+), 4 deletions(-) diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/config/AppConfig.kt b/app/src/main/java/com/flowfoundation/wallet/manager/config/AppConfig.kt index 9dbc6729..2661d3e0 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/config/AppConfig.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/config/AppConfig.kt @@ -56,6 +56,8 @@ object AppConfig { fun canCreateNewAccount() = isDev() || isTesting() || (config().getFeatures().createNewAccount ?: false) + fun canClaimInbox() = isDev() || isTesting() || (config().getFeatures().cadenceInbox ?: false) + fun addressRegistry(network: Int): Map { return when (network) { NETWORK_TESTNET -> flowAddressRegistry().testnet @@ -231,9 +233,10 @@ private data class Features( val bloctoKeyRotation: Boolean?, @SerializedName("coa_migration") val coaMigration: Boolean?, - @SerializedName("create_new_account") - val createNewAccount: Boolean? + val createNewAccount: Boolean?, + @SerializedName("cadence_inbox") + val cadenceInbox: Boolean? ) private data class Payer( diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/inbox/InboxManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/inbox/InboxManager.kt index 62b478ad..760e1f1a 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/inbox/InboxManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/inbox/InboxManager.kt @@ -1,5 +1,6 @@ package com.flowfoundation.wallet.manager.inbox +import com.flowfoundation.wallet.manager.config.AppConfig import com.flowfoundation.wallet.manager.flowjvm.cadenceQueryInboxUnclaimedNumber import com.flowfoundation.wallet.manager.notification.WalletNotificationManager import com.flowfoundation.wallet.manager.wallet.WalletManager @@ -26,6 +27,9 @@ object InboxManager { private var inboxNotification: WalletNotification? = null fun refresh() { + if (AppConfig.canClaimInbox().not()) { + return + } ioScope { if (WalletManager.isChildAccountSelected() || WalletManager.isEVMAccountSelected()) { updateCount(0) diff --git a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/BridgeModels.kt b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/BridgeModels.kt index e7d11596..96de0d79 100644 --- a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/BridgeModels.kt +++ b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/BridgeModels.kt @@ -26,6 +26,7 @@ class RNBridge { @SerializedName("activity") ACTIVITY, @SerializedName("keystore-migration") KEYSTORE_MIGRATION, @SerializedName("migration") MIGRATION, + @SerializedName("whatsNew") WHATSNEW, @SerializedName("claimTokens") CLAIMTOKENS } @@ -171,7 +172,9 @@ class RNBridge { @SerializedName("INSTABUG_TOKEN") val INSTABUG_TOKEN: String, @SerializedName("MIXPANEL_TOKEN") - val MIXPANEL_TOKEN: String? + val MIXPANEL_TOKEN: String?, + @SerializedName("CADENCE_INBOX") + val CADENCE_INBOX: Boolean ) data class Currency( diff --git a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/UtilsBridgeHandler.kt b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/UtilsBridgeHandler.kt index 78d2c350..a9e9ce42 100644 --- a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/UtilsBridgeHandler.kt +++ b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/UtilsBridgeHandler.kt @@ -23,6 +23,7 @@ import com.flowfoundation.wallet.utils.loge import com.flowfoundation.wallet.utils.logw import com.flowfoundation.wallet.utils.uiScope import com.flowfoundation.wallet.manager.account.DeviceInfoManager +import com.flowfoundation.wallet.manager.config.AppConfig import java.util.Locale /** @@ -93,7 +94,8 @@ class UtilsBridgeHandler(private val reactContext: ReactApplicationContext) { BuildConfig.MIXPANEL_TOKEN_DEV } else { BuildConfig.MIXPANEL_TOKEN_PROD - } + }, + CADENCE_INBOX = AppConfig.canClaimInbox() ) return bridgeModelToWritableMap(environmentVariables) From 92a553647b98d2e6d608b0c2283294e9f437d5ab Mon Sep 17 00:00:00 2001 From: Meng Date: Thu, 19 Mar 2026 16:07:56 +0800 Subject: [PATCH 19/27] fix: eoa address management --- .../wallet/instabug/InstabugUtils.kt | 2 +- .../wallet/manager/evm/EVMWalletManager.kt | 6 +- .../wallet/manager/evm/Utils.kt | 2 +- .../wallet/manager/wallet/WalletManager.kt | 16 +++- .../mnemonic/WalletCreateMnemonicViewModel.kt | 92 ------------------- .../reactnative/bridge/NativeFRWBridge.kt | 8 +- .../bridge/handlers/AccountBridgeHandler.kt | 36 +++++--- gradle.properties | 2 +- 8 files changed, 51 insertions(+), 113 deletions(-) delete mode 100644 app/src/main/java/com/flowfoundation/wallet/page/walletcreate/fragments/mnemonic/WalletCreateMnemonicViewModel.kt diff --git a/app/src/main/java/com/flowfoundation/wallet/instabug/InstabugUtils.kt b/app/src/main/java/com/flowfoundation/wallet/instabug/InstabugUtils.kt index 8df9aae9..f66036b5 100644 --- a/app/src/main/java/com/flowfoundation/wallet/instabug/InstabugUtils.kt +++ b/app/src/main/java/com/flowfoundation/wallet/instabug/InstabugUtils.kt @@ -68,7 +68,7 @@ fun instabugInitialize(application: Application) { childAccounts.toString() ) report.setUserAttribute("COA", EVMWalletManager.getEVMAddress().orEmpty()) - report.setUserAttribute("EOA", WalletManager.getEOAAddress().orEmpty()) + report.setUserAttribute("EOA", WalletManager.getEOAAddresses().toString()) report.setUserAttribute("Network", chainNetWorkString()) } val configuration = ProactiveReportingConfigs.Builder() diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/evm/EVMWalletManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/evm/EVMWalletManager.kt index e6532c1e..79ddc0da 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/evm/EVMWalletManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/evm/EVMWalletManager.kt @@ -1,6 +1,7 @@ package com.flowfoundation.wallet.manager.evm import com.flowfoundation.wallet.manager.account.AccountManager +import com.flowfoundation.wallet.manager.walletdata.EOAWallet import com.flowfoundation.wallet.manager.flowjvm.CadenceScript import com.flowfoundation.wallet.manager.flowjvm.cadenceBridgeChildFTFromCOA import com.flowfoundation.wallet.manager.flowjvm.cadenceBridgeChildFTToCOA @@ -119,7 +120,10 @@ object EVMWalletManager { } fun isEOAAddress(address: String): Boolean { - val result = address.equals(WalletManager.getEOAAddress(), ignoreCase = true) + val result = AccountManager.walletNodes() + ?.filterIsInstance() + ?.any { it.address.equals(address, ignoreCase = true) } + ?: false logd(TAG, "isEOAAddress result: $result") return result } diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/evm/Utils.kt b/app/src/main/java/com/flowfoundation/wallet/manager/evm/Utils.kt index e3cfc3bc..c12ee801 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/evm/Utils.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/evm/Utils.kt @@ -72,7 +72,7 @@ suspend fun loadInitJS(): String { } } - WalletManager.getEOAAddress()?.let { eoaAddress -> + WalletManager.getEOAAddresses().forEach { eoaAddress -> if (eoaAddress.isNotEmpty()) { addressList.add(eoaAddress) } diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletManager.kt index c61cc1d2..d6b35ead 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletManager.kt @@ -40,7 +40,7 @@ object WalletManager { fun canDeriveEoa() = _canDeriveEoa /** - * Get EOA address + * Get the first EOA address (for backward compatibility / single-address scenarios) */ fun getEOAAddress(): String? { val eoaWallet = AccountManager.walletNodes() @@ -55,6 +55,16 @@ object WalletManager { return null } + /** + * Get all EOA addresses + */ + fun getEOAAddresses(): List { + return AccountManager.walletNodes() + ?.filterIsInstance() + ?.map { it.address } + ?: emptyList() + } + /** * Get the BIP44 derivation index for the currently selected EOA wallet. * Returns 0 if no EOA is selected or found. @@ -155,7 +165,9 @@ object WalletManager { } fun isEVMAccountSelected(): Boolean { - return selectedWalletAddress().toAddress().equals(EVMWalletManager.getEVMAddress()?.toAddress(), ignoreCase = true) || selectedWalletAddress().toAddress().equals(getEOAAddress(), ignoreCase = true) + val selected = selectedWalletAddress().toAddress() + return selected.equals(EVMWalletManager.getEVMAddress()?.toAddress(), ignoreCase = true) + || EVMWalletManager.isEOAAddress(selected) } fun isSelfFlowAddress(address: String): Boolean { diff --git a/app/src/main/java/com/flowfoundation/wallet/page/walletcreate/fragments/mnemonic/WalletCreateMnemonicViewModel.kt b/app/src/main/java/com/flowfoundation/wallet/page/walletcreate/fragments/mnemonic/WalletCreateMnemonicViewModel.kt deleted file mode 100644 index 875b96ba..00000000 --- a/app/src/main/java/com/flowfoundation/wallet/page/walletcreate/fragments/mnemonic/WalletCreateMnemonicViewModel.kt +++ /dev/null @@ -1,92 +0,0 @@ -package com.flowfoundation.wallet.page.walletcreate.fragments.mnemonic - -import androidx.lifecycle.MutableLiveData -import androidx.lifecycle.ViewModel -import com.flowfoundation.wallet.utils.viewModelIOScope -import com.flow.wallet.crypto.BIP39 -import com.flow.wallet.keys.SeedPhraseKey -import com.flowfoundation.wallet.manager.wallet.WalletManager -import com.flowfoundation.wallet.utils.Env.getStorage -import com.flowfoundation.wallet.wallet.DERIVATION_PATH -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.withContext - - -class WalletCreateMnemonicViewModel : ViewModel() { - - val mnemonicList = MutableLiveData>() - private var currentMnemonic: String? = null - - fun loadMnemonic() { - viewModelIOScope(this) { - // Generate a new mnemonic using BIP39 - val mnemonic = BIP39.generate(BIP39.SeedPhraseLength.TWELVE) - currentMnemonic = mnemonic - - withContext(Dispatchers.Main) { - val list = mnemonic.split(" ").mapIndexed { index, s -> MnemonicModel(index + 1, s) } - val result = mutableListOf() - (0 until list.size / 2).forEach { i -> - result.add(list[i]) - result.add(list[i + list.size / 2]) - } - mnemonicList.value = result - } - } - } - - fun getMnemonic(): String { - return currentMnemonic ?: throw IllegalStateException("Mnemonic not generated yet") - } - - @OptIn(ExperimentalStdlibApi::class) - fun createWallet() { - viewModelIOScope(this) { - val mnemonic = getMnemonic() - val seedPhraseKey = SeedPhraseKey( - mnemonicString = mnemonic, - passphrase = "", - derivationPath = DERIVATION_PATH, - storage = getStorage() - ) - - // Create keystore info for the account - val privateKeyHex = seedPhraseKey.privateKey(org.onflow.flow.models.SigningAlgorithm.ECDSA_P256)?.toHexString() ?: "" - val publicKeyHex = seedPhraseKey.publicKey(org.onflow.flow.models.SigningAlgorithm.ECDSA_P256)?.toHexString()?.removePrefix("04") ?: "" - val walletAddress = WalletManager.getCurrentFlowWalletAddress() ?: "" - - // Create keystore address info - val keystoreAddress = com.flowfoundation.wallet.page.restore.keystore.model.KeystoreAddress( - address = walletAddress, - publicKey = publicKeyHex, - privateKey = privateKeyHex, - keyId = 0, - weight = 1000, - hashAlgo = org.onflow.flow.models.HashingAlgorithm.SHA2_256.cadenceIndex, - signAlgo = org.onflow.flow.models.SigningAlgorithm.ECDSA_P256.cadenceIndex - ) - - // Create user info for local wallet - val userInfo = com.flowfoundation.wallet.network.model.UserInfoData( - nickname = "Local User", - username = "local_${System.currentTimeMillis()}", - avatar = "", - address = walletAddress, - isPrivate = 0, - created = java.time.Instant.now().toString() - ) - - // Create and add account to AccountManager with keystore info - val account = com.flowfoundation.wallet.manager.account.Account( - userInfo = userInfo, - keyStoreInfo = com.google.gson.Gson().toJson(keystoreAddress) - ) - - com.flowfoundation.wallet.manager.account.AccountManager.add(account) - - // Mark as registered immediately after wallet creation (like server registration) - // This allows users to proceed even if they exit backup early - com.flowfoundation.wallet.utils.setRegistered() - } - } -} diff --git a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/NativeFRWBridge.kt b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/NativeFRWBridge.kt index e3a5fac2..a0a8c823 100644 --- a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/NativeFRWBridge.kt +++ b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/NativeFRWBridge.kt @@ -443,7 +443,13 @@ class NativeFRWBridge(reactContext: ReactApplicationContext) : NativeFRWBridgeSp override fun closeRN(id: String?) = uiHandler.closeRN(id) - override fun closeRNWithNFT(id: String?) {} + override fun onUpdateDialogActionPress( + actionType: String?, + actionUrl: String?, + actionText: String? + ) {} + + override fun closeRNWithNFT(id: String?) {} override fun getSignKeyIndex(): Double = accountHandler.getSignKeyIndex() diff --git a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/AccountBridgeHandler.kt b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/AccountBridgeHandler.kt index de8b07f4..aabe25db 100644 --- a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/AccountBridgeHandler.kt +++ b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/AccountBridgeHandler.kt @@ -15,6 +15,7 @@ import com.flowfoundation.wallet.manager.wallet.WalletManager import com.flowfoundation.wallet.manager.walletdata.FlowWallet import com.flowfoundation.wallet.manager.walletdata.COAWallet import com.flowfoundation.wallet.manager.walletdata.ChildWallet +import com.flowfoundation.wallet.manager.walletdata.EOAWallet import com.flowfoundation.wallet.reactnative.bridge.RNBridge import com.flowfoundation.wallet.reactnative.bridge.createEmojiInfo import com.flowfoundation.wallet.reactnative.bridge.isSelectedWalletAddress @@ -210,15 +211,17 @@ class AccountBridgeHandler(private val reactContext: ReactApplicationContext) { println("EVM account not available: ${e.message}") } - // Get EOA address only if it's different from EVM address + // Get EOA addresses only if they're different from EVM address // For Secure Type (COA) accounts, EOA and EVM addresses are the same, // so we should only show the EVM account to avoid duplicate "EOA" chip try { - val eoaAddress = WalletManager.getEOAAddress() - if (!eoaAddress.isNullOrEmpty()) { - // Only add EOA account if it's different from EVM address - // Secure Type accounts have a prefix field, Recovery Phrase accounts don't - val isSecureTypeAccount = !currentAccount?.prefix.isNullOrBlank() + val isSecureTypeAccount = !currentAccount?.prefix.isNullOrBlank() + val eoaWallets = AccountManager.walletNodes() + ?.filterIsInstance() ?: emptyList() + + for (eoaWallet in eoaWallets) { + val eoaAddress = eoaWallet.address + if (eoaAddress.isEmpty()) continue // Only add EOA if: // 1. EOA address is different from EVM address, AND @@ -229,7 +232,7 @@ class AccountBridgeHandler(private val reactContext: ReactApplicationContext) { if (isDifferentFromEVM && !isSecureTypeAccount) { val eoaEmojiInfo = createEmojiInfo(eoaAddress) val eoaAccount = RNBridge.WalletAccount( - id = "eoa", + id = "eoa_${eoaAddress}", name = eoaEmojiInfo?.name ?: "EOA Account", address = eoaAddress, parentAddress = mainAddress, @@ -245,8 +248,8 @@ class AccountBridgeHandler(private val reactContext: ReactApplicationContext) { } } } catch (e: Exception) { - // EOA account might not be available, continue without it - println("EOA account not available: ${e.message}") + // EOA accounts might not be available, continue without them + println("EOA accounts not available: ${e.message}") } val response = RNBridge.WalletAccountsResponse(accounts = bridgeAccounts) @@ -475,15 +478,20 @@ class AccountBridgeHandler(private val reactContext: ReactApplicationContext) { } } - // Add EOA address only for currently selected wallet + // Add EOA addresses only for currently selected wallet val mainAddress = flowWallets.firstOrNull()?.address if (mainAddress != null && isSelectedWalletAddress(mainAddress)) { try { - val eoaAddress = WalletManager.getEOAAddress() - if (!eoaAddress.isNullOrEmpty()) { + val eoaWallets = AccountManager.walletNodes() + ?.filterIsInstance() ?: emptyList() + + for (eoaWallet in eoaWallets) { + val eoaAddress = eoaWallet.address + if (eoaAddress.isEmpty()) continue + val eoaEmojiInfo = createEmojiInfo(eoaAddress) val eoaAccount = RNBridge.WalletAccount( - id = "eoa", + id = "eoa_${eoaAddress}", name = eoaEmojiInfo?.name ?: "EVM Account (EOA)", address = eoaAddress, parentAddress = mainAddress, @@ -498,7 +506,7 @@ class AccountBridgeHandler(private val reactContext: ReactApplicationContext) { bridgeAccounts.add(eoaAccount) } } catch (e: Exception) { - logw(TAG, "createWalletProfileFromAccount() - EOA account not available: ${e.message}") + logw(TAG, "createWalletProfileFromAccount() - EOA accounts not available: ${e.message}") } } diff --git a/gradle.properties b/gradle.properties index c7b15042..94d3747b 100644 --- a/gradle.properties +++ b/gradle.properties @@ -64,7 +64,7 @@ android.r8.dexing.parallel=true #android.bundle.enableUncompressedNativeLibs=false #android.experimental.enableArtProfiles=true -vCode=400000465 +vCode=400000531 vName=r3.1.0 # --- GitHub Packages (Flow Wallet Kit) --- From c4d8215ea9f80d61a4aae4f2926626671b3b943a Mon Sep 17 00:00:00 2001 From: Meng Date: Thu, 19 Mar 2026 16:12:17 +0800 Subject: [PATCH 20/27] fix: add new account dialog ui --- .../wallet/page/dialog/common/AddNewAccountDialog.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/app/src/main/java/com/flowfoundation/wallet/page/dialog/common/AddNewAccountDialog.kt b/app/src/main/java/com/flowfoundation/wallet/page/dialog/common/AddNewAccountDialog.kt index ebe53142..6469ff05 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/dialog/common/AddNewAccountDialog.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/dialog/common/AddNewAccountDialog.kt @@ -107,7 +107,7 @@ private fun AddNewAccountContent( .fillMaxWidth() .background( color = colorResource(id = R.color.bg_card), - shape = RoundedCornerShape(topStart = 16.dp, topEnd = 16.dp) + shape = RoundedCornerShape(16.dp) ) .padding(horizontal = 18.dp) ) { From 9a992733455b7b73761687ff100a1a1bab87a8e2 Mon Sep 17 00:00:00 2001 From: Meng Date: Fri, 20 Mar 2026 09:01:01 +0800 Subject: [PATCH 21/27] fix: multi flow wallet address check --- .../wallet/manager/wallet/WalletManager.kt | 17 ++++++++--------- .../page/main/presenter/DrawerLayoutContent.kt | 4 +++- gradle.properties | 2 +- 3 files changed, 12 insertions(+), 11 deletions(-) diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletManager.kt index d6b35ead..9e17216e 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletManager.kt @@ -148,15 +148,14 @@ object WalletManager { selectedWalletAddressRef.set(currentNetworkFlowWallet.address) updateSelectedWalletAddress(currentNetworkFlowWallet.address) } else { - // Check if currentSelected is a Flow Main account but NOT the one for the current network - val isSelectedFlowMain = walletNodes.filterIsInstance() - .any { it.address.equals(currentSelected, ignoreCase = true) } - - if (isSelectedFlowMain) { - if (!currentNetworkFlowWallet.address.equals(currentSelected, ignoreCase = true)) { - selectedWalletAddressRef.set(currentNetworkFlowWallet.address) - updateSelectedWalletAddress(currentNetworkFlowWallet.address) - } + // Check if currentSelected is a Flow Main account on a different network + val selectedFlowWallet = walletNodes.filterIsInstance() + .firstOrNull { it.address.equals(currentSelected, ignoreCase = true) } + + if (selectedFlowWallet != null && !selectedFlowWallet.chainIdString.equals(currentNetwork, ignoreCase = true)) { + logd(TAG, "Selected FlowWallet is on a different network (${selectedFlowWallet.chainIdString} vs $currentNetwork), switching to current network account: ${currentNetworkFlowWallet.address}") + selectedWalletAddressRef.set(currentNetworkFlowWallet.address) + updateSelectedWalletAddress(currentNetworkFlowWallet.address) } } } diff --git a/app/src/main/java/com/flowfoundation/wallet/page/main/presenter/DrawerLayoutContent.kt b/app/src/main/java/com/flowfoundation/wallet/page/main/presenter/DrawerLayoutContent.kt index 3c095d5f..d7c405d8 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/main/presenter/DrawerLayoutContent.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/main/presenter/DrawerLayoutContent.kt @@ -185,7 +185,8 @@ fun DrawerLayoutCompose(drawer: DrawerLayout) { toast(msgRes = R.string.copy_address_toast) }, onAccountClick = { address -> - FlowLoadingDialog(context).show() + val loadingDialog = FlowLoadingDialog(context) + loadingDialog.show() WalletManager.selectWalletAddress(address) ioScope { delay(200) @@ -200,6 +201,7 @@ fun DrawerLayoutCompose(drawer: DrawerLayout) { CryptoProviderManager.clear() delay(1000) uiScope { + loadingDialog.dismiss() MainActivity.relaunch(Env.getApp()) } } diff --git a/gradle.properties b/gradle.properties index 94d3747b..6c0dc2e6 100644 --- a/gradle.properties +++ b/gradle.properties @@ -64,7 +64,7 @@ android.r8.dexing.parallel=true #android.bundle.enableUncompressedNativeLibs=false #android.experimental.enableArtProfiles=true -vCode=400000531 +vCode=400000537 vName=r3.1.0 # --- GitHub Packages (Flow Wallet Kit) --- From 8cb31567b98412107e0603f4fa22de202e2fb0bd Mon Sep 17 00:00:00 2001 From: Meng Date: Fri, 20 Mar 2026 14:20:31 +0800 Subject: [PATCH 22/27] fix: eoa sign message with index --- .../manager/evm/DAppEVMConnectionManager.kt | 9 +++++++-- .../flowfoundation/wallet/manager/evm/Utils.kt | 4 ++-- .../wallet/manager/wallet/WalletManager.kt | 12 ++++++++++++ .../wallet/manager/walletconnect/Utils.kt | 18 +++++++++++++++--- .../WalletConnectRequestDispatcher.kt | 5 +++-- .../wallet/widgets/webview/evm/EvmInterface.kt | 6 +++--- 6 files changed, 42 insertions(+), 12 deletions(-) diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/evm/DAppEVMConnectionManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/evm/DAppEVMConnectionManager.kt index ce3b1920..2f759c9a 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/evm/DAppEVMConnectionManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/evm/DAppEVMConnectionManager.kt @@ -120,8 +120,13 @@ object DAppEVMConnectionManager { _availableAccounts.value = accounts logd(TAG, "Loaded ${accounts.size} available accounts") - // Set default selected account if none is selected - if (_selectedAccount.value == null && accounts.isNotEmpty()) { + // Sync with main wallet's selected address if it matches an available account + val walletSelected = WalletManager.selectedWalletAddress() + val matchingAccount = accounts.firstOrNull { it.address.equals(walletSelected, ignoreCase = true) } + if (matchingAccount != null) { + logd(TAG, "Syncing DApp selection with main wallet address: ${matchingAccount.address} (${matchingAccount.type})") + setSelectedAccount(matchingAccount) + } else if (_selectedAccount.value == null && accounts.isNotEmpty()) { // Default to COA account, fallback to first available val defaultAccount = accounts.find { it.type == DAppEVMAccountType.COA } ?: accounts.first() setSelectedAccount(defaultAccount) diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/evm/Utils.kt b/app/src/main/java/com/flowfoundation/wallet/manager/evm/Utils.kt index c12ee801..aa2b2c0d 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/evm/Utils.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/evm/Utils.kt @@ -257,7 +257,7 @@ Unit) { return@ioScope } val singer = cryptoProvider.getSigner(HashingAlgorithm.SHA2_256) - val eoaIndex = WalletManager.getSelectedEOAIndex() + val eoaIndex = WalletManager.getEOAIndexForAddress(address) val result = WalletManager.wallet()?.ethSignTransactionAndSendByCadence( input = input, fromAddress = address, @@ -277,7 +277,7 @@ Unit) { callback.invoke(txHash) } else { - val eoaIndex = WalletManager.getSelectedEOAIndex() + val eoaIndex = WalletManager.getEOAIndexForAddress(address) val output = WalletManager.wallet()?.ethSignTransaction(input, index = eoaIndex) if (output == null) { diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletManager.kt index 9e17216e..4bf3e98b 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/wallet/WalletManager.kt @@ -77,6 +77,18 @@ object WalletManager { ?.index ?: 0 } + /** + * Get the BIP44 derivation index for a specific EOA address. + * Use this in DApp contexts where the signing address may differ from the globally selected one. + * Returns 0 if the address is not found among EOA wallets. + */ + fun getEOAIndexForAddress(address: String): Int { + return AccountManager.walletNodes() + ?.filterIsInstance() + ?.firstOrNull { it.address.equals(address, ignoreCase = true) } + ?.index ?: 0 + } + private fun initializeWallet(): Boolean { logd(TAG, "initializeWallet() called") diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/walletconnect/Utils.kt b/app/src/main/java/com/flowfoundation/wallet/manager/walletconnect/Utils.kt index 569785e9..ff2564c8 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/walletconnect/Utils.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/walletconnect/Utils.kt @@ -26,9 +26,21 @@ fun Sign.Model.SessionProposal.approveSession() { namespaces.putAll(requiredNamespaces.map { item -> pair(item) }.toMap()) - namespaces.putAll(optionalNamespaces.map { item -> - pair(item) - }.toMap()) + // Merge optional namespaces instead of overwriting required ones + optionalNamespaces.forEach { item -> + val (key, session) = pair(item) + val existing = namespaces[key] + if (existing != null) { + namespaces[key] = Sign.Model.Namespace.Session( + chains = ((existing.chains.orEmpty()) + (session.chains.orEmpty())).distinct(), + accounts = ((existing.accounts) + (session.accounts)).distinct(), + methods = ((existing.methods) + (session.methods)).distinct(), + events = ((existing.events) + (session.events)).distinct() + ) + } else { + namespaces[key] = session + } + } logd(TAG, "approveSession: $namespaces") diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/walletconnect/WalletConnectRequestDispatcher.kt b/app/src/main/java/com/flowfoundation/wallet/manager/walletconnect/WalletConnectRequestDispatcher.kt index 50937320..bd6e55fc 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/walletconnect/WalletConnectRequestDispatcher.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/walletconnect/WalletConnectRequestDispatcher.kt @@ -188,7 +188,8 @@ suspend fun WCRequest.evmSignTypedData() { EVMSignTypedDataDialog.observe { isApprove -> ioScope { val result = if (DAppEVMConnectionManager.isCurrentEOAAccount()) { - val eoaIndex = WalletManager.getSelectedEOAIndex() + val currentAddress = DAppEVMConnectionManager.getCurrentAccount()?.address.orEmpty() + val eoaIndex = WalletManager.getEOAIndexForAddress(currentAddress) val data = WalletManager.wallet()?.ethSignTypedData(message, index = eoaIndex) Numeric.toHexString(data) } else { @@ -291,7 +292,7 @@ private suspend fun WCRequest.evmSignMessage() { val result = if (EVMWalletManager.isEVMWalletAddress(fromAddress)) { signEthereumMessage(message) } else { - val eoaIndex = WalletManager.getSelectedEOAIndex() + val eoaIndex = WalletManager.getEOAIndexForAddress(fromAddress) val data = WalletManager.wallet()?.ethSignPersonalMessage(hexMessage.hexToBytes(), index = eoaIndex) Numeric.toHexString(data) } diff --git a/app/src/main/java/com/flowfoundation/wallet/widgets/webview/evm/EvmInterface.kt b/app/src/main/java/com/flowfoundation/wallet/widgets/webview/evm/EvmInterface.kt index da1fe7bb..057019cb 100644 --- a/app/src/main/java/com/flowfoundation/wallet/widgets/webview/evm/EvmInterface.kt +++ b/app/src/main/java/com/flowfoundation/wallet/widgets/webview/evm/EvmInterface.kt @@ -73,7 +73,7 @@ class EvmInterface( return } uiScope { - if (EVMWalletManager.haveEVMAddress()) { + if (EVMWalletManager.haveEVMAddress() || WalletManager.getEOAAddresses().isNotEmpty()) { val connect = EvmRequestAccountDialog().show( activity.supportFragmentManager, EVMDialogModel( @@ -283,7 +283,7 @@ class EvmInterface( val signature = if (EVMWalletManager.isEVMWalletAddress(fromAddress)) { signEthereumMessage(signMessage) } else { - val eoaIndex = WalletManager.getSelectedEOAIndex() + val eoaIndex = WalletManager.getEOAIndexForAddress(fromAddress) val result = WalletManager.wallet()?.ethSignPersonalMessage(data, index = eoaIndex) Numeric.toHexString(result) } @@ -311,7 +311,7 @@ class EvmInterface( val signature = if (EVMWalletManager.isEVMWalletAddress(fromAddress)) { signTypedData(data) } else { - val eoaIndex = WalletManager.getSelectedEOAIndex() + val eoaIndex = WalletManager.getEOAIndexForAddress(fromAddress) val result = WalletManager.wallet()?.ethSignTypedData(raw, index = eoaIndex) Numeric.toHexString(result) } From 6faf0cec8adf7f05fe1fb899ddb40414ff7ba22c Mon Sep 17 00:00:00 2001 From: Meng Date: Sat, 21 Mar 2026 01:02:16 +0800 Subject: [PATCH 23/27] fix: coa wallet display and emoji cache --- app/src/main/assets/config/cadence_api.json | 996 +++++++++--------- .../wallet/manager/account/AccountManager.kt | 3 + .../manager/emoji/AccountEmojiManager.kt | 34 +- .../wallet/manager/evm/COAVisibilityCache.kt | 40 + .../wallet/manager/evm/EVMWalletManager.kt | 2 +- .../wallet/manager/evm/Utils.kt | 7 +- .../manager/walletdata/WalletDataManager.kt | 128 ++- .../wallet/network/UserRegisterUtils.kt | 2 + .../page/account/AccountListViewModel.kt | 80 +- .../page/dialog/common/AddNewAccountDialog.kt | 2 +- .../dialog/profile/ProfileSwitchDialog.kt | 2 +- .../page/main/drawer/DrawerLayoutViewModel.kt | 78 +- .../layout/dialog_add_collection_confirm.xml | 2 +- .../res/layout/dialog_add_token_confirm.xml | 2 +- .../layout/dialog_add_token_processing.xml | 2 +- .../res/layout/dialog_evm_request_account.xml | 2 +- app/src/main/res/layout/dialog_fcl_authn.xml | 2 +- app/src/main/res/layout/dialog_fcl_authz.xml | 2 +- .../res/layout/dialog_fcl_sign_message.xml | 2 +- .../res/layout/dialog_fcl_wrong_network.xml | 2 +- .../main/res/layout/dialog_link_account.xml | 2 +- .../layout/dialog_reset_wallet_confirm.xml | 6 +- .../main/res/layout/dialog_root_detected.xml | 2 +- .../main/res/layout/dialog_select_account.xml | 2 +- .../res/layout/dialog_swap_token_confirm.xml | 2 +- .../layout/dialog_unlink_child_account.xml | 4 +- .../res/layout/dialog_wallet_confirmation.xml | 2 +- .../main/res/layout/fragment_evm_account.xml | 2 +- .../layout/fragment_evm_select_account.xml | 2 +- app/src/main/res/layout/item_explore_dapp.xml | 5 +- app/src/main/res/values-night/colors.xml | 1 + app/src/main/res/values/colors.xml | 1 + 32 files changed, 765 insertions(+), 656 deletions(-) create mode 100644 app/src/main/java/com/flowfoundation/wallet/manager/evm/COAVisibilityCache.kt diff --git a/app/src/main/assets/config/cadence_api.json b/app/src/main/assets/config/cadence_api.json index b43d20ab..ddcf9b85 100644 --- a/app/src/main/assets/config/cadence_api.json +++ b/app/src/main/assets/config/cadence_api.json @@ -2,30 +2,265 @@ "data": { "scripts": { "mainnet": { - "version": "1.0", + "basic": { + "accountStorage": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYWNjb3VudFN0b3JhZ2UgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCiBhY2Nlc3MoYWxsKSBzdHJ1Y3QgU3RvcmFnZUluZm8gewogICAgYWNjZXNzKGFsbCkgIGxldCBjYXBhY2l0eTogVUludDY0CiAgICBhY2Nlc3MoYWxsKSAgbGV0IHVzZWQ6IFVJbnQ2NAogICAgYWNjZXNzKGFsbCkgIGxldCBhdmFpbGFibGU6IFVJbnQ2NAoKICAgIGluaXQoY2FwYWNpdHk6IFVJbnQ2NCwgdXNlZDogVUludDY0LCBhdmFpbGFibGU6IFVJbnQ2NCkgewogICAgICAgIHNlbGYuY2FwYWNpdHkgPSBjYXBhY2l0eQogICAgICAgIHNlbGYudXNlZCA9IHVzZWQKICAgICAgICBzZWxmLmF2YWlsYWJsZSA9IGF2YWlsYWJsZQogICAgfQp9CgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyOiBBZGRyZXNzKTogU3RvcmFnZUluZm8gewogICAgbGV0IGFjY3QgPSBnZXRBY2NvdW50KGFkZHIpCiAgICB2YXIgYXZhaWxhYmxlOiBVSW50NjQgPSAwCiAgICBpZiBhY2N0LnN0b3JhZ2UuY2FwYWNpdHkgPiAwIHsKICAgICAgICBhdmFpbGFibGUgPSBhY2N0LnN0b3JhZ2UuY2FwYWNpdHkgLSBhY2N0LnN0b3JhZ2UudXNlZAogICAgfQogICAgcmV0dXJuIFN0b3JhZ2VJbmZvKGNhcGFjaXR5OiBhY2N0LnN0b3JhZ2UuY2FwYWNpdHksCiAgICAgICAgICAgIHVzZWQ6IGFjY3Quc3RvcmFnZS51c2VkLAogICAgICAgICAgICBhdmFpbGFibGU6IGF2YWlsYWJsZSkKfQ\u003d\u003d", + "addContractToAccount": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYWRkQ29udHJhY3RUb0FjY291bnQgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCnRyYW5zYWN0aW9uKG5hbWU6IFN0cmluZywgY29kZTogU3RyaW5nKSB7CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChDb250cmFjdHMsIEFkZENvbnRyYWN0KSAmQWNjb3VudCkgewogICAgICAgIHNpZ25lci5jb250cmFjdHMuYWRkKG5hbWU6IG5hbWUsIGNvZGU6IGNvZGUudXRmOCkKICAgIH0KfQ\u003d\u003d", + "addKey": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYWRkS2V5IC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgQ3J5cHRvCgp0cmFuc2FjdGlvbihwdWJsaWNLZXk6IFN0cmluZywgc2lnbmF0dXJlQWxnb3JpdGhtOiBVSW50OCwgaGFzaEFsZ29yaXRobTogVUludDgsIHdlaWdodDogVUZpeDY0KSB7CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChLZXlzKSAmQWNjb3VudCkgewogICAgICAgIGxldCBrZXkgPSBQdWJsaWNLZXkoCiAgICAgICAgICAgIHB1YmxpY0tleTogcHVibGljS2V5LmRlY29kZUhleCgpLAogICAgICAgICAgICBzaWduYXR1cmVBbGdvcml0aG06IFNpZ25hdHVyZUFsZ29yaXRobShyYXdWYWx1ZTogc2lnbmF0dXJlQWxnb3JpdGhtKSEKICAgICAgICApCgogICAgICAgIHNpZ25lci5rZXlzLmFkZCgKICAgICAgICAgICAgcHVibGljS2V5OiBrZXksCiAgICAgICAgICAgIGhhc2hBbGdvcml0aG06IEhhc2hBbGdvcml0aG0ocmF3VmFsdWU6IGhhc2hBbGdvcml0aG0pISwKICAgICAgICAgICAgd2VpZ2h0OiB3ZWlnaHQKICAgICAgICApCiAgICB9Cn0\u003d", + "addKeyTemp": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYWRkS2V5VGVtcCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IENyeXB0bwoKdHJhbnNhY3Rpb24ocHVibGljS2V5czogW0NyeXB0by5LZXlMaXN0RW50cnldLCBjb250cmFjdHM6IHtTdHJpbmc6IFN0cmluZ30pIHsKCXByZXBhcmUoc2lnbmVyOiBhdXRoKEJvcnJvd1ZhbHVlIHwgU3RvcmFnZSkgJkFjY291bnQpIHsKCgkJbGV0IGFjY291bnQgPSBBY2NvdW50KHBheWVyOiBzaWduZXIpCgoJCS8vIGFkZCBhbGwgdGhlIGtleXMgdG8gdGhlIGFjY291bnQKCQlmb3Iga2V5IGluIHB1YmxpY0tleXMgewoJCQlhY2NvdW50LmtleXMuYWRkKHB1YmxpY0tleToga2V5LnB1YmxpY0tleSwgaGFzaEFsZ29yaXRobToga2V5Lmhhc2hBbGdvcml0aG0sIHdlaWdodDoga2V5LndlaWdodCkKCQl9CgkJCgkJLy8gYWRkIGNvbnRyYWN0cyBpZiBwcm92aWRlZAoJCWZvciBjb250cmFjdCBpbiBjb250cmFjdHMua2V5cyB7CgkJCWFjY291bnQuY29udHJhY3RzLmFkZChuYW1lOiBjb250cmFjdCwgY29kZTogY29udHJhY3RzW2NvbnRyYWN0XSEuZGVjb2RlSGV4KCkpCgkJfQoJfQp9", + "checkResource": "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", + "createAccount": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY3JlYXRlQWNjb3VudCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IENyeXB0bwppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHgxNjU0NjUzMzk5MDQwYTYxCgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKCiB0cmFuc2FjdGlvbihwdWJsaWNLZXlzOiBbQ3J5cHRvLktleUxpc3RFbnRyeV0sIGNvbnRyYWN0czoge1N0cmluZzogU3RyaW5nfSwgZnVuZEFtb3VudDogVUZpeDY0KSB7CiAgICBsZXQgdG9rZW5SZWNlaXZlcjogJntGdW5naWJsZVRva2VuLlJlY2VpdmVyfQogICAgbGV0IHNlbnRWYXVsdDogQEZ1bmdpYmxlVG9rZW4uVmF1bHQKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChCb3Jyb3dWYWx1ZSB8IFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IGFjY291bnQgPSBBY2NvdW50KHBheWVyOiBzaWduZXIpCiAgICAgICAgZm9yIGtleSBpbiBwdWJsaWNLZXlzIHsKICAgICAgICAgICAgYWNjb3VudC5rZXlzLmFkZChwdWJsaWNLZXk6IGtleS5wdWJsaWNLZXksIGhhc2hBbGdvcml0aG06IGtleS5oYXNoQWxnb3JpdGhtLCB3ZWlnaHQ6IGtleS53ZWlnaHQpCiAgICAgICAgfQogICAgICAgIGZvciBjb250cmFjdCBpbiBjb250cmFjdHMua2V5cyB7CiAgICAgICAgICAgIGFjY291bnQuY29udHJhY3RzLmFkZChuYW1lOiBjb250cmFjdCwgY29kZTogY29udHJhY3RzW2NvbnRyYWN0XSEuZGVjb2RlSGV4KCkpCiAgICAgICAgfQogICAgICAgIHNlbGYudG9rZW5SZWNlaXZlciA9IGFjY291bnQuY2FwYWJpbGl0aWVzLmJvcnJvdzwme0Z1bmdpYmxlVG9rZW4uUmVjZWl2ZXJ9PigvcHVibGljL2Zsb3dUb2tlblJlY2VpdmVyKSA/PyBwYW5pYygiVW5hYmxlIHRvIGJvcnJvdyByZWNlaXZlciByZWZlcmVuY2UiKQogICAgICAgIGxldCB2YXVsdFJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZGbG93VG9rZW4uVmF1bHQ+KGZyb206IC9zdG9yYWdlL2Zsb3dUb2tlblZhdWx0KSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIG93bmVyJydzIFZhdWx0ISIpCiAgICAgICAgc2VsZi5zZW50VmF1bHQgPC0gdmF1bHRSZWYud2l0aGRyYXcoYW1vdW50OiBmdW5kQW1vdW50KQogICAgfQogICAgZXhlY3V0ZSB7CiAgICAgICAgc2VsZi50b2tlblJlY2VpdmVyLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKICAgIH0KIH0\u003d", + "createAccountSdk": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY3JlYXRlQWNjb3VudFNkayAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IENyeXB0bwoKdHJhbnNhY3Rpb24ocHVibGljS2V5OiBTdHJpbmcsIHNpZ25hdHVyZUFsZ29yaXRobTogVUludDgsIGhhc2hBbGdvcml0aG06IFVJbnQ4LCB3ZWlnaHQ6IFVGaXg2NCwgY29udHJhY3RzOiB7U3RyaW5nOiBTdHJpbmd9KSB7CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChCb3Jyb3dWYWx1ZSB8IFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IGFjY291bnQgPSBBY2NvdW50KHBheWVyOiBzaWduZXIpCgogICAgICAgIGxldCBrZXkgPSBQdWJsaWNLZXkoCiAgICAgICAgICAgIHB1YmxpY0tleTogcHVibGljS2V5LmRlY29kZUhleCgpLAogICAgICAgICAgICBzaWduYXR1cmVBbGdvcml0aG06IFNpZ25hdHVyZUFsZ29yaXRobShyYXdWYWx1ZTogc2lnbmF0dXJlQWxnb3JpdGhtKSEKICAgICAgICApCgogICAgICAgIGFjY291bnQua2V5cy5hZGQoCiAgICAgICAgICAgIHB1YmxpY0tleToga2V5LAogICAgICAgICAgICBoYXNoQWxnb3JpdGhtOiBIYXNoQWxnb3JpdGhtKHJhd1ZhbHVlOiBoYXNoQWxnb3JpdGhtKSEsCiAgICAgICAgICAgIHdlaWdodDogd2VpZ2h0CiAgICAgICAgKQoKICAgICAgICBmb3IgY29udHJhY3QgaW4gY29udHJhY3RzLmtleXMgewogICAgICAgICAgICBhY2NvdW50LmNvbnRyYWN0cy5hZGQobmFtZTogY29udHJhY3QsIGNvZGU6IGNvbnRyYWN0c1tjb250cmFjdF0hLmRlY29kZUhleCgpKQogICAgICAgIH0KICAgIH0KfQ\u003d\u003d", + "getAccountInfo": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QWNjb3VudEluZm8gLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmFjY2VzcyhhbGwpIHN0cnVjdCBSZXN1bHQgewogIGFjY2VzcyhhbGwpIGxldCBhZGRyZXNzOiBBZGRyZXNzCiAgYWNjZXNzKGFsbCkgbGV0IGJhbGFuY2U6IFVGaXg2NAogIGFjY2VzcyhhbGwpIGxldCBhdmFpbGFibGVCYWxhbmNlOiBVRml4NjQKICBhY2Nlc3MoYWxsKSBsZXQgc3RvcmFnZVVzZWQ6IFVJbnQ2NAogIGFjY2VzcyhhbGwpIGxldCBzdG9yYWdlQ2FwYWNpdHk6IFVJbnQ2NAogIGFjY2VzcyhhbGwpIGxldCBzdG9yYWdlRmxvdzogVUZpeDY0CgogIGluaXQoCiAgICBhZGRyZXNzOiBBZGRyZXNzLAogICAgYmFsYW5jZTogVUZpeDY0LAogICAgYXZhaWxhYmxlQmFsYW5jZTogVUZpeDY0LAogICAgc3RvcmFnZVVzZWQ6IFVJbnQ2NCwKICAgIHN0b3JhZ2VDYXBhY2l0eTogVUludDY0LAogICAgc3RvcmFnZUZsb3c6IFVGaXg2NCwKICApIHsKICAgIHNlbGYuYWRkcmVzcyA9IGFkZHJlc3MKICAgIHNlbGYuYmFsYW5jZSA9IGJhbGFuY2UKICAgIHNlbGYuYXZhaWxhYmxlQmFsYW5jZSA9IGF2YWlsYWJsZUJhbGFuY2UKICAgIHNlbGYuc3RvcmFnZVVzZWQgPSBzdG9yYWdlVXNlZAogICAgc2VsZi5zdG9yYWdlQ2FwYWNpdHkgPSBzdG9yYWdlQ2FwYWNpdHkKICAgIHNlbGYuc3RvcmFnZUZsb3cgPSBzdG9yYWdlRmxvdwogIH0KfQoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IFJlc3VsdCB7CiAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgcmV0dXJuIFJlc3VsdCgKICAgIGFkZHJlc3M6IGFjY291bnQuYWRkcmVzcywKICAgIGJhbGFuY2U6IGFjY291bnQuYmFsYW5jZSwKICAgIGF2YWlsYWJsZUJhbGFuY2U6IGFjY291bnQuYXZhaWxhYmxlQmFsYW5jZSwKICAgIHN0b3JhZ2VVc2VkOiBhY2NvdW50LnN0b3JhZ2UudXNlZCwKICAgIHN0b3JhZ2VDYXBhY2l0eTogYWNjb3VudC5zdG9yYWdlLmNhcGFjaXR5LAogICAgc3RvcmFnZUZsb3c6IGFjY291bnQuYmFsYW5jZSAtIGFjY291bnQuYXZhaWxhYmxlQmFsYW5jZQogICkKfQ\u003d\u003d", + "getAccountMinFlow": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QWNjb3VudE1pbkZsb3cgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBVRml4NjQgewogIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogIHJldHVybiBhY2NvdW50LmJhbGFuY2UgLSBhY2NvdW50LmF2YWlsYWJsZUJhbGFuY2UKfQ\u003d\u003d", + "getAccountTotalFlowBalance": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QWNjb3VudFRvdGFsRmxvd0JhbGFuY2UgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHgxNjU0NjUzMzk5MDQwYTYxCgppbXBvcnQgTG9ja2VkVG9rZW5zIGZyb20gMHg4ZDBlODdiNjUxNTlhZTYzCgovLyBpbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKLy8gaW1wb3J0IEZsb3dUb2tlbiBmcm9tIDB4MTY1NDY1MzM5OTA0MGE2MQoKLy8gaW1wb3J0IExvY2tlZFRva2VucyBmcm9tIDB4OGQwZTg3YjY1MTU5YWU2MwoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBVRml4NjQgewogICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICBsZXQgdW5sb2NrZWRWYXVsdCA9IGFjY291bnQKICAgICAgLmNhcGFiaWxpdGllcy5nZXQ8JntGdW5naWJsZVRva2VuLkJhbGFuY2V9PigvcHVibGljL2Zsb3dUb2tlbkJhbGFuY2UpIQogICAgICAuYm9ycm93KCkKICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBCYWxhbmNlIHJlZmVyZW5jZSB0byB0aGUgVmF1bHQiKQogICAgbGV0IHVubG9ja2VkQmFsYW5jZSA9IHVubG9ja2VkVmF1bHQuYmFsYW5jZQogICAgICAgIAogICAgbGV0IGxvY2tlZEFjY291bnRJbmZvQ2FwID0gYWNjb3VudAogICAgICAuY2FwYWJpbGl0aWVzLmdldAogICAgICA8JkxvY2tlZFRva2Vucy5Ub2tlbkhvbGRlcj4KICAgICAgKExvY2tlZFRva2Vucy5Mb2NrZWRBY2NvdW50SW5mb1B1YmxpY1BhdGgpCiAgICBpZiBsb2NrZWRBY2NvdW50SW5mb0NhcCA9PSBuaWwgfHwgIShsb2NrZWRBY2NvdW50SW5mb0NhcCEuY2hlY2soKSkgewogICAgICAgIHJldHVybiB1bmxvY2tlZEJhbGFuY2UKICAgIH0KICAgIAogICAgbGV0IGxvY2tlZEFjY291bnRJbmZvUmVmID0gbG9ja2VkQWNjb3VudEluZm9DYXAhLmJvcnJvdygpIQogICAgbGV0IGxvY2tlZEJhbGFuY2UgPSBsb2NrZWRBY2NvdW50SW5mb1JlZi5nZXRMb2NrZWRBY2NvdW50QmFsYW5jZSgpCiAgICAKICAgIHJldHVybiBsb2NrZWRCYWxhbmNlICsgdW5sb2NrZWRCYWxhbmNlCn0\u003d", + "getAccountTotalLockedFlowBalance": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QWNjb3VudFRvdGFsTG9ja2VkRmxvd0JhbGFuY2UgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHgxNjU0NjUzMzk5MDQwYTYxCgppbXBvcnQgTG9ja2VkVG9rZW5zIGZyb20gMHg4ZDBlODdiNjUxNTlhZTYzCgoKLy8gaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKCi8vIGltcG9ydCBGbG93VG9rZW4gZnJvbSAweDE2NTQ2NTMzOTkwNDBhNjEKCi8vIGltcG9ydCBMb2NrZWRUb2tlbnMgZnJvbSAweDhkMGU4N2I2NTE1OWFlNjMKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzKTogVUZpeDY0IHsKICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQoKICAgIGxldCBsb2NrZWRBY2NvdW50SW5mb0NhcCA9IGFjY291bnQKICAgICAgLmNhcGFiaWxpdGllcy5nZXQKICAgICAgPCZMb2NrZWRUb2tlbnMuVG9rZW5Ib2xkZXI+CiAgICAgIChMb2NrZWRUb2tlbnMuTG9ja2VkQWNjb3VudEluZm9QdWJsaWNQYXRoKQogICAgaWYgbG9ja2VkQWNjb3VudEluZm9DYXAgPT0gbmlsIHx8ICEobG9ja2VkQWNjb3VudEluZm9DYXAhLmNoZWNrKCkpIHsKICAgICAgICByZXR1cm4gVUZpeDY0KDApCiAgICB9CiAgICAKICAgIGxldCBsb2NrZWRBY2NvdW50SW5mb1JlZiA9IGxvY2tlZEFjY291bnRJbmZvQ2FwIS5ib3Jyb3coKSEKICAgIGxldCBsb2NrZWRCYWxhbmNlID0gbG9ja2VkQWNjb3VudEluZm9SZWYuZ2V0TG9ja2VkQWNjb3VudEJhbGFuY2UoKQogICAgCiAgICByZXR1cm4gbG9ja2VkQmFsYW5jZQp9", + "getAccountTotalUnlockedFlowBalance": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QWNjb3VudFRvdGFsVW5sb2NrZWRGbG93QmFsYW5jZSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKLy8gaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKCi8vIGltcG9ydCBGbG93VG9rZW4gZnJvbSAweDE2NTQ2NTMzOTkwNDBhNjEKCi8vIGltcG9ydCBMb2NrZWRUb2tlbnMgZnJvbSAweDhkMGU4N2I2NTE1OWFlNjMKCgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKaW1wb3J0IEZsb3dUb2tlbiBmcm9tIDB4MTY1NDY1MzM5OTA0MGE2MQoKaW1wb3J0IExvY2tlZFRva2VucyBmcm9tIDB4OGQwZTg3YjY1MTU5YWU2MwoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBVRml4NjQgewogICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCgogICAgbGV0IHVubG9ja2VkVmF1bHQgPSBhY2NvdW50CiAgICAgIC5jYXBhYmlsaXRpZXMuZ2V0PCZGbG93VG9rZW4uVmF1bHQ+KC9wdWJsaWMvZmxvd1Rva2VuQmFsYW5jZSkhCiAgICAgIC5ib3Jyb3coKQogICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IEJhbGFuY2UgcmVmZXJlbmNlIHRvIHRoZSBWYXVsdCIpCiAgICBsZXQgdW5sb2NrZWRCYWxhbmNlID0gdW5sb2NrZWRWYXVsdC5iYWxhbmNlCgogICAgbGV0IGxvY2tlZEFjY291bnRJbmZvQ2FwID0gYWNjb3VudAogICAgICAuY2FwYWJpbGl0aWVzLmdldAogICAgICA8JkxvY2tlZFRva2Vucy5Ub2tlbkhvbGRlcj4KICAgICAgKExvY2tlZFRva2Vucy5Mb2NrZWRBY2NvdW50SW5mb1B1YmxpY1BhdGgpCiAgICBpZiBsb2NrZWRBY2NvdW50SW5mb0NhcCA9PSBuaWwgfHwgIShsb2NrZWRBY2NvdW50SW5mb0NhcCEuY2hlY2soKSkgewogICAgICAgIHJldHVybiB1bmxvY2tlZEJhbGFuY2UKICAgIH0KICAgIAogICAgbGV0IGxvY2tlZEFjY291bnRJbmZvUmVmID0gbG9ja2VkQWNjb3VudEluZm9DYXAhLmJvcnJvdygpIQogICAgbGV0IGxvY2tlZEJhbGFuY2UgPSBsb2NrZWRBY2NvdW50SW5mb1JlZi5nZXRMb2NrZWRBY2NvdW50QmFsYW5jZSgpCiAgICBsZXQgbG9ja2VkQmFsYW5jZVVubG9ja2VkID0gbG9ja2VkQWNjb3VudEluZm9SZWYuZ2V0VW5sb2NrTGltaXQoKQoKICAgIGlmIGxvY2tlZEJhbGFuY2UgPT0gVUZpeDY0KDApIHsKICAgICAgICByZXR1cm4gdW5sb2NrZWRCYWxhbmNlCiAgICB9CgogICAgaWYgbG9ja2VkQmFsYW5jZVVubG9ja2VkID4gbG9ja2VkQmFsYW5jZSB7CiAgICAgICAgcmV0dXJuIHVubG9ja2VkQmFsYW5jZSArIGxvY2tlZEJhbGFuY2UKICAgIH0KCiAgICByZXR1cm4gbG9ja2VkQmFsYW5jZVVubG9ja2VkICsgdW5sb2NrZWRCYWxhbmNlCn0\u003d", + "getAccountsDetail": "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", + "getFindAddress": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0RmluZEFkZHJlc3MgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGSU5EIGZyb20gMHgwOTdiYWZhNGUwYjQ4ZWVmCgovL0NoZWNrIHRoZSBzdGF0dXMgb2YgYSBmaW4gdXNlcgphY2Nlc3MoYWxsKSBmdW4gbWFpbihuYW1lOiBTdHJpbmcpIDogQWRkcmVzcz8gewogICAgbGV0IHN0YXR1cyA9IEZJTkQuc3RhdHVzKG5hbWUpCiAgICByZXR1cm4gc3RhdHVzLm93bmVyCn0\u003d", + "getFindDomainByAddress": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0RmluZERvbWFpbkJ5QWRkcmVzcyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZJTkQgZnJvbSAweDA5N2JhZmE0ZTBiNDhlZWYKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzKSA6IFN0cmluZz97CiAgICByZXR1cm4gRklORC5yZXZlcnNlTG9va3VwKGFkZHJlc3MpCn0\u003d", + "getFlowBalanceForAnyAccounts": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Rmxvd0JhbGFuY2VGb3JBbnlBY2NvdW50cyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4ZTQ2N2I5ZGQxMWZhMDBkZgoKCi8vIEdldCB0aGUgYWNjb3VudCBiYWxhbmNlIGZvciBhIENPQSBhY2NvdW50CmFjY2VzcyhhbGwpIGZ1biBnZXRFVk1CYWxhbmNlKF8gYWRkcmVzczogU3RyaW5nKTogVUZpeDY0PyB7CiAgICByZXR1cm4gRVZNLmFkZHJlc3NGcm9tU3RyaW5nKGFkZHJlc3MpLmJhbGFuY2UoKS5pbkZMT1coKQp9CgovLyBHZXQgdGhlIGF2YWlsYWJsZSBhY2NvdW50IGJhbGFuY2UgZm9yIGEgRmxvdyBhY2NvdW50CmFjY2VzcyhhbGwpIGZ1biBnZXRGbG93QmFsYW5jZShfIGFkZHJlc3M6IFN0cmluZyk6IFVGaXg2ND8gewogICAgaWYgbGV0IGFjY291bnQgPSBBZGRyZXNzLmZyb21TdHJpbmcoYWRkcmVzcykgewogICAgICAgIC8vIFVzZSBhdmFpbGFibGUgYmFsYW5jZSBpbnN0ZWFkIG9mIHRvdGFsIGJhbGFuY2UKICAgICAgICByZXR1cm4gZ2V0QWNjb3VudChhY2NvdW50KS5hdmFpbGFibGVCYWxhbmNlCiAgICB9CiAgICByZXR1cm4gbmlsCn0KCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3NlczogW1N0cmluZ10pOiB7U3RyaW5nOiBVRml4NjQ/fSB7CiAgICBsZXQgcmVzOiB7U3RyaW5nOiBVRml4NjQ/fSA9IHt9CgogICAgZm9yIGFkZHIgaW4gYWRkcmVzc2VzIHsKICAgICAgICBsZXQgaGV4ID0gYWRkclsxXSA9PSAieCIgPyBhZGRyIDogIjB4Ii5jb25jYXQoYWRkcikKICAgICAgICBpZiBsZXQgZmxvd0JhbGFuY2UgPSBnZXRGbG93QmFsYW5jZShoZXgpIHsKICAgICAgICAgICAgcmVzW2hleF0gPSBmbG93QmFsYW5jZQogICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgIGlmIGxldCBldm1CYWxhbmNlID0gZ2V0RVZNQmFsYW5jZShoZXgpIHsKICAgICAgICAgICAgICAgIHJlc1toZXhdID0gZXZtQmFsYW5jZQogICAgICAgICAgICB9CiAgICAgICAgfQogICAgfQogICAgcmV0dXJuIHJlcwp9", + "getFlownsAddress": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Rmxvd25zQWRkcmVzcyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3ducyBmcm9tIDB4MjMzZWIwMTJkMzRiMDA3MAoKaW1wb3J0IERvbWFpbnMgZnJvbSAweDIzM2ViMDEyZDM0YjAwNzAKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihuYW1lOiBTdHJpbmcsIHJvb3Q6IFN0cmluZykgOiBBZGRyZXNzPyB7CiAgICBsZXQgcHJlZml4ID0gIjB4IgogICAgbGV0IHJvb3RIYWhzaCA9IEZsb3ducy5oYXNoKG5vZGU6ICIiLCBsYWJsZTogcm9vdCkKICAgIGxldCBuYW1laGFzaCA9IHByZWZpeC5jb25jYXQoRmxvd25zLmhhc2gobm9kZTogcm9vdEhhaHNoLCBsYWJsZTogbmFtZSkpCiAgICB2YXIgYWRkcmVzcyA9IERvbWFpbnMuZ2V0UmVjb3JkcyhuYW1laGFzaCkKICAgIHJldHVybiBhZGRyZXNzCn0\u003d", + "getFlownsDomainsByAddress": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Rmxvd25zRG9tYWluc0J5QWRkcmVzcyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IERvbWFpbnMgZnJvbSAweDIzM2ViMDEyZDM0YjAwNzAKCi8vIGFkZHJlc3M6IEZsb3cgYWRkcmVzcwoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IFtEb21haW5zLkRvbWFpbkRldGFpbF0gewogICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICBsZXQgY29sbGVjdGlvbkNhcCA9IGFjY291bnQuZ2V0Q2FwYWJpbGl0eTwme0RvbWFpbnMuQ29sbGVjdGlvblB1YmxpY30+KERvbWFpbnMuQ29sbGVjdGlvblB1YmxpY1BhdGgpCiAgICBsZXQgY29sbGVjdGlvbiA9IGNvbGxlY3Rpb25DYXAuYm9ycm93KCkhCiAgICBsZXQgZG9tYWluczpbRG9tYWlucy5Eb21haW5EZXRhaWxdID0gW10KICAgIGxldCBpZHMgPSBjb2xsZWN0aW9uLmdldElEcygpCgogICAgZm9yIGlkIGluIGlkcyB7CiAgICAgICAgbGV0IGRvbWFpbiA9IGNvbGxlY3Rpb24uYm9ycm93RG9tYWluKGlkOiBpZCkKICAgICAgICBsZXQgZGV0YWlsID0gZG9tYWluLmdldERldGFpbCgpCiAgICAgICAgZG9tYWlucy5hcHBlbmQoZGV0YWlsKQogICAgfQoKICAgIHJldHVybiBkb21haW5zCn0\u003d", + "getStorageInfo": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0U3RvcmFnZUluZm8gLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCiBhY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyOiBBZGRyZXNzKToge1N0cmluZzogVUludDY0fSB7CiAgICBsZXQgYWNjdCA9IGdldEFjY291bnQoYWRkcikKICAgIGxldCByZXQ6IHtTdHJpbmc6IFVJbnQ2NH0gPSB7fQogICAgcmV0WyJjYXBhY2l0eSJdID0gYWNjdC5zdG9yYWdlLmNhcGFjaXR5CiAgICByZXRbInVzZWQiXSA9IGFjY3Quc3RvcmFnZS51c2VkCiAgICBpZiBhY2N0LnN0b3JhZ2UuY2FwYWNpdHkgPiAwIHsKICAgICAgICByZXRbImF2YWlsYWJsZSJdID0gYWNjdC5zdG9yYWdlLmNhcGFjaXR5IC0gIGFjY3Quc3RvcmFnZS51c2VkCiAgICB9IGVsc2UgewogICAgICAgIHJldFsiYXZhaWxhYmxlIl0gPSAwCiAgICB9CiAgICAKICAgIHJldHVybiByZXQKfQ\u003d\u003d", + "getTokenBalanceWithModel": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0VG9rZW5CYWxhbmNlV2l0aE1vZGVsIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKaW1wb3J0IDxUb2tlbj4gZnJvbSA8VG9rZW5BZGRyZXNzPgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IFVGaXg2NCB7CiAgICBsZXQgYWNjb3VudCA9IGdldEFjY291bnQoYWRkcmVzcykKCiAgICBsZXQgdmF1bHRSZWYgPSBhY2NvdW50LmNhcGFiaWxpdGllcy5ib3Jyb3c8JntGdW5naWJsZVRva2VuLkJhbGFuY2V9Pig8VG9rZW5CYWxhbmNlUGF0aD4pCiAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBCYWxhbmNlIGNhcGFiaWxpdHkiKQoKICAgIHJldHVybiB2YXVsdFJlZi5iYWxhbmNlCn0\u003d", + "isKeyHasFullAuth": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgaXNLZXlIYXNGdWxsQXV0aCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MsIHB1YmxpY0tleTogU3RyaW5nKTogQm9vbCB7CiAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgdmFyIGZsYWcgPSBmYWxzZQogIGZ1biBhY2NvdW50Rm4oYWNjb3VudEtleTogQWNjb3VudEtleSk6IEJvb2wgewogICAgbGV0IGtleSA9IFN0cmluZy5lbmNvZGVIZXgoYWNjb3VudEtleS5wdWJsaWNLZXkucHVibGljS2V5KQogICAgaWYgcHVibGljS2V5ID09IGtleSB7CiAgICAgIGZsYWcgPSBhY2NvdW50S2V5LndlaWdodCA+PSBVRml4NjQoMTAwMCkgJiYgIWFjY291bnRLZXkuaXNSZXZva2VkCiAgICB9CiAgICByZXR1cm4gZmFsc2UKICB9CiAgYWNjb3VudC5rZXlzLmZvckVhY2goYWNjb3VudEZuKQoKICByZXR1cm4gZmxhZwp9Cg\u003d\u003d", + "isKeysHasFullAuth": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgaXNLZXlzSGFzRnVsbEF1dGggLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzLCBwdWJsaWNLZXlzOiBbU3RyaW5nXSk6IEJvb2wgewogIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogIHZhciB3ZWlnaHQ6IFVGaXg2NCA9IDAuMAogIGZ1biBhY2NvdW50Rm4oYWNjb3VudEtleTogQWNjb3VudEtleSk6IEJvb2wgewogICAgbGV0IGtleSA9IFN0cmluZy5lbmNvZGVIZXgoYWNjb3VudEtleS5wdWJsaWNLZXkucHVibGljS2V5KQogICAgaWYgcHVibGljS2V5cy5jb250YWlucyhrZXkpICYmICFhY2NvdW50S2V5LmlzUmV2b2tlZCB7CiAgICAgIHdlaWdodCA9IHdlaWdodCArIGFjY291bnRLZXkud2VpZ2h0IAogICAgfQogICAgcmV0dXJuIGZhbHNlCiAgfQogIGFjY291bnQua2V5cy5mb3JFYWNoKGFjY291bnRGbikKCiAgcmV0dXJuIHdlaWdodCA+PSBVRml4NjQoMTAwMCkKfQo\u003d", + "isLockedFlowEnable": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgaXNMb2NrZWRGbG93RW5hYmxlIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTG9ja2VkVG9rZW5zIGZyb20gMHg4ZDBlODdiNjUxNTlhZTYzCgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IEJvb2wgewogICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICByZXR1cm4gYWNjb3VudC5jYXBhYmlsaXRpZXMuZXhpc3RzKExvY2tlZFRva2Vucy5Mb2NrZWRBY2NvdW50SW5mb1B1YmxpY1BhdGgpCn0\u003d", + "isTokenStorageEnabled": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgaXNUb2tlblN0b3JhZ2VFbmFibGVkIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKaW1wb3J0IDxUb2tlbj4gZnJvbSA8VG9rZW5BZGRyZXNzPgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAKICAgIGxldCByZWNlaXZlciA9IGFjY291bnQuY2FwYWJpbGl0aWVzLmV4aXN0cyg8VG9rZW5SZWNlaXZlclBhdGg+KQogICAgbGV0IGJhbGFuY2UgPSBhY2NvdW50LmNhcGFiaWxpdGllcy5leGlzdHMoPFRva2VuQmFsYW5jZVBhdGg+KQoKICAgIHJldHVybiByZWNlaXZlciAmJiBiYWxhbmNlCn0\u003d", + "queryBalanceForAccounts": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcXVlcnlCYWxhbmNlRm9yQWNjb3VudHMgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBOb25GdW5naWJsZVRva2VuIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcnM6IFtBZGRyZXNzXSk6IHtBZGRyZXNzOiBBbnlTdHJ1Y3R9IHsKCiAgICB2YXIgcmVzdWx0OiB7QWRkcmVzczogQW55U3RydWN0fSA9IHt9CiAgICBmb3IgYWRkciBpbiBhZGRycyB7CiAgICAgICAgbGV0IGFjY291bnRJbmZvID0gZ2V0QWNjb3VudEluZm8oYWRkcmVzczogYWRkcikKICAgICAgICByZXN1bHRbYWRkcl0gPSBhY2NvdW50SW5mbwogICAgfQogICAgcmV0dXJuIHJlc3VsdAp9CgphY2Nlc3MoYWxsKSBmdW4gZ2V0QWNjb3VudEluZm8oYWRkcmVzczogQWRkcmVzcyk6IEFueVN0cnVjdCB7CiAgICBsZXQgYWNjID0gZ2V0QXV0aEFjY291bnQ8YXV0aChTdG9yYWdlKSAmQWNjb3VudD4oYWRkcmVzcykKICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgbGV0IGZvdW5kVHlwZXM6IFtUeXBlXSA9IFtdCiAgICB2YXIgbmZ0Q291bnRzID0gMAoKICAgICBhY2Muc3RvcmFnZS5mb3JFYWNoU3RvcmVkKGZ1biAocGF0aDogU3RvcmFnZVBhdGgsIHR5cGU6IFR5cGUpOiBCb29sIHsKICAgICAgaWYgdHlwZS5pc1N1YnR5cGUob2Y6IFR5cGU8QHtOb25GdW5naWJsZVRva2VuLkNvbGxlY3Rpb259PigpKSAmJiAhdHlwZS5pc1JlY292ZXJlZCB7CiAgICAgICAgICB2YXIgY29sbGVjdGlvbiA9IGFjYy5zdG9yYWdlLmJvcnJvdzwme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0+KGZyb206cGF0aCkhCiAgICAgICAgICBsZXQgaWRzID0gY29sbGVjdGlvbi5nZXRJRHMoKQogICAgICAgICAgICBuZnRDb3VudHMgPSBuZnRDb3VudHMgKyBpZHMubGVuZ3RoCiAgICAgICAgfQogICAgICAgIHJldHVybiB0cnVlCiAgICB9KQoKICAgIHJldHVybiB7CiAgICAgICAgImZsb3dCYWxhbmNlIjogYWNjb3VudC5iYWxhbmNlLAogICAgICAgICJuZnRDb3VudHMiOiBuZnRDb3VudHMKICAgIH0KfQo\u003d", + "queryCustomFT": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcXVlcnlDdXN0b21GVCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IE1ldGFkYXRhVmlld3MgZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCmltcG9ydCBWaWV3UmVzb2x2ZXIgZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCmltcG9ydCBOb25GdW5naWJsZVRva2VuIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgRnVuZ2libGVUb2tlbk1ldGFkYXRhVmlld3MgZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKTWV0YWRhdGFWaWV3cwoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGNvbnRyYWN0QWRkcmVzczogQWRkcmVzcywgY29udHJhY3ROYW1lOiBTdHJpbmcpOiBGdW5naWJsZVRva2VuTWV0YWRhdGFWaWV3cy5GVFZhdWx0RGF0YSB7CiAgICAKICAgIGxldCB2aWV3UmVzb2x2ZXIgPSBnZXRBY2NvdW50KGNvbnRyYWN0QWRkcmVzcykuY29udHJhY3RzLmJvcnJvdzwme1ZpZXdSZXNvbHZlcn0+KG5hbWU6IGNvbnRyYWN0TmFtZSkKICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IFZpZXdSZXNvbHZlciBmcm9tIEZ1bmdpYmxlVG9rZW4gY29udHJhY3QiKQogICAgbGV0IHZhdWx0RGF0YSA9IHZpZXdSZXNvbHZlci5yZXNvbHZlQ29udHJhY3RWaWV3KAogICAgICAgIHJlc291cmNlVHlwZTogbmlsLAogICAgICAgIHZpZXdUeXBlOiBUeXBlPEZ1bmdpYmxlVG9rZW5NZXRhZGF0YVZpZXdzLkZUVmF1bHREYXRhPigpCiAgICApIGFzISBGdW5naWJsZVRva2VuTWV0YWRhdGFWaWV3cy5GVFZhdWx0RGF0YT8gPz8gcGFuaWMoIkNvdWxkIG5vdCByZXNvbHZlIEZUVmF1bHREYXRhIHZpZXciKQoKICAgIHJldHVybiB2YXVsdERhdGEKfQ\u003d\u003d", + "queryCustomNFT": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcXVlcnlDdXN0b21ORlQgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgVmlld1Jlc29sdmVyIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4MWQ3ZTU3YWE1NTgxNzQ0OAoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGNvbnRyYWN0QWRkcmVzczogQWRkcmVzcywgY29udHJhY3ROYW1lOiBTdHJpbmcpOiBNZXRhZGF0YVZpZXdzLk5GVENvbGxlY3Rpb25EYXRhIHsKCiAgICBsZXQgdmlld1Jlc29sdmVyID0gZ2V0QWNjb3VudChjb250cmFjdEFkZHJlc3MpLmNvbnRyYWN0cy5ib3Jyb3c8JntWaWV3UmVzb2x2ZXJ9PihuYW1lOiBjb250cmFjdE5hbWUpCiAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgVmlld1Jlc29sdmVyIGZyb20gTkZUIGNvbnRyYWN0IikKICAgIGxldCBjb2xsZWN0aW9uRGF0YSA9IHZpZXdSZXNvbHZlci5yZXNvbHZlQ29udHJhY3RWaWV3KAogICAgICAgICAgICByZXNvdXJjZVR5cGU6IG5pbCwKICAgICAgICAgICAgdmlld1R5cGU6IFR5cGU8TWV0YWRhdGFWaWV3cy5ORlRDb2xsZWN0aW9uRGF0YT4oKQogICAgICAgICkgYXMhIE1ldGFkYXRhVmlld3MuTkZUQ29sbGVjdGlvbkRhdGE/ID8/IHBhbmljKCJDb3VsZCBub3QgcmVzb2x2ZSBORlRDb2xsZWN0aW9uRGF0YSB2aWV3IikKICAgIAogICAgcmV0dXJuIGNvbGxlY3Rpb25EYXRhCn0\u003d", + "queryFlowBalance": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcXVlcnlGbG93QmFsYW5jZSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDE2NTQ2NTMzOTkwNDBhNjEKCgphY2Nlc3MoYWxsKSBmdW4gY2hlY2tGbG93VG9rZW5CYWxhbmNlKGFkZHJlc3M6IEFkZHJlc3MpIDogVUZpeDY0IHsKICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgbGV0IHZhdWx0UmVmID0gYWNjb3VudC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5CYWxhbmNlfT4oL3B1YmxpYy9mbG93VG9rZW5CYWxhbmNlKQogICAgPz8gbmlsCgogICAgCiAgICBpZiB2YXVsdFJlZiAhPSBuaWwgewogICAgICAgIHJldHVybiB2YXVsdFJlZiEuYmFsYW5jZQogICAgfQogICAgCiAgICByZXR1cm4gMC4wCn0KCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJzOiBbQWRkcmVzc10pOiBbVUZpeDY0XSB7CiAgICBsZXQgYmFsczogW1VGaXg2NF0gPSBbXQoKICAgIGZvciBhZGRyIGluIGFkZHJzIHsKICAgICAgICBsZXQgYmFsID0gY2hlY2tGbG93VG9rZW5CYWxhbmNlKGFkZHJlc3M6IGFkZHIpCiAgICAgICAgYmFscy5hcHBlbmQoYmFsKQogICAgfQogICAgCiAgICByZXR1cm4gYmFscwp9", + "removeAccountKeyByIndex": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcmVtb3ZlQWNjb3VudEtleUJ5SW5kZXggLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCnRyYW5zYWN0aW9uKGtleUluZGV4OiBJbnQpIHsKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKEtleXMpICZBY2NvdW50KSB7CiAgICAgICAgc2lnbmVyLmtleXMucmV2b2tlKGtleUluZGV4OiBrZXlJbmRleCkKICAgIH0KfQ\u003d\u003d", + "removeContractFromAccount": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcmVtb3ZlQ29udHJhY3RGcm9tQWNjb3VudCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKdHJhbnNhY3Rpb24obmFtZTogU3RyaW5nKSB7CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChSZW1vdmVDb250cmFjdCkgJkFjY291bnQpIHsKICAgICAgICBzaWduZXIuY29udHJhY3RzLnJlbW92ZShuYW1lOiBuYW1lKQogICAgfQp9", + "revokeKey": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcmV2b2tlS2V5IC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+Cgp0cmFuc2FjdGlvbihpbmRleDogSW50KSB7CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChLZXlzKSAmQWNjb3VudCkgewogICAgICAgIC8vIEdldCBhIGtleSBmcm9tIGFuIGF1dGggYWNjb3VudC4KICAgICAgICBsZXQga2V5QSA9IHNpZ25lci5rZXlzLnJldm9rZShrZXlJbmRleDogaW5kZXgpCiAgICB9Cn0\u003d", + "test": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgdGVzdCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDE2NTQ2NTMzOTkwNDBhNjEKCgp0cmFuc2FjdGlvbihhbW91bnQ6IFVGaXg2NCwgcmVjaXBpZW50OiBBZGRyZXNzKSB7CgogICAgLy8gVGhlIFZhdWx0IHJlc291cmNlIHRoYXQgaG9sZHMgdGhlIHRva2VucyB0aGF0IGFyZSBiZWluZyB0cmFuc2ZlcmVkCiAgICBsZXQgc2VudFZhdWx0OiBAe0Z1bmdpYmxlVG9rZW4uVmF1bHR9CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSwgQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgIC8vIEdldCBhIHJlZmVyZW5jZSB0byB0aGUgc2lnbmVyJ3Mgc3RvcmVkIHZhdWx0CiAgICAgICAgbGV0IHZhdWx0UmVmID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJkZsb3dUb2tlbi5WYXVsdD4oZnJvbTogL3N0b3JhZ2UvZmxvd1Rva2VuVmF1bHQpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IHJlZmVyZW5jZSB0byB0aGUgb3duZXIncyBWYXVsdCEiKQoKICAgICAgICAvLyBXaXRoZHJhdyB0b2tlbnMgZnJvbSB0aGUgc2lnbmVyJ3Mgc3RvcmVkIHZhdWx0CiAgICAgICAgc2VsZi5zZW50VmF1bHQgPC0gdmF1bHRSZWYud2l0aGRyYXcoYW1vdW50OiBhbW91bnQpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgLy8gR2V0IHRoZSByZWNpcGllbnQncyBwdWJsaWMgYWNjb3VudCBvYmplY3QKICAgICAgICBsZXQgcmVjaXBpZW50QWNjb3VudCA9IGdldEFjY291bnQocmVjaXBpZW50KQoKICAgICAgICAvLyBHZXQgYSByZWZlcmVuY2UgdG8gdGhlIHJlY2lwaWVudCdzIFJlY2VpdmVyCiAgICAgICAgbGV0IHJlY2VpdmVyUmVmID0gcmVjaXBpZW50QWNjb3VudC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5SZWNlaXZlcn0+KC9wdWJsaWMvZmxvd1Rva2VuUmVjZWl2ZXIpIQogICAgICAgICAgICAKICAgICAgICAvLyBEZXBvc2l0IHRoZSB3aXRoZHJhd24gdG9rZW5zIGluIHRoZSByZWNpcGllbnQncyByZWNlaXZlcgogICAgICAgIHJlY2VpdmVyUmVmLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKICAgIH0KfQ\u003d\u003d", + "updateContractOfAccount": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgdXBkYXRlQ29udHJhY3RPZkFjY291bnQgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCnRyYW5zYWN0aW9uKG5hbWU6IFN0cmluZywgY29kZTogU3RyaW5nKSB7CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChVcGRhdGVDb250cmFjdCkgJkFjY291bnQpIHsKICAgICAgICBzaWduZXIuY29udHJhY3RzLnVwZGF0ZShuYW1lOiBuYW1lLCBjb2RlOiBjb2RlLnV0ZjgpCiAgICB9Cn0\u003d", + "verifyUserSignature": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgdmVyaWZ5VXNlclNpZ25hdHVyZSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IENyeXB0bwoKYWNjZXNzKGFsbCkgZnVuIG1haW4oCiAgICBtZXNzYWdlOiBTdHJpbmcsCiAgICByYXdQdWJsaWNLZXlzOiBbU3RyaW5nXSwKICAgIHdlaWdodHM6IFtVRml4NjRdLAogICAgc2lnbkFsZ29zOiBbVUludDhdLAogICAgaGFzaEFsZ29zOiBbVUludDhdLAogICAgc2lnbmF0dXJlczogW1N0cmluZ10sCik6IEJvb2wgewoKICAgIGxldCBrZXlMaXN0ID0gQ3J5cHRvLktleUxpc3QoKQoKICAgIHZhciBpID0gMAogICAgZm9yIHJhd1B1YmxpY0tleSBpbiByYXdQdWJsaWNLZXlzIHsKICAgIGtleUxpc3QuYWRkKAogICAgICAgIFB1YmxpY0tleSgKICAgICAgICBwdWJsaWNLZXk6IHJhd1B1YmxpY0tleS5kZWNvZGVIZXgoKSwKICAgICAgICBzaWduYXR1cmVBbGdvcml0aG06IFNpZ25hdHVyZUFsZ29yaXRobShyYXdWYWx1ZTogc2lnbkFsZ29zW2ldKSEKICAgICAgICApLAogICAgICAgIGhhc2hBbGdvcml0aG06IEhhc2hBbGdvcml0aG0ocmF3VmFsdWU6IGhhc2hBbGdvc1tpXSkhLAogICAgICAgIHdlaWdodDogd2VpZ2h0c1tpXSwKICAgICkKICAgIGkgPSBpICsgMQogICAgfQoKICAgIGxldCBzaWduYXR1cmVTZXQ6IFtDcnlwdG8uS2V5TGlzdFNpZ25hdHVyZV0gPSBbXQoKICAgIHZhciBqID0gMAogICAgZm9yIHNpZ25hdHVyZSBpbiBzaWduYXR1cmVzIHsKICAgIHNpZ25hdHVyZVNldC5hcHBlbmQoCiAgICAgICAgQ3J5cHRvLktleUxpc3RTaWduYXR1cmUoCiAgICAgICAgICAgIGtleUluZGV4OiBqLAogICAgICAgICAgICBzaWduYXR1cmU6IHNpZ25hdHVyZS5kZWNvZGVIZXgoKQogICAgICAgICkKICAgICkKICAgICAgICBqID0gaiArIDEKICAgIH0KCiAgICBsZXQgc2lnbmVkRGF0YSA9IG1lc3NhZ2UuZGVjb2RlSGV4KCkKCiAgICByZXR1cm4ga2V5TGlzdC52ZXJpZnkoCiAgICAgICAgc2lnbmF0dXJlU2V0OiBzaWduYXR1cmVTZXQsCiAgICAgICAgc2lnbmVkRGF0YTogc2lnbmVkRGF0YSwKICAgICAgICBkb21haW5TZXBhcmF0aW9uVGFnOiAiRkxPVy1WMC4wLXVzZXIiCiAgICApCn0\u003d", + "withdrawAllUnlockedFlow": "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\u003d\u003d", + "withdrawUnlockedFlow": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgd2l0aGRyYXdVbmxvY2tlZEZsb3cgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCi8vIGltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgovLyBpbXBvcnQgRmxvd1Rva2VuIGZyb20gMHgxNjU0NjUzMzk5MDQwYTYxCgovLyBpbXBvcnQgTG9ja2VkVG9rZW5zIGZyb20gMHg4ZDBlODdiNjUxNTlhZTYzCgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDE2NTQ2NTMzOTkwNDBhNjEKCmltcG9ydCBMb2NrZWRUb2tlbnMgZnJvbSAweDhkMGU4N2I2NTE1OWFlNjMKCgp0cmFuc2FjdGlvbihhbW91bnQ6IFVGaXg2NCkgewoKICAgIGxldCBob2xkZXJSZWY6IGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgICZMb2NrZWRUb2tlbnMuVG9rZW5Ib2xkZXIKICAgIGxldCB2YXVsdFJlZjogJkZsb3dUb2tlbi5WYXVsdAoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgIHNlbGYuaG9sZGVyUmVmID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJkxvY2tlZFRva2Vucy5Ub2tlbkhvbGRlcj4oZnJvbTogTG9ja2VkVG9rZW5zLlRva2VuSG9sZGVyU3RvcmFnZVBhdGgpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IGEgcmVmZXJlbmNlIHRvIFRva2VuSG9sZGVyIikKCiAgICAgICAgc2VsZi52YXVsdFJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzwmRmxvd1Rva2VuLlZhdWx0Pihmcm9tOiAvc3RvcmFnZS9mbG93VG9rZW5WYXVsdCkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgZmxvdyB0b2tlbiB2YXVsdCByZWYiKQogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIHNlbGYudmF1bHRSZWYuZGVwb3NpdChmcm9tOiA8LXNlbGYuaG9sZGVyUmVmLndpdGhkcmF3KGFtb3VudDogYW1vdW50KSkKICAgIH0KfQ\u003d\u003d" + }, + "bridge": { + "batchBridgeChildNFTFromEoaWithPayer": "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\u003d\u003d", + "batchBridgeChildNFTFromEvmWithPayer": "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\u003d", + "batchBridgeChildNFTToEvmAddressWithPayer": "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\u003d", + "batchBridgeChildNFTToEvmWithPayer": "// Flow Wallet - mainnet Script  batchBridgeChildNFTToEvmWithPayer - v2.78
// <platform_info>

import MetadataViews from 0x1d7e57aa55817448

import ViewResolver from 0x1d7e57aa55817448

import NonFungibleToken from 0x1d7e57aa55817448

import FungibleToken from 0xf233dcee88fe0abe

import FlowToken from 0x1654653399040a61

import FungibleTokenMetadataViews from 0xf233dcee88fe0abe

import ScopedFTProviders from 0x1e4aa0b87d10b141

import EVM from 0xe467b9dd11fa00df

import FlowEVMBridgeUtils from 0x1e4aa0b87d10b141

import FlowEVMBridge from 0x1e4aa0b87d10b141

import FlowEVMBridgeConfig from 0x1e4aa0b87d10b141

import HybridCustody from 0xd8a7e05a7ac670c0

import CapabilityFilter from 0xd8a7e05a7ac670c0

import CrossVMMetadataViews from 0x1d7e57aa55817448


transaction(nftIdentifier: String, child: Address, ids: [UInt64]) {
    prepare(signer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, Capabilities, SaveValue) &Account, payer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        let coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        let m = signer.storage.borrow<auth(HybridCustody.Manage) &HybridCustody.Manager>(from: HybridCustody.ManagerStoragePath)
            ?? panic("manager does not exist")
        let childAcct = m.borrowAccount(addr: child) ?? panic("child account not found")

         // Construct the NFT type from the provided identifier
        let nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Retrieve the NFT --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        let viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = viewResolver.resolveContractView(
                resourceType: nil,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        var collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            )

        // Create collection if it doesn't exist
        if collection == nil {
            signer.storage.save(<- collectionData.createEmptyCollection(), to: collectionData.storagePath)
            signer.capabilities.unpublish(collectionData.publicPath)
            signer.capabilities.publish(
                signer.capabilities.storage.issue<&{NonFungibleToken.Collection}>(collectionData.storagePath),
                at: collectionData.publicPath
            )

            // Borrow authorized withdraw reference to the signer's collection
            collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            )!
        }

        let capType = Type<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider}>()
        let controllerID = childAcct.getControllerIDForType(type: capType, forPath: collectionData.storagePath)
            ?? panic("no controller found for capType")

        let cap = childAcct.getCapability(controllerID: controllerID, type: capType) ?? panic("no cap found")
        let providerCap = cap as! Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider}>
        assert(providerCap.check(), message: "invalid provider capability")

        let id = ids[0]
        // Get a reference to the child's stored vault
        let collectionRef = providerCap.borrow()!
        let childNft <- collectionRef.withdraw(withdrawID: id)
        collection!.deposit(token: <-childNft)
        // // Withdraw tokens from the signer's stored vault
        let currentStorageUsage = signer.storage.used
        let nft <- collection!.withdraw(withdrawID: id)
        let withdrawnStorageUsage = signer.storage.used
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(
                bytes: 400_000
            ) + (FlowEVMBridgeConfig.baseFee * UFix64(ids.length))

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if payer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = payer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            payer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = payer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        let scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )

        // Execute the bridge
        coa.depositNFT(
            nft: <- nft,
            feeProvider: &scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        var idx = 0
        for nftId in ids {
            if idx == 0 {
                idx = idx + 1
                continue
            }

            let nft <- collectionRef.withdraw(withdrawID: nftId)
            coa.depositNFT(
                nft: <- nft,
                feeProvider: &scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
            idx = idx + 1
        }
        // Destroy the ScopedFTProvider
        destroy scopedProvider

        // Wrap NFTs if applicable
        wrapAndTransferNFTsIfApplicable(coa,
            nftIDs: ids,
            nftType: nftType,
            viewResolver: viewResolver,
            recipientIfNotCoa: nil
        )
    }
}

/// Wraps and transfers bridged NFTs into a project's custom ERC721 wrapper contract on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
/// @param recipientIfNotCoa: The EVM address to transfer the wrapped NFTs to, nil if the NFTs should stay in signer's COA
///
access(all) fun wrapAndTransferNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt64],
    nftType: Type,
    viewResolver: &{ViewResolver},
    recipientIfNotCoa: EVM.EVMAddress?
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            // Wrap NFTs if underlying ERC721 address matches bridge's associated address for NFT type
            if underlyingAddress.equals(FlowEVMBridgeConfig.getEVMAddressAssociated(with: nftType)!) {
                // Approve contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, true]
                )

                // Wrap NFTs with provided IDs, and check if the call was successful
                let res = mustCall(coa, crossVMPointer.evmContractAddress,
                    functionSig: "depositFor(address,uint256[])",
                    args: [coa.address(), nftIDs]
                )
                let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                assert(decodedRes.length == 1, message: "Invalid response length")
                assert(decodedRes[0] as! Bool, message: "Failed to wrap NFTs")

                // Transfer NFTs to recipient if provided
                if let to = recipientIfNotCoa {
                    mustTransferNFTs(coa, crossVMPointer.evmContractAddress, nftIDs: nftIDs, to: to)
                }

                // Revoke approval for contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, false]
                )
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is owned by the provided EVM address
///
access(all) fun isOwner(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    _ nftID: UInt64,
    _ ownerToCheck: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: erc721Address,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )
    assert(res.status == EVM.Status.successful, message: "Call to ERC721.ownerOf(uint256) failed")
    let decodedRes = EVM.decodeABI(types: [Type<EVM.EVMAddress>()], data: res.data)
    if decodedRes.length == 1 {
        let actualOwner = decodedRes[0] as! EVM.EVMAddress
        return actualOwner.equals(ownerToCheck)
    }
    return false
}

/// Transfers NFTs from the provided COA to the provided EVM address
///
access(all) fun mustTransferNFTs(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    nftIDs: [UInt64],
    to: EVM.EVMAddress
) {
    for id in nftIDs {
        assert(isOwner(coa, erc721Address, id, coa.address()), message: "NFT not owned by signer's COA")
        mustCall(coa, erc721Address,
            functionSig: "safeTransferFrom(address,address,uint256)",
            args: [coa.address(), to, id]
        )
        assert(isOwner(coa, erc721Address, id, to), message: "NFT not transferred to recipient")
    }
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}", + "batchBridgeNFTFromEoaToFlowWithPayer": "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\u003d\u003d", + "batchBridgeNFTFromEvm": "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", + "batchBridgeNFTFromEvmToFlow": "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\u003d", + "batchBridgeNFTFromEvmToFlowWithPayer": "// Flow Wallet - mainnet Script  batchBridgeNFTFromEvmToFlowWithPayer - v2.78
// <platform_info>

import MetadataViews from 0x1d7e57aa55817448

import ViewResolver from 0x1d7e57aa55817448

import NonFungibleToken from 0x1d7e57aa55817448

import FungibleToken from 0xf233dcee88fe0abe

import FlowToken from 0x1654653399040a61

import FungibleTokenMetadataViews from 0xf233dcee88fe0abe

import ScopedFTProviders from 0x1e4aa0b87d10b141

import EVM from 0xe467b9dd11fa00df

import FlowEVMBridgeUtils from 0x1e4aa0b87d10b141

import FlowEVMBridge from 0x1e4aa0b87d10b141

import FlowEVMBridgeConfig from 0x1e4aa0b87d10b141

import StorageRent from 0x707adbad1428c624

import CrossVMMetadataViews from 0x1d7e57aa55817448


/// This transaction bridges an NFT from EVM to Cadence assuming it has already been onboarded to the FlowEVMBridge.
/// Also know that the recipient Flow account must have a Receiver capable of receiving the this bridged NFT accessible
/// via published Capability at the token's standard path.
/// NOTE: The ERC721 must have first been onboarded to the bridge. This can be checked via the method
///     FlowEVMBridge.evmAddressRequiresOnboarding(address: self.evmContractAddress)
///
/// @param nftIdentifier: The Cadence type identifier of the NFT to bridge - e.g. nft.getType().identifier
/// @param id: The ERC721 id of the NFT to bridge to Cadence from EVM
/// @param recipient: The Flow account address to receive the bridged NFT
///
transaction(nftIdentifier: String, ids: [UInt256], recipient: Address) {
    let nftType: Type
    let receiver: &{NonFungibleToken.Collection}
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let coa: auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount
    let viewResolver: &{ViewResolver}

    prepare(signer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account, payer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        /* --- Construct the NFT type --- */
        //
        // Construct the NFT type from the provided identifier
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        // Parse the NFT identifier into its components
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: self.nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Reference the recipient's NFT Receiver --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: self.nftType,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        // Configure the signer's account for this NFT
        if signer.storage.borrow<&{NonFungibleToken.Collection}>(from: collectionData.storagePath) == nil {
            signer.storage.save(<-collectionData.createEmptyCollection(), to: collectionData.storagePath)
            signer.capabilities.unpublish(collectionData.publicPath)
            let collectionCap = signer.capabilities.storage.issue<&{NonFungibleToken.Collection}>(collectionData.storagePath)
            signer.capabilities.publish(collectionCap, at: collectionData.publicPath)
        }
                
        self.receiver = getAccount(recipient).capabilities.borrow<&{NonFungibleToken.Collection}>(collectionData.publicPath) ?? panic("Could not borrow Receiver from recipient's public capability path")

        /* --- Configure a ScopedFTProvider --- */
        //
        // Calculate the bridge fee - bridging from EVM consumes no storage, so flat fee
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000) + (FlowEVMBridgeConfig.baseFee * UFix64(ids.length))
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if payer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = payer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            payer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = payer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    execute {
        // Unwrap NFTs from project-defined ERC721 wrapper contract if applicable
        unwrapNFTsIfApplicable(self.coa, nftIDs: ids, nftType: self.nftType, viewResolver: self.viewResolver)

        // Execute the bridge
        var idx = 0
        while idx < ids.length {
            let nftId = ids[idx]!
            // Execute the bridge
            let nft: @{NonFungibleToken.NFT} <- self.coa.withdrawNFT(
                type: self.nftType,
                id: nftId,
                feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
            // Ensure the bridged nft is the correct type
            assert(
                nft.getType() == self.nftType,
                message: "Bridged nft type mismatch - requested: ".concat(self.nftType.identifier)
                    .concat(", received: ").concat(nft.getType().identifier)
            )
            // Deposit the bridged NFT into the recipient's collection
            self.receiver.deposit(token: <-nft)
            idx = idx + 1
        }
        destroy self.scopedProvider

        StorageRent.tryRefill(recipient)

    }
}

/// Unwraps NFTs from a project's custom ERC721 wrapper contract to bridged NFTs on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
///
access(all) fun unwrapNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt256],
    nftType: Type,
    viewResolver: &{ViewResolver}
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            for id in nftIDs {
                // Unwrap NFT if it is wrapped
                if isNFTWrapped(coa,
                    nftID: id,
                    underlying: underlyingAddress,
                    wrapper: crossVMPointer.evmContractAddress
                ) {
                    let res = mustCall(coa, crossVMPointer.evmContractAddress,
                        functionSig: "withdrawTo(address,uint256[])",
                        args: [coa.address(), [id]]
                    )
                    let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                    assert(decodedRes.length == 1, message: "Invalid response length")
                    assert(decodedRes[0] as! Bool, message: "Failed to unwrap NFT")
                }
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is wrapped in the underlying ERC721 contract
///
access(all) fun isNFTWrapped(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftID: UInt256,
    underlying: EVM.EVMAddress,
    wrapper: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: underlying,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return false
    if res.status != EVM.Status.successful || res.data.length == 0{
        return false
    }

    // Decode and compare the addresses
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")

    let owner = decodedResult[0] as! EVM.EVMAddress
    return owner.toString() == wrapper.toString()
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}", + "batchBridgeNFTFromEvmV2": "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\u003d\u003d", + "batchBridgeNFTFromEvmWithPayer": "// Flow Wallet - mainnet Script  batchBridgeNFTFromEvmWithPayer - v2.78
// <platform_info>

import MetadataViews from 0x1d7e57aa55817448

import ViewResolver from 0x1d7e57aa55817448

import NonFungibleToken from 0x1d7e57aa55817448

import FungibleToken from 0xf233dcee88fe0abe

import FlowToken from 0x1654653399040a61

import FungibleTokenMetadataViews from 0xf233dcee88fe0abe

import ScopedFTProviders from 0x1e4aa0b87d10b141

import EVM from 0xe467b9dd11fa00df

import FlowEVMBridgeUtils from 0x1e4aa0b87d10b141

import FlowEVMBridge from 0x1e4aa0b87d10b141

import FlowEVMBridgeConfig from 0x1e4aa0b87d10b141

import CrossVMMetadataViews from 0x1d7e57aa55817448


/// This transaction bridges an NFT from EVM to Cadence assuming it has already been onboarded to the FlowEVMBridge
/// NOTE: The ERC721 must have first been onboarded to the bridge. This can be checked via the method
///     FlowEVMBridge.evmAddressRequiresOnboarding(address: self.evmContractAddress)
///
/// @param nftIdentifier: The Cadence type identifier of the NFT to bridge - e.g. nft.getType().identifier
/// @param id: The ERC721 id of the NFT to bridge to Cadence from EVM
///
transaction(nftIdentifier: String, ids: [UInt256]) {

    let nftType: Type
    let collection: &{NonFungibleToken.Collection}
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let coa: auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount
    let viewResolver: &{ViewResolver}

    prepare(signer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account, payer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        /* --- Construct the NFT type --- */
        //
        // Construct the NFT type from the provided identifier
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        // Parse the NFT identifier into its components
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: self.nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Reference the signer's NFT Collection --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: self.nftType,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        if signer.storage.borrow<&{NonFungibleToken.Collection}>(from: collectionData.storagePath) == nil {
            signer.storage.save(<-collectionData.createEmptyCollection(), to: collectionData.storagePath)
            signer.capabilities.unpublish(collectionData.publicPath)
            let collectionCap = signer.capabilities.storage.issue<&{NonFungibleToken.Collection}>(collectionData.storagePath)
            signer.capabilities.publish(collectionCap, at: collectionData.publicPath)
        }
        self.collection = signer.storage.borrow<&{NonFungibleToken.Collection}>(from: collectionData.storagePath)
            ?? panic("Could not borrow collection from storage path")

        /* --- Configure a ScopedFTProvider --- */
        //
        // Calculate the bridge fee - bridging from EVM consumes no storage, so flat fee
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000) + (FlowEVMBridgeConfig.baseFee * UFix64(ids.length))
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if payer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = payer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            payer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = payer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
            provider: providerCapCopy,
            filters: [ providerFilter ],
            expiration: getCurrentBlock().timestamp + 1.0
        )
    }

    execute {
        // Unwrap NFTs from project-defined ERC721 wrapper contract if applicable
        unwrapNFTsIfApplicable(self.coa, nftIDs: ids, nftType: self.nftType, viewResolver: self.viewResolver)

        // Execute the bridge
        var idx = 0
        while idx < ids.length {
            let nftId = ids[idx]!
            // Execute the bridge
            let nft: @{NonFungibleToken.NFT} <- self.coa.withdrawNFT(
                type: self.nftType,
                id: nftId,
                feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
            // Ensure the bridged nft is the correct type
            assert(
                nft.getType() == self.nftType,
                message: "Bridged nft type mismatch - requested: ".concat(self.nftType.identifier)
                    .concat(", received: ").concat(nft.getType().identifier)
            )
            // Deposit the bridged NFT into the signer's collection
            self.collection.deposit(token: <-nft)
            idx = idx + 1
        }

        // Destroy the ScopedFTProvider
        destroy self.scopedProvider
    }
}

/// Unwraps NFTs from a project's custom ERC721 wrapper contract to bridged NFTs on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
///
access(all) fun unwrapNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt256],
    nftType: Type,
    viewResolver: &{ViewResolver}
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            for id in nftIDs {
                // Unwrap NFT if it is wrapped
                if isNFTWrapped(coa,
                    nftID: id,
                    underlying: underlyingAddress,
                    wrapper: crossVMPointer.evmContractAddress
                ) {
                    let res = mustCall(coa, crossVMPointer.evmContractAddress,
                        functionSig: "withdrawTo(address,uint256[])",
                        args: [coa.address(), [id]]
                    )
                    let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                    assert(decodedRes.length == 1, message: "Invalid response length")
                    assert(decodedRes[0] as! Bool, message: "Failed to unwrap NFT")
                }
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is wrapped in the underlying ERC721 contract
///
access(all) fun isNFTWrapped(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftID: UInt256,
    underlying: EVM.EVMAddress,
    wrapper: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: underlying,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return false
    if res.status != EVM.Status.successful || res.data.length == 0{
        return false
    }

    // Decode and compare the addresses
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    let owner = decodedResult[0] as! EVM.EVMAddress
    return owner.toString() == wrapper.toString()
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", + "batchBridgeNFTToEvm": "// Flow Wallet - mainnet Script  batchBridgeNFTToEvm - v2.78
// <platform_info>

import FungibleToken from 0xf233dcee88fe0abe

import FlowToken from 0x1654653399040a61

import MetadataViews from 0x1d7e57aa55817448

import ViewResolver from 0x1d7e57aa55817448

import NonFungibleToken from 0x1d7e57aa55817448

import ScopedFTProviders from 0x1e4aa0b87d10b141

import EVM from 0xe467b9dd11fa00df

import FlowEVMBridgeUtils from 0x1e4aa0b87d10b141

import FlowEVMBridge from 0x1e4aa0b87d10b141

import FlowEVMBridgeConfig from 0x1e4aa0b87d10b141

import CrossVMMetadataViews from 0x1d7e57aa55817448


transaction(nftContractAddress: Address, nftContractName: String, ids: [UInt64]) {

    let nfts: @{UInt64 : {NonFungibleToken.NFT}}
    let coa: auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let nftType: Type
    let viewResolver: &{ViewResolver}

    prepare(signer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account) {

        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        self.nfts <- {}
        /* --- Retrieve the NFT --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        
        // Initialize nftType from the contract
        let nftIdentifier = "A.".concat(nftContractAddress.toString().slice(from: 2, upTo: nftContractAddress.toString().length)).concat(".").concat(nftContractName).concat(".NFT")
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
            
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: nil,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        let collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            ) ?? panic("Could not access signer's NFT Collection")

        // Withdraw the requested NFT & calculate the approximate bridge fee based on NFT storage usage
        let currentStorageUsage = signer.storage.used
        for id in ids {
            let nft <- collection.withdraw(withdrawID: id)
            self.nfts[id] <-! nft
        }
        // self.nft <- collection.withdraw(withdrawID: id)
        let withdrawnStorageUsage = signer.storage.used
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(
                bytes: currentStorageUsage - withdrawnStorageUsage
            ) * 1.10 * UFix64(ids.length)

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    execute {
        // Execute the bridge
        var idx = 0
        while idx < ids.length {
            let nftId = ids[idx]!
            let nft <- self.nfts.remove(key: nftId)! as @{NonFungibleToken.NFT}
            self.coa.depositNFT(
                nft: <- nft!,
                feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
            idx = idx + 1
        }

        // Destroy the ScopedFTProvider
        destroy self.scopedProvider
        destroy self.nfts

        // Wrap NFTs if applicable
        wrapAndTransferNFTsIfApplicable(self.coa,
            nftIDs: ids,
            nftType: self.nftType,
            viewResolver: self.viewResolver,
            recipientIfNotCoa: nil
        )
    }
}

/// Wraps and transfers bridged NFTs into a project's custom ERC721 wrapper contract on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
/// @param recipientIfNotCoa: The EVM address to transfer the wrapped NFTs to, nil if the NFTs should stay in signer's COA
///
access(all) fun wrapAndTransferNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt64],
    nftType: Type,
    viewResolver: &{ViewResolver},
    recipientIfNotCoa: EVM.EVMAddress?
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            // Wrap NFTs if underlying ERC721 address matches bridge's associated address for NFT type
            if underlyingAddress.equals(FlowEVMBridgeConfig.getEVMAddressAssociated(with: nftType)!) {
                // Approve contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, true]
                )

                // Wrap NFTs with provided IDs, and check if the call was successful
                let res = mustCall(coa, crossVMPointer.evmContractAddress,
                    functionSig: "depositFor(address,uint256[])",
                    args: [coa.address(), nftIDs]
                )
                let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                assert(decodedRes.length == 1, message: "Invalid response length")
                assert(decodedRes[0] as! Bool, message: "Failed to wrap NFTs")

                // Transfer NFTs to recipient if provided
                if let to = recipientIfNotCoa {
                    mustTransferNFTs(coa, crossVMPointer.evmContractAddress, nftIDs: nftIDs, to: to)
                }

                // Revoke approval for contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, false]
                )
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is owned by the provided EVM address
///
access(all) fun isOwner(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    _ nftID: UInt64,
    _ ownerToCheck: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: erc721Address,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )
    assert(res.status == EVM.Status.successful, message: "Call to ERC721.ownerOf(uint256) failed")
    let decodedRes = EVM.decodeABI(types: [Type<EVM.EVMAddress>()], data: res.data)
    if decodedRes.length == 1 {
        let actualOwner = decodedRes[0] as! EVM.EVMAddress
        return actualOwner.equals(ownerToCheck)
    }
    return false
}

/// Transfers NFTs from the provided COA to the provided EVM address
///
access(all) fun mustTransferNFTs(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    nftIDs: [UInt64],
    to: EVM.EVMAddress
) {
    for id in nftIDs {
        assert(isOwner(coa, erc721Address, id, coa.address()), message: "NFT not owned by signer's COA")
        mustCall(coa, erc721Address,
            functionSig: "safeTransferFrom(address,address,uint256)",
            args: [coa.address(), to, id]
        )
        assert(isOwner(coa, erc721Address, id, to), message: "NFT not transferred to recipient")
    }
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", + "batchBridgeNFTToEvmAddress": "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\u003d", + "batchBridgeNFTToEvmAddressWithPayer": "// Flow Wallet - mainnet Script  batchBridgeNFTToEvmAddressWithPayer - v2.78
// <platform_info>

import MetadataViews from 0x1d7e57aa55817448

import ViewResolver from 0x1d7e57aa55817448

import NonFungibleToken from 0x1d7e57aa55817448

import FungibleToken from 0xf233dcee88fe0abe

import FlowToken from 0x1654653399040a61

import FungibleTokenMetadataViews from 0xf233dcee88fe0abe

import ScopedFTProviders from 0x1e4aa0b87d10b141

import EVM from 0xe467b9dd11fa00df

import FlowEVMBridgeUtils from 0x1e4aa0b87d10b141

import FlowEVMBridge from 0x1e4aa0b87d10b141

import FlowEVMBridgeConfig from 0x1e4aa0b87d10b141

import CrossVMMetadataViews from 0x1d7e57aa55817448


/// Bridges an NFT from the signer's collection in Cadence to the signer's COA in FlowEVM
///
/// NOTE: This transaction also onboards the NFT to the bridge if necessary which may incur additional fees
///     than bridging an asset that has already been onboarded.
///
/// @param nftIdentifier: The Cadence type identifier of the NFT to bridge - e.g. nft.getType().identifier
/// @param id: The Cadence NFT.id of the NFT to bridge to EVM
///
transaction(nftIdentifier: String, ids: [UInt64], recipient: String) {
    let nft: @{NonFungibleToken.NFT}
    let requiresOnboarding: Bool
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let collection: auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}
    let nftType: Type
    let coa: auth(EVM.Call) &EVM.CadenceOwnedAccount
    let viewResolver: &{ViewResolver}

    prepare(signer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account, payer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account) {
        // Retrieve or create COA
        if let coa = signer.storage.borrow<auth(EVM.Call) &EVM.CadenceOwnedAccount>(from: /storage/evm) {
            self.coa = coa
        } else {
            signer.storage.save<@EVM.CadenceOwnedAccount>(<- EVM.createCadenceOwnedAccount(), to: /storage/evm)
            signer.capabilities.publish(
                signer.capabilities.storage.issue<&EVM.CadenceOwnedAccount>(/storage/evm),
                at: /public/evm
            )
            self.coa = signer.storage.borrow<auth(EVM.Call) &EVM.CadenceOwnedAccount>(from: /storage/evm)!
        }

        /* --- Construct the NFT type --- */
        //
        // Construct the NFT type from the provided identifier
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        // Parse the NFT identifier into its components
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: self.nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Retrieve the NFT --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: nil,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        self.collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            ) ?? panic("Could not access signer's NFT Collection")

        // Withdraw the requested NFT & calculate the approximate bridge fee based on NFT storage usage
        let currentStorageUsage = signer.storage.used
        self.nft <- self.collection.withdraw(withdrawID: ids[0])
        let withdrawnStorageUsage = signer.storage.used
        var approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000) + (FlowEVMBridgeConfig.baseFee * UFix64(ids.length))

        // Determine if the NFT requires onboarding - this impacts the fee required
        self.requiresOnboarding = FlowEVMBridge.typeRequiresOnboarding(self.nft.getType())
            ?? panic("Bridge does not support this asset type")
        if self.requiresOnboarding {
            approxFee = approxFee + FlowEVMBridgeConfig.onboardFee
        }

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if payer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = payer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            payer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = payer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    pre {
        self.nft.getType().identifier == nftIdentifier:
            "Attempting to send invalid nft type - requested: ".concat(nftIdentifier)
            .concat(", sending: ").concat(self.nft.getType().identifier)
    }

    execute {
        if self.requiresOnboarding {
            // Onboard the NFT to the bridge
            FlowEVMBridge.onboardByType(
                self.nft.getType(),
                feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
        }
        // Execute the bridge transaction
        self.coa.depositNFT(
            nft: <- self.nft,
            feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )

        var idx = 0
        for id in ids {
            if idx == 0 {
                idx = idx + 1
                continue
            }

            self.coa.depositNFT(
                nft: <- self.collection.withdraw(withdrawID: id),
                feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
        }

        // Destroy the ScopedFTProvider
        destroy self.scopedProvider

        // Wrap NFTs if applicable
        wrapAndTransferNFTsIfApplicable(self.coa,
            nftIDs: ids,
            nftType: self.nftType,
            viewResolver: self.viewResolver,
            recipientIfNotCoa: EVM.addressFromString(recipient)
        )
    }
}

/// Wraps and transfers bridged NFTs into a project's custom ERC721 wrapper contract on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
/// @param recipientIfNotCoa: The EVM address to transfer the wrapped NFTs to, nil if the NFTs should stay in signer's COA
///
access(all) fun wrapAndTransferNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt64],
    nftType: Type,
    viewResolver: &{ViewResolver},
    recipientIfNotCoa: EVM.EVMAddress?
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            // Wrap NFTs if underlying ERC721 address matches bridge's associated address for NFT type

            if underlyingAddress.equals(FlowEVMBridgeConfig.getEVMAddressAssociated(with: nftType)!) {
                // Approve contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, true]
                )

                // Wrap NFTs with provided IDs, and check if the call was successful
                let res = mustCall(coa, crossVMPointer.evmContractAddress,
                    functionSig: "depositFor(address,uint256[])",
                    args: [coa.address(), nftIDs]
                )
                let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                assert(decodedRes.length == 1, message: "Invalid response length")
                assert(decodedRes[0] as! Bool, message: "Failed to wrap NFTs")

                // Transfer NFTs to recipient if provided
                if let to = recipientIfNotCoa {
                    mustTransferNFTs(coa, crossVMPointer.evmContractAddress, nftIDs: nftIDs, to: to)
                }

                // Revoke approval for contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, false]
                )
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is owned by the provided EVM address
///
access(all) fun isOwner(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    _ nftID: UInt64,
    _ ownerToCheck: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: erc721Address,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )
    assert(res.status == EVM.Status.successful, message: "Call to ERC721.ownerOf(uint256) failed")
    let decodedRes = EVM.decodeABI(types: [Type<EVM.EVMAddress>()], data: res.data)
    if decodedRes.length == 1 {
        let actualOwner = decodedRes[0] as! EVM.EVMAddress
        return actualOwner.equals(ownerToCheck)
    }
    return false
}

/// Transfers NFTs from the provided COA to the provided EVM address
///
access(all) fun mustTransferNFTs(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    nftIDs: [UInt64],
    to: EVM.EVMAddress
) {
    for id in nftIDs {
        assert(isOwner(coa, erc721Address, id, coa.address()), message: "NFT not owned by signer's COA")
        mustCall(coa, erc721Address,
            functionSig: "safeTransferFrom(address,address,uint256)",
            args: [coa.address(), to, id]
        )
        assert(isOwner(coa, erc721Address, id, to), message: "NFT not transferred to recipient")
    }
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", + "batchBridgeNFTToEvmV2": "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\u003d", + "batchBridgeNFTToEvmWithPayer": "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\u003d\u003d", + "batchEvmAddressRequiresOnboarding": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYmF0Y2hFdm1BZGRyZXNzUmVxdWlyZXNPbmJvYXJkaW5nIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRVZNIGZyb20gMHhlNDY3YjlkZDExZmEwMGRmCgppbXBvcnQgRmxvd0VWTUJyaWRnZSBmcm9tIDB4MWU0YWEwYjg3ZDEwYjE0MQoKCi8vLyBSZXR1cm5zIHdoZXRoZXIgYSBFVk0gY29udHJhY3QgbmVlZHMgdG8gYmUgb25ib2FyZGVkIHRvIHRoZSBGbG93RVZNQnJpZGdlCi8vLwovLy8gQHBhcmFtIGV2bUFkZHJlc3NlczogQXJyYXkgb2YgaGV4LWVuY29kZWQgYWRkcmVzcyBvZiB0aGUgRVZNIGNvbnRyYWN0IGFzIGEgU3RyaW5nIHdpdGhvdXQgMHggcHJlZml4IHRvIGNoZWNrIGZvcgovLy8gICAgIG9uYm9hcmRpbmcgc3RhdHVzCi8vLwovLy8gQHJldHVybiBXaGV0aGVyIHRoZSBjb250cmFjdCByZXF1aXJlcyBvbmJvYXJkaW5nIHRvIHRoZSBGbG93RVZNQnJpZGdlIGlmIHRoZSB0eXBlIGlzIGJyaWRnZWFibGUsIG90aGVyd2lzZSBuaWwKLy8vICAgICBpbmRleGVkIG9uIHRoZSBoZXgtZW5jb2RlZCBhZGRyZXNzIG9mIHRoZSBFVk0gY29udHJhY3Qgd2l0aG91dCAweCBwcmVmaXgKLy8vCmFjY2VzcyhhbGwpIGZ1biBtYWluKGV2bUFkZHJlc3NlczogW1N0cmluZ10pOiB7U3RyaW5nOiBCb29sP30gewogICAgbGV0IHJlc3VsdHM6IHtTdHJpbmc6IEJvb2w/fSA9IHt9CiAgICBmb3IgYWRkcmVzc0hleCBpbiBldm1BZGRyZXNzZXMgewogICAgICAgIGlmIHJlc3VsdHNbYWRkcmVzc0hleF0gIT0gbmlsIHsKICAgICAgICAgICAgY29udGludWUKICAgICAgICB9CiAgICAgICAgbGV0IGFkZHJlc3MgPSBFVk0uYWRkcmVzc0Zyb21TdHJpbmcoYWRkcmVzc0hleCkKICAgICAgICBsZXQgcmVxdWlyZXNPbmJvYXJkaW5nID0gRmxvd0VWTUJyaWRnZS5ldm1BZGRyZXNzUmVxdWlyZXNPbmJvYXJkaW5nKGFkZHJlc3MpCiAgICAgICAgcmVzdWx0cy5pbnNlcnQoa2V5OiBhZGRyZXNzSGV4LCByZXF1aXJlc09uYm9hcmRpbmcpCiAgICB9CiAgICByZXR1cm4gcmVzdWx0cwp9Cg\u003d\u003d", + "batchIdentifierRequiresOnboarding": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYmF0Y2hJZGVudGlmaWVyUmVxdWlyZXNPbmJvYXJkaW5nIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd0VWTUJyaWRnZSBmcm9tIDB4MWU0YWEwYjg3ZDEwYjE0MQoKCi8vLyBSZXR1cm5zIHdoZXRoZXIgYSB0eXBlIG5lZWRzIHRvIGJlIG9uYm9hcmRlZCB0byB0aGUgRmxvd0VWTUJyaWRnZQovLy8KLy8vIEBwYXJhbSBUeXBlczogVGhlIGFycmF5IG9mIHR5cGVzIHRvIGNoZWNrIGZvciBvbmJvYXJkaW5nIHN0YXR1cwovLy8KLy8vIEByZXR1cm4gV2hldGhlciB0aGUgdHlwZSByZXF1aXJlcyBvbmJvYXJkaW5nIHRvIHRoZSBGbG93RVZNQnJpZGdlIGlmIHRoZSB0eXBlIGlzIGJyaWRnZWFibGUsIG90aGVyd2lzZSBuaWwgaW5kZXhlZAovLy8gICAgIG9uIHRoZSB0eXBlCi8vLwphY2Nlc3MoYWxsKSBmdW4gbWFpbihpZGVudGlmaWVyczogW1N0cmluZ10pOiB7U3RyaW5nOiBCb29sP30gewogICAgbGV0IHJlc3VsdHM6IHtTdHJpbmc6IEJvb2w/fSA9IHt9CgogICAgZm9yIGlkZW50aWZpZXIgaW4gaWRlbnRpZmllcnMgewogICAgICAgIGlmIHJlc3VsdHNbaWRlbnRpZmllcl0gIT0gbmlsIHsKICAgICAgICAgICAgY29udGludWUKICAgICAgICB9CiAgICAgICAgbGV0IHR5cGU6IFR5cGUgPSBDb21wb3NpdGVUeXBlKGlkZW50aWZpZXIpID8/IHBhbmljKCJJbnZhbGlkIHR5cGUgaWRlbnRpZmllciIpCiAgICAgICAgcmVzdWx0cy5pbnNlcnQoa2V5OiBpZGVudGlmaWVyLCBGbG93RVZNQnJpZGdlLnR5cGVSZXF1aXJlc09uYm9hcmRpbmcodHlwZSkpCiAgICB9CiAgICByZXR1cm4gcmVzdWx0cwp9Cg\u003d\u003d", + "batchOnboardByEvmAddress": "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", + "batchOnboardByIdentifier": "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\u003d", + "batchOnboardByType": "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\u003d\u003d", + "batchTypeRequiresOnboarding": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYmF0Y2hUeXBlUmVxdWlyZXNPbmJvYXJkaW5nIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd0VWTUJyaWRnZSBmcm9tIDB4MWU0YWEwYjg3ZDEwYjE0MQoKCi8vLyBSZXR1cm5zIHdoZXRoZXIgYSB0eXBlIG5lZWRzIHRvIGJlIG9uYm9hcmRlZCB0byB0aGUgRmxvd0VWTUJyaWRnZQovLy8KLy8vIEBwYXJhbSBUeXBlczogVGhlIGFycmF5IG9mIHR5cGVzIHRvIGNoZWNrIGZvciBvbmJvYXJkaW5nIHN0YXR1cwovLy8KLy8vIEByZXR1cm4gV2hldGhlciB0aGUgdHlwZSByZXF1aXJlcyBvbmJvYXJkaW5nIHRvIHRoZSBGbG93RVZNQnJpZGdlIGlmIHRoZSB0eXBlIGlzIGJyaWRnZWFibGUsIG90aGVyd2lzZSBuaWwgaW5kZXhlZAovLy8gICAgIG9uIHRoZSB0eXBlCi8vLwphY2Nlc3MoYWxsKSBmdW4gbWFpbih0eXBlczogW1R5cGVdKToge1R5cGU6IEJvb2w/fSB7CiAgICBsZXQgcmVzdWx0czoge1R5cGU6IEJvb2w/fSA9IHt9CiAgICBmb3IgdHlwZSBpbiB0eXBlcyB7CiAgICAgICAgaWYgcmVzdWx0c1t0eXBlXSAhPSBuaWwgewogICAgICAgICAgICBjb250aW51ZQogICAgICAgIH0KICAgICAgICByZXN1bHRzLmluc2VydChrZXk6IHR5cGUsIEZsb3dFVk1CcmlkZ2UudHlwZVJlcXVpcmVzT25ib2FyZGluZyh0eXBlKSkKICAgIH0KICAgIHJldHVybiByZXN1bHRzCn0K", + "bridgeNFTFromEvm": "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\u003d", + "bridgeNFTFromEvmToFlow": "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\u003d", + "bridgeNFTFromEvmToFlowV2": "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\u003d\u003d", + "bridgeNFTFromEvmToFlowV3": "// Flow Wallet - mainnet Script  bridgeNFTFromEvmToFlowV3 - v2.78
// <platform_info>

import MetadataViews from 0x1d7e57aa55817448

import ViewResolver from 0x1d7e57aa55817448

import NonFungibleToken from 0x1d7e57aa55817448

import FungibleToken from 0xf233dcee88fe0abe

import FlowToken from 0x1654653399040a61

import FungibleTokenMetadataViews from 0xf233dcee88fe0abe

import ScopedFTProviders from 0x1e4aa0b87d10b141

import EVM from 0xe467b9dd11fa00df

import FlowEVMBridgeUtils from 0x1e4aa0b87d10b141

import FlowEVMBridge from 0x1e4aa0b87d10b141

import FlowEVMBridgeConfig from 0x1e4aa0b87d10b141

import StorageRent from 0x707adbad1428c624

import CrossVMMetadataViews from 0x1d7e57aa55817448


/// This transaction bridges an NFT from EVM to Cadence assuming it has already been onboarded to the FlowEVMBridge.
/// Also know that the recipient Flow account must have a Receiver capable of receiving the this bridged NFT accessible
/// via published Capability at the token's standard path.
/// NOTE: The ERC721 must have first been onboarded to the bridge. This can be checked via the method
///     FlowEVMBridge.evmAddressRequiresOnboarding(address: self.evmContractAddress)
///
/// @param nftIdentifier: The Cadence type identifier of the NFT to bridge - e.g. nft.getType().identifier
/// @param id: The ERC721 id of the NFT to bridge to Cadence from EVM
/// @param recipient: The Flow account address to receive the bridged NFT
///
transaction(nftIdentifier: String, id: UInt256, recipient: Address) {
    let nftType: Type
    let receiver: &{NonFungibleToken.Receiver}
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let coa: auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount
    let viewResolver: &{ViewResolver}

    prepare(signer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        /* --- Construct the NFT type --- */
        //
        // Construct the NFT type from the provided identifier
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        // Parse the NFT identifier into its components
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: self.nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Reference the recipient's NFT Receiver --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: self.nftType,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        // Configure the signer's account for this NFT
        if signer.storage.borrow<&{NonFungibleToken.Collection}>(from: collectionData.storagePath) == nil {
            signer.storage.save(<-collectionData.createEmptyCollection(), to: collectionData.storagePath)
            signer.capabilities.unpublish(collectionData.publicPath)
            let collectionCap = signer.capabilities.storage.issue<&{NonFungibleToken.Collection}>(collectionData.storagePath)
            signer.capabilities.publish(collectionCap, at: collectionData.publicPath)
        }
        self.receiver = getAccount(recipient).capabilities.borrow<&{NonFungibleToken.Receiver}>(collectionData.publicPath)
            ?? panic("Could not borrow Receiver from recipient's public capability path")

        /* --- Configure a ScopedFTProvider --- */
        //
        // Calculate the bridge fee - bridging from EVM consumes no storage, so flat fee
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000)
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    execute {
        // Unwrap NFTs from project-defined ERC721 wrapper contract if applicable
        unwrapNFTsIfApplicable(self.coa, nftIDs: [id], nftType: self.nftType, viewResolver: self.viewResolver)

        // Execute the bridge
        let nft: @{NonFungibleToken.NFT} <- self.coa.withdrawNFT(
            type: self.nftType,
            id: id,
            feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        // Ensure the bridged nft is the correct type
        assert(
            nft.getType() == self.nftType,
            message: "Bridged nft type mismatch - requested: ".concat(self.nftType.identifier)
                .concat(", received: ").concat(nft.getType().identifier)
        )
        // Deposit the bridged NFT into the signer's collection
        self.receiver.deposit(token: <-nft)
        // Destroy the ScopedFTProvider
        destroy self.scopedProvider
        StorageRent.tryRefill(recipient)

    }
}

/// Unwraps NFTs from a project's custom ERC721 wrapper contract to bridged NFTs on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
///
access(all) fun unwrapNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt256],
    nftType: Type,
    viewResolver: &{ViewResolver}
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            for id in nftIDs {
                // Unwrap NFT if it is wrapped
                if isNFTWrapped(coa,
                    nftID: id,
                    underlying: underlyingAddress,
                    wrapper: crossVMPointer.evmContractAddress
                ) {
                    let res = mustCall(coa, crossVMPointer.evmContractAddress,
                        functionSig: "withdrawTo(address,uint256[])",
                        args: [coa.address(), [id]]
                    )
                    let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                    assert(decodedRes.length == 1, message: "Invalid response length")
                    assert(decodedRes[0] as! Bool, message: "Failed to unwrap NFT")
                }
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is wrapped in the underlying ERC721 contract
///
access(all) fun isNFTWrapped(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftID: UInt256,
    underlying: EVM.EVMAddress,
    wrapper: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: underlying,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return false
    if res.status != EVM.Status.successful || res.data.length == 0{
        return false
    }

    // Decode and compare the addresses
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")

    let owner = decodedResult[0] as! EVM.EVMAddress
    return owner.toString() == wrapper.toString()
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", + "bridgeNFTFromEvmToFlowWithPayer": "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\u003d\u003d", + "bridgeNFTFromEvmV2": "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\u003d", + "bridgeNFTFromEvmWithPayer": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYnJpZGdlTkZURnJvbUV2bVdpdGhQYXllciAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IE1ldGFkYXRhVmlld3MgZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCmltcG9ydCBWaWV3UmVzb2x2ZXIgZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCmltcG9ydCBOb25GdW5naWJsZVRva2VuIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKaW1wb3J0IEZsb3dUb2tlbiBmcm9tIDB4MTY1NDY1MzM5OTA0MGE2MQoKaW1wb3J0IEZ1bmdpYmxlVG9rZW5NZXRhZGF0YVZpZXdzIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgppbXBvcnQgU2NvcGVkRlRQcm92aWRlcnMgZnJvbSAweDFlNGFhMGI4N2QxMGIxNDEKCmltcG9ydCBFVk0gZnJvbSAweGU0NjdiOWRkMTFmYTAwZGYKCmltcG9ydCBGbG93RVZNQnJpZGdlVXRpbHMgZnJvbSAweDFlNGFhMGI4N2QxMGIxNDEKCmltcG9ydCBGbG93RVZNQnJpZGdlIGZyb20gMHgxZTRhYTBiODdkMTBiMTQxCgppbXBvcnQgRmxvd0VWTUJyaWRnZUNvbmZpZyBmcm9tIDB4MWU0YWEwYjg3ZDEwYjE0MQoKaW1wb3J0IENyb3NzVk1NZXRhZGF0YVZpZXdzIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgoKLy8vIFRoaXMgdHJhbnNhY3Rpb24gYnJpZGdlcyBhbiBORlQgZnJvbSBFVk0gdG8gQ2FkZW5jZSBhc3N1bWluZyBpdCBoYXMgYWxyZWFkeSBiZWVuIG9uYm9hcmRlZCB0byB0aGUgRmxvd0VWTUJyaWRnZQovLy8gTk9URTogVGhlIEVSQzcyMSBtdXN0IGhhdmUgZmlyc3QgYmVlbiBvbmJvYXJkZWQgdG8gdGhlIGJyaWRnZS4gVGhpcyBjYW4gYmUgY2hlY2tlZCB2aWEgdGhlIG1ldGhvZAovLy8gICAgIEZsb3dFVk1CcmlkZ2UuZXZtQWRkcmVzc1JlcXVpcmVzT25ib2FyZGluZyhhZGRyZXNzOiBzZWxmLmV2bUNvbnRyYWN0QWRkcmVzcykKLy8vCi8vLyBAcGFyYW0gbmZ0SWRlbnRpZmllcjogVGhlIENhZGVuY2UgdHlwZSBpZGVudGlmaWVyIG9mIHRoZSBORlQgdG8gYnJpZGdlIC0gZS5nLiBuZnQuZ2V0VHlwZSgpLmlkZW50aWZpZXIKLy8vIEBwYXJhbSBpZDogVGhlIEVSQzcyMSBpZCBvZiB0aGUgTkZUIHRvIGJyaWRnZSB0byBDYWRlbmNlIGZyb20gRVZNCi8vLwp0cmFuc2FjdGlvbihuZnRJZGVudGlmaWVyOiBTdHJpbmcsIGlkOiBVSW50MjU2KSB7CgogICAgbGV0IG5mdFR5cGU6IFR5cGUKICAgIGxldCBjb2xsZWN0aW9uOiAme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0KICAgIGxldCBzY29wZWRQcm92aWRlcjogQFNjb3BlZEZUUHJvdmlkZXJzLlNjb3BlZEZUUHJvdmlkZXIKICAgIGxldCBjb2E6IGF1dGgoRVZNLkNhbGwsIEVWTS5CcmlkZ2UpICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudAogICAgbGV0IHZpZXdSZXNvbHZlcjogJntWaWV3UmVzb2x2ZXJ9CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoQm9ycm93VmFsdWUsIENvcHlWYWx1ZSwgSXNzdWVTdG9yYWdlQ2FwYWJpbGl0eUNvbnRyb2xsZXIsIFB1Ymxpc2hDYXBhYmlsaXR5LCBTYXZlVmFsdWUsIFVucHVibGlzaENhcGFiaWxpdHkpICZBY2NvdW50LCBwYXllcjogYXV0aChCb3Jyb3dWYWx1ZSwgQ29weVZhbHVlLCBJc3N1ZVN0b3JhZ2VDYXBhYmlsaXR5Q29udHJvbGxlciwgUHVibGlzaENhcGFiaWxpdHksIFNhdmVWYWx1ZSwgVW5wdWJsaXNoQ2FwYWJpbGl0eSkgJkFjY291bnQpIHsKICAgICAgICAvKiAtLS0gUmVmZXJlbmNlIHRoZSBzaWduZXIncyBDYWRlbmNlT3duZWRBY2NvdW50IC0tLSAqLwogICAgICAgIC8vCiAgICAgICAgLy8gQm9ycm93IGEgcmVmZXJlbmNlIHRvIHRoZSBzaWduZXIncyBDT0EKICAgICAgICBzZWxmLmNvYSA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEVWTS5DYWxsLCBFVk0uQnJpZGdlKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KGZyb206IC9zdG9yYWdlL2V2bSkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgQ09BIGZyb20gcHJvdmlkZWQgZ2F0ZXdheSBhZGRyZXNzIikKCiAgICAgICAgLyogLS0tIENvbnN0cnVjdCB0aGUgTkZUIHR5cGUgLS0tICovCiAgICAgICAgLy8KICAgICAgICAvLyBDb25zdHJ1Y3QgdGhlIE5GVCB0eXBlIGZyb20gdGhlIHByb3ZpZGVkIGlkZW50aWZpZXIKICAgICAgICBzZWxmLm5mdFR5cGUgPSBDb21wb3NpdGVUeXBlKG5mdElkZW50aWZpZXIpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgY29uc3RydWN0IE5GVCB0eXBlIGZyb20gaWRlbnRpZmllcjogIi5jb25jYXQobmZ0SWRlbnRpZmllcikpCiAgICAgICAgLy8gUGFyc2UgdGhlIE5GVCBpZGVudGlmaWVyIGludG8gaXRzIGNvbXBvbmVudHMKICAgICAgICBsZXQgbmZ0Q29udHJhY3RBZGRyZXNzID0gRmxvd0VWTUJyaWRnZVV0aWxzLmdldENvbnRyYWN0QWRkcmVzcyhmcm9tVHlwZTogc2VsZi5uZnRUeXBlKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGdldCBjb250cmFjdCBhZGRyZXNzIGZyb20gaWRlbnRpZmllcjogIi5jb25jYXQobmZ0SWRlbnRpZmllcikpCiAgICAgICAgbGV0IG5mdENvbnRyYWN0TmFtZSA9IEZsb3dFVk1CcmlkZ2VVdGlscy5nZXRDb250cmFjdE5hbWUoZnJvbVR5cGU6IHNlbGYubmZ0VHlwZSkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBnZXQgY29udHJhY3QgbmFtZSBmcm9tIGlkZW50aWZpZXI6ICIuY29uY2F0KG5mdElkZW50aWZpZXIpKQoKICAgICAgICAvKiAtLS0gUmVmZXJlbmNlIHRoZSBzaWduZXIncyBORlQgQ29sbGVjdGlvbiAtLS0gKi8KICAgICAgICAvLwogICAgICAgIC8vIEJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgTkZUIGNvbGxlY3Rpb24sIGNvbmZpZ3VyaW5nIGlmIG5lY2Vzc2FyeQogICAgICAgIHNlbGYudmlld1Jlc29sdmVyID0gZ2V0QWNjb3VudChuZnRDb250cmFjdEFkZHJlc3MpLmNvbnRyYWN0cy5ib3Jyb3c8JntWaWV3UmVzb2x2ZXJ9PihuYW1lOiBuZnRDb250cmFjdE5hbWUpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IFZpZXdSZXNvbHZlciBmcm9tIE5GVCBjb250cmFjdCIpCiAgICAgICAgbGV0IGNvbGxlY3Rpb25EYXRhID0gc2VsZi52aWV3UmVzb2x2ZXIucmVzb2x2ZUNvbnRyYWN0VmlldygKICAgICAgICAgICAgICAgIHJlc291cmNlVHlwZTogc2VsZi5uZnRUeXBlLAogICAgICAgICAgICAgICAgdmlld1R5cGU6IFR5cGU8TWV0YWRhdGFWaWV3cy5ORlRDb2xsZWN0aW9uRGF0YT4oKQogICAgICAgICAgICApIGFzISBNZXRhZGF0YVZpZXdzLk5GVENvbGxlY3Rpb25EYXRhPyA/PyBwYW5pYygiQ291bGQgbm90IHJlc29sdmUgTkZUQ29sbGVjdGlvbkRhdGEgdmlldyIpCiAgICAgICAgaWYgc2lnbmVyLnN0b3JhZ2UuYm9ycm93PCZ7Tm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9ufT4oZnJvbTogY29sbGVjdGlvbkRhdGEuc3RvcmFnZVBhdGgpID09IG5pbCB7CiAgICAgICAgICAgIHNpZ25lci5zdG9yYWdlLnNhdmUoPC1jb2xsZWN0aW9uRGF0YS5jcmVhdGVFbXB0eUNvbGxlY3Rpb24oKSwgdG86IGNvbGxlY3Rpb25EYXRhLnN0b3JhZ2VQYXRoKQogICAgICAgICAgICBzaWduZXIuY2FwYWJpbGl0aWVzLnVucHVibGlzaChjb2xsZWN0aW9uRGF0YS5wdWJsaWNQYXRoKQogICAgICAgICAgICBsZXQgY29sbGVjdGlvbkNhcCA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTwme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0+KGNvbGxlY3Rpb25EYXRhLnN0b3JhZ2VQYXRoKQogICAgICAgICAgICBzaWduZXIuY2FwYWJpbGl0aWVzLnB1Ymxpc2goY29sbGVjdGlvbkNhcCwgYXQ6IGNvbGxlY3Rpb25EYXRhLnB1YmxpY1BhdGgpCiAgICAgICAgfQogICAgICAgIHNlbGYuY29sbGVjdGlvbiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzwme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0+KGZyb206IGNvbGxlY3Rpb25EYXRhLnN0b3JhZ2VQYXRoKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBjb2xsZWN0aW9uIGZyb20gc3RvcmFnZSBwYXRoIikKCiAgICAgICAgLyogLS0tIENvbmZpZ3VyZSBhIFNjb3BlZEZUUHJvdmlkZXIgLS0tICovCiAgICAgICAgLy8KICAgICAgICAvLyBDYWxjdWxhdGUgdGhlIGJyaWRnZSBmZWUgLSBicmlkZ2luZyBmcm9tIEVWTSBjb25zdW1lcyBubyBzdG9yYWdlLCBzbyBmbGF0IGZlZQogICAgICAgIGxldCBhcHByb3hGZWUgPSBGbG93RVZNQnJpZGdlVXRpbHMuY2FsY3VsYXRlQnJpZGdlRmVlKGJ5dGVzOiA0MDBfMDAwKQogICAgICAgIC8vIElzc3VlIGFuZCBzdG9yZSBicmlkZ2UtZGVkaWNhdGVkIFByb3ZpZGVyIENhcGFiaWxpdHkgaW4gc3RvcmFnZSBpZiBuZWNlc3NhcnkKICAgICAgICBpZiBwYXllci5zdG9yYWdlLnR5cGUoYXQ6IEZsb3dFVk1CcmlkZ2VDb25maWcucHJvdmlkZXJDYXBhYmlsaXR5U3RvcmFnZVBhdGgpID09IG5pbCB7CiAgICAgICAgICAgIGxldCBwcm92aWRlckNhcCA9IHBheWVyLmNhcGFiaWxpdGllcy5zdG9yYWdlLmlzc3VlPGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntGdW5naWJsZVRva2VuLlByb3ZpZGVyfT4oCiAgICAgICAgICAgICAgICAvc3RvcmFnZS9mbG93VG9rZW5WYXVsdAogICAgICAgICAgICApCiAgICAgICAgICAgIHBheWVyLnN0b3JhZ2Uuc2F2ZShwcm92aWRlckNhcCwgdG86IEZsb3dFVk1CcmlkZ2VDb25maWcucHJvdmlkZXJDYXBhYmlsaXR5U3RvcmFnZVBhdGgpCiAgICAgICAgfQogICAgICAgIC8vIENvcHkgdGhlIHN0b3JlZCBQcm92aWRlciBjYXBhYmlsaXR5IGFuZCBjcmVhdGUgYSBTY29wZWRGVFByb3ZpZGVyCiAgICAgICAgbGV0IHByb3ZpZGVyQ2FwQ29weSA9IHBheWVyLnN0b3JhZ2UuY29weTxDYXBhYmlsaXR5PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntGdW5naWJsZVRva2VuLlByb3ZpZGVyfT4+KAogICAgICAgICAgICAgICAgZnJvbTogRmxvd0VWTUJyaWRnZUNvbmZpZy5wcm92aWRlckNhcGFiaWxpdHlTdG9yYWdlUGF0aAogICAgICAgICAgICApID8/IHBhbmljKCJJbnZhbGlkIFByb3ZpZGVyIENhcGFiaWxpdHkgZm91bmQgaW4gc3RvcmFnZS4iKQogICAgICAgIGxldCBwcm92aWRlckZpbHRlciA9IFNjb3BlZEZUUHJvdmlkZXJzLkFsbG93YW5jZUZpbHRlcihhcHByb3hGZWUpCiAgICAgICAgc2VsZi5zY29wZWRQcm92aWRlciA8LSBTY29wZWRGVFByb3ZpZGVycy5jcmVhdGVTY29wZWRGVFByb3ZpZGVyKAogICAgICAgICAgICAgICAgcHJvdmlkZXI6IHByb3ZpZGVyQ2FwQ29weSwKICAgICAgICAgICAgICAgIGZpbHRlcnM6IFsgcHJvdmlkZXJGaWx0ZXIgXSwKICAgICAgICAgICAgICAgIGV4cGlyYXRpb246IGdldEN1cnJlbnRCbG9jaygpLnRpbWVzdGFtcCArIDEuMAogICAgICAgICAgICApCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgLy8gVW53cmFwIE5GVHMgZnJvbSBwcm9qZWN0LWRlZmluZWQgRVJDNzIxIHdyYXBwZXIgY29udHJhY3QgaWYgYXBwbGljYWJsZQogICAgICAgIHVud3JhcE5GVHNJZkFwcGxpY2FibGUoc2VsZi5jb2EsIG5mdElEczogW2lkXSwgbmZ0VHlwZTogc2VsZi5uZnRUeXBlLCB2aWV3UmVzb2x2ZXI6IHNlbGYudmlld1Jlc29sdmVyKQoKICAgICAgICAvLyBFeGVjdXRlIHRoZSBicmlkZ2UKICAgICAgICBsZXQgbmZ0OiBAe05vbkZ1bmdpYmxlVG9rZW4uTkZUfSA8LSBzZWxmLmNvYS53aXRoZHJhd05GVCgKICAgICAgICAgICAgdHlwZTogc2VsZi5uZnRUeXBlLAogICAgICAgICAgICBpZDogaWQsCiAgICAgICAgICAgIGZlZVByb3ZpZGVyOiAmc2VsZi5zY29wZWRQcm92aWRlciBhcyBhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0KICAgICAgICApCiAgICAgICAgLy8gRW5zdXJlIHRoZSBicmlkZ2VkIG5mdCBpcyB0aGUgY29ycmVjdCB0eXBlCiAgICAgICAgYXNzZXJ0KAogICAgICAgICAgICBuZnQuZ2V0VHlwZSgpID09IHNlbGYubmZ0VHlwZSwKICAgICAgICAgICAgbWVzc2FnZTogIkJyaWRnZWQgbmZ0IHR5cGUgbWlzbWF0Y2ggLSByZXF1ZXN0ZWQ6ICIuY29uY2F0KHNlbGYubmZ0VHlwZS5pZGVudGlmaWVyKQogICAgICAgICAgICAgICAgLmNvbmNhdCgiLCByZWNlaXZlZDogIikuY29uY2F0KG5mdC5nZXRUeXBlKCkuaWRlbnRpZmllcikKICAgICAgICApCiAgICAgICAgLy8gRGVwb3NpdCB0aGUgYnJpZGdlZCBORlQgaW50byB0aGUgc2lnbmVyJ3MgY29sbGVjdGlvbgogICAgICAgIHNlbGYuY29sbGVjdGlvbi5kZXBvc2l0KHRva2VuOiA8LW5mdCkKICAgICAgICAvLyBEZXN0cm95IHRoZSBTY29wZWRGVFByb3ZpZGVyCiAgICAgICAgZGVzdHJveSBzZWxmLnNjb3BlZFByb3ZpZGVyCiAgICB9Cn0KCi8vLyBVbndyYXBzIE5GVHMgZnJvbSBhIHByb2plY3QncyBjdXN0b20gRVJDNzIxIHdyYXBwZXIgY29udHJhY3QgdG8gYnJpZGdlZCBORlRzIG9uIEVWTSwgaWYgYXBwbGljYWJsZS4KLy8vIEVuYWJsZXMgcHJvamVjdHMgdG8gdXNlIHRoZWlyIG93biBFUkM3MjEgY29udHJhY3Qgd2hpbGUgbGV2ZXJhZ2luZyB0aGUgYnJpZGdlJ3MgdW5kZXJseWluZyBjb250cmFjdCwKLy8vIHVudGlsIGRpcmVjdCBjdXN0b20gY29udHJhY3Qgc3VwcG9ydCBpcyBhZGRlZCB0byB0aGUgYnJpZGdlLgovLy8KLy8vIEBwYXJhbSBjb2E6IFRoZSBDT0Egb2YgdGhlIHNpZ25lcgovLy8gQHBhcmFtIG5mdElEczogVGhlIElEcyBvZiB0aGUgTkZUcyB0byB3cmFwCi8vLyBAcGFyYW0gbmZ0VHlwZTogVGhlIHR5cGUgb2YgdGhlIE5GVHMgdG8gd3JhcAovLy8gQHBhcmFtIHZpZXdSZXNvbHZlcjogVGhlIFZpZXdSZXNvbHZlciBvZiB0aGUgTkZUIGNvbnRyYWN0Ci8vLwphY2Nlc3MoYWxsKSBmdW4gdW53cmFwTkZUc0lmQXBwbGljYWJsZSgKICAgIF8gY29hOiBhdXRoKEVWTS5DYWxsKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQsCiAgICBuZnRJRHM6IFtVSW50MjU2XSwKICAgIG5mdFR5cGU6IFR5cGUsCiAgICB2aWV3UmVzb2x2ZXI6ICZ7Vmlld1Jlc29sdmVyfQopIHsKICAgIC8vIEdldCB0aGUgcHJvamVjdC1kZWZpbmVkIEVSQzcyMSBhZGRyZXNzIGlmIGl0IGV4aXN0cwogICAgaWYgbGV0IGNyb3NzVk1Qb2ludGVyID0gdmlld1Jlc29sdmVyLnJlc29sdmVDb250cmFjdFZpZXcoCiAgICAgICAgICAgIHJlc291cmNlVHlwZTogbmZ0VHlwZSwKICAgICAgICAgICAgdmlld1R5cGU6IFR5cGU8Q3Jvc3NWTU1ldGFkYXRhVmlld3MuRVZNUG9pbnRlcj4oKQogICAgKSBhcyEgQ3Jvc3NWTU1ldGFkYXRhVmlld3MuRVZNUG9pbnRlcj8gewogICAgICAgIC8vIEdldCB0aGUgdW5kZXJseWluZyBFUkM3MjEgYWRkcmVzcyBpZiBpdCBleGlzdHMKICAgICAgICBpZiBsZXQgdW5kZXJseWluZ0FkZHJlc3MgPSBnZXRVbmRlcmx5aW5nRVJDNzIxQWRkcmVzcyhjb2EsIGNyb3NzVk1Qb2ludGVyLmV2bUNvbnRyYWN0QWRkcmVzcykgewogICAgICAgICAgICBmb3IgaWQgaW4gbmZ0SURzIHsKICAgICAgICAgICAgICAgIC8vIFVud3JhcCBORlQgaWYgaXQgaXMgd3JhcHBlZAogICAgICAgICAgICAgICAgaWYgaXNORlRXcmFwcGVkKGNvYSwKICAgICAgICAgICAgICAgICAgICBuZnRJRDogaWQsCiAgICAgICAgICAgICAgICAgICAgdW5kZXJseWluZzogdW5kZXJseWluZ0FkZHJlc3MsCiAgICAgICAgICAgICAgICAgICAgd3JhcHBlcjogY3Jvc3NWTVBvaW50ZXIuZXZtQ29udHJhY3RBZGRyZXNzCiAgICAgICAgICAgICAgICApIHsKICAgICAgICAgICAgICAgICAgICBsZXQgcmVzID0gbXVzdENhbGwoY29hLCBjcm9zc1ZNUG9pbnRlci5ldm1Db250cmFjdEFkZHJlc3MsCiAgICAgICAgICAgICAgICAgICAgICAgIGZ1bmN0aW9uU2lnOiAid2l0aGRyYXdUbyhhZGRyZXNzLHVpbnQyNTZbXSkiLAogICAgICAgICAgICAgICAgICAgICAgICBhcmdzOiBbY29hLmFkZHJlc3MoKSwgW2lkXV0KICAgICAgICAgICAgICAgICAgICApCiAgICAgICAgICAgICAgICAgICAgbGV0IGRlY29kZWRSZXMgPSBFVk0uZGVjb2RlQUJJKHR5cGVzOiBbVHlwZTxCb29sPigpXSwgZGF0YTogcmVzLmRhdGEpCiAgICAgICAgICAgICAgICAgICAgYXNzZXJ0KGRlY29kZWRSZXMubGVuZ3RoID09IDEsIG1lc3NhZ2U6ICJJbnZhbGlkIHJlc3BvbnNlIGxlbmd0aCIpCiAgICAgICAgICAgICAgICAgICAgYXNzZXJ0KGRlY29kZWRSZXNbMF0gYXMhIEJvb2wsIG1lc3NhZ2U6ICJGYWlsZWQgdG8gdW53cmFwIE5GVCIpCiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgIH0KICAgICAgICB9CiAgICB9Cn0KCi8vLyBHZXRzIHRoZSB1bmRlcmx5aW5nIEVSQzcyMSBhZGRyZXNzIGlmIGl0IGV4aXN0cyAoaS5lLiBpZiB0aGUgRVJDNzIxIGlzIGEgd3JhcHBlcikKLy8vCmFjY2VzcyhhbGwpIGZ1biBnZXRVbmRlcmx5aW5nRVJDNzIxQWRkcmVzcygKICAgIF8gY29hOiBhdXRoKEVWTS5DYWxsKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQsCiAgICBfIHdyYXBwZXJBZGRyZXNzOiBFVk0uRVZNQWRkcmVzcwopOiBFVk0uRVZNQWRkcmVzcz8gewogICAgbGV0IHJlcyA9IGNvYS5jYWxsKAogICAgICAgIHRvOiB3cmFwcGVyQWRkcmVzcywKICAgICAgICBkYXRhOiBFVk0uZW5jb2RlQUJJV2l0aFNpZ25hdHVyZSgidW5kZXJseWluZygpIiwgW10pLAogICAgICAgIGdhc0xpbWl0OiAxMDBfMDAwLAogICAgICAgIHZhbHVlOiBFVk0uQmFsYW5jZShhdHRvZmxvdzogMCkKICAgICkKCiAgICAvLyBJZiB0aGUgY2FsbCBmYWlscywgcmV0dXJuIG5pbAogICAgaWYgcmVzLnN0YXR1cyAhPSBFVk0uU3RhdHVzLnN1Y2Nlc3NmdWwgfHwgcmVzLmRhdGEubGVuZ3RoID09IDAgewogICAgICAgIHJldHVybiBuaWwKICAgIH0KCiAgICAvLyBEZWNvZGUgYW5kIHJldHVybiB0aGUgdW5kZXJseWluZyBFUkM3MjEgYWRkcmVzcwogICAgbGV0IGRlY29kZWRSZXN1bHQgPSBFVk0uZGVjb2RlQUJJKAogICAgICAgIHR5cGVzOiBbVHlwZTxFVk0uRVZNQWRkcmVzcz4oKV0sCiAgICAgICAgZGF0YTogcmVzLmRhdGEKICAgICkKICAgIGFzc2VydChkZWNvZGVkUmVzdWx0Lmxlbmd0aCA9PSAxLCBtZXNzYWdlOiAiSW52YWxpZCByZXNwb25zZSBsZW5ndGgiKQogICAgcmV0dXJuIGRlY29kZWRSZXN1bHRbMF0gYXMhIEVWTS5FVk1BZGRyZXNzCn0KCi8vLyBDaGVja3MgaWYgdGhlIHByb3ZpZGVkIE5GVCBpcyB3cmFwcGVkIGluIHRoZSB1bmRlcmx5aW5nIEVSQzcyMSBjb250cmFjdAovLy8KYWNjZXNzKGFsbCkgZnVuIGlzTkZUV3JhcHBlZCgKICAgIF8gY29hOiBhdXRoKEVWTS5DYWxsKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQsCiAgICBuZnRJRDogVUludDI1NiwKICAgIHVuZGVybHlpbmc6IEVWTS5FVk1BZGRyZXNzLAogICAgd3JhcHBlcjogRVZNLkVWTUFkZHJlc3MKKTogQm9vbCB7CiAgICBsZXQgcmVzID0gY29hLmNhbGwoCiAgICAgICAgdG86IHVuZGVybHlpbmcsCiAgICAgICAgZGF0YTogRVZNLmVuY29kZUFCSVdpdGhTaWduYXR1cmUoIm93bmVyT2YodWludDI1NikiLCBbbmZ0SURdKSwKICAgICAgICBnYXNMaW1pdDogMTAwXzAwMCwKICAgICAgICB2YWx1ZTogRVZNLkJhbGFuY2UoYXR0b2Zsb3c6IDApCiAgICApCgogICAgLy8gSWYgdGhlIGNhbGwgZmFpbHMsIHJldHVybiBmYWxzZQogICAgaWYgcmVzLnN0YXR1cyAhPSBFVk0uU3RhdHVzLnN1Y2Nlc3NmdWwgfHwgcmVzLmRhdGEubGVuZ3RoID09IDB7CiAgICAgICAgcmV0dXJuIGZhbHNlCiAgICB9CgogICAgLy8gRGVjb2RlIGFuZCBjb21wYXJlIHRoZSBhZGRyZXNzZXMKICAgIGxldCBkZWNvZGVkUmVzdWx0ID0gRVZNLmRlY29kZUFCSSgKICAgICAgICB0eXBlczogW1R5cGU8RVZNLkVWTUFkZHJlc3M+KCldLAogICAgICAgIGRhdGE6IHJlcy5kYXRhCiAgICApCiAgICBhc3NlcnQoZGVjb2RlZFJlc3VsdC5sZW5ndGggPT0gMSwgbWVzc2FnZTogIkludmFsaWQgcmVzcG9uc2UgbGVuZ3RoIikKICAgIGxldCBvd25lciA9IGRlY29kZWRSZXN1bHRbMF0gYXMhIEVWTS5FVk1BZGRyZXNzCiAgICByZXR1cm4gb3duZXIudG9TdHJpbmcoKSA9PSB3cmFwcGVyLnRvU3RyaW5nKCkKfQoKLy8vIENhbGxzIGEgZnVuY3Rpb24gb24gYW4gRVZNIGNvbnRyYWN0IGZyb20gcHJvdmlkZWQgY29hCi8vLwphY2Nlc3MoYWxsKSBmdW4gbXVzdENhbGwoCiAgICBfIGNvYTogYXV0aChFVk0uQ2FsbCkgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50LAogICAgXyBjb250cmFjdEFkZHI6IEVWTS5FVk1BZGRyZXNzLAogICAgZnVuY3Rpb25TaWc6IFN0cmluZywKICAgIGFyZ3M6IFtBbnlTdHJ1Y3RdCik6IEVWTS5SZXN1bHQgewogICAgbGV0IHJlcyA9IGNvYS5jYWxsKAogICAgICAgIHRvOiBjb250cmFjdEFkZHIsCiAgICAgICAgZGF0YTogRVZNLmVuY29kZUFCSVdpdGhTaWduYXR1cmUoZnVuY3Rpb25TaWcsIGFyZ3MpLAogICAgICAgIGdhc0xpbWl0OiA0XzAwMF8wMDAsCiAgICAgICAgdmFsdWU6IEVWTS5CYWxhbmNlKGF0dG9mbG93OiAwKQogICAgKQoKICAgIGFzc2VydChyZXMuc3RhdHVzID09IEVWTS5TdGF0dXMuc3VjY2Vzc2Z1bCwKICAgICAgICBtZXNzYWdlOiAiRmFpbGVkIHRvIGNhbGwgJyIuY29uY2F0KGZ1bmN0aW9uU2lnKQogICAgICAgICAgICAuY29uY2F0KCJcblx0IGVycm9yIGNvZGU6ICIpLmNvbmNhdChyZXMuZXJyb3JDb2RlLnRvU3RyaW5nKCkpCiAgICAgICAgICAgIC5jb25jYXQoIlxuXHQgZXJyb3IgbWVzc2FnZTogIikuY29uY2F0KHJlcy5lcnJvck1lc3NhZ2UpCiAgICAgICAgICAgIC5jb25jYXQoIlxuXHQgZ2FzIHVzZWQ6ICIpLmNvbmNhdChyZXMuZ2FzVXNlZC50b1N0cmluZygpKQogICAgICAgICAgICAuY29uY2F0KCJcblx0IGNhbGxlciBhZGRyZXNzOiAweCIpLmNvbmNhdChjb2EuYWRkcmVzcygpLnRvU3RyaW5nKCkpCiAgICAgICAgICAgIC5jb25jYXQoIlxuXHQgY29udHJhY3QgYWRkcmVzczogMHgiKS5jb25jYXQoY29udHJhY3RBZGRyLnRvU3RyaW5nKCkpCiAgICApCgogICAgcmV0dXJuIHJlcwp9Cg\u003d\u003d", + "bridgeNFTToEvm": "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\u003d", + "bridgeNFTToEvmAddress": "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\u003d", + "bridgeNFTToEvmAddressV2": "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\u003d", + "bridgeNFTToEvmAddressWithPayer": "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\u003d\u003d", + "bridgeNFTToEvmV2": "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\u003d\u003d", + "bridgeNFTToEvmWithPayer": "// Flow Wallet - mainnet Script  bridgeNFTToEvmWithPayer - v2.78
// <platform_info>

import MetadataViews from 0x1d7e57aa55817448

import ViewResolver from 0x1d7e57aa55817448

import NonFungibleToken from 0x1d7e57aa55817448

import FungibleToken from 0xf233dcee88fe0abe

import FlowToken from 0x1654653399040a61

import FungibleTokenMetadataViews from 0xf233dcee88fe0abe

import ScopedFTProviders from 0x1e4aa0b87d10b141

import EVM from 0xe467b9dd11fa00df

import FlowEVMBridgeUtils from 0x1e4aa0b87d10b141

import FlowEVMBridge from 0x1e4aa0b87d10b141

import FlowEVMBridgeConfig from 0x1e4aa0b87d10b141

import CrossVMMetadataViews from 0x1d7e57aa55817448


/// Bridges an NFT from the signer's collection in Cadence to the signer's COA in FlowEVM
///
/// NOTE: This transaction also onboards the NFT to the bridge if necessary which may incur additional fees
///     than bridging an asset that has already been onboarded.
///
/// @param nftIdentifier: The Cadence type identifier of the NFT to bridge - e.g. nft.getType().identifier
/// @param id: The Cadence NFT.id of the NFT to bridge to EVM
///
transaction(nftIdentifier: String, id: UInt64) {

    let nft: @{NonFungibleToken.NFT}
    let coa: auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount
    let requiresOnboarding: Bool
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let nftType: Type
    let viewResolver: &{ViewResolver}

    prepare(signer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account, payer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        /* --- Construct the NFT type --- */
        //
        // Construct the NFT type from the provided identifier
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        // Parse the NFT identifier into its components
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: self.nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Retrieve the NFT --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: self.nftType,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        let collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            ) ?? panic("Could not access signer's NFT Collection")

        // Withdraw the requested NFT & calculate the approximate bridge fee based on NFT storage usage
        let currentStorageUsage = signer.storage.used
        self.nft <- collection.withdraw(withdrawID: id)
        let withdrawnStorageUsage = signer.storage.used
        var approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000) + FlowEVMBridgeConfig.baseFee
        // Determine if the NFT requires onboarding - this impacts the fee required
        self.requiresOnboarding = FlowEVMBridge.typeRequiresOnboarding(self.nft.getType())
            ?? panic("Bridge does not support this asset type")
        if self.requiresOnboarding {
            approxFee = approxFee + FlowEVMBridgeConfig.onboardFee
        }

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if payer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = payer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            payer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = payer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    pre {
        self.nft.getType().identifier == nftIdentifier:
            "Attempting to send invalid nft type - requested: ".concat(nftIdentifier)
            .concat(", sending: ").concat(self.nft.getType().identifier)
    }

    execute {
        if self.requiresOnboarding {
            // Onboard the NFT to the bridge
            FlowEVMBridge.onboardByType(
                self.nft.getType(),
                feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
        }

        // Execute the bridge
        self.coa.depositNFT(
            nft: <-self.nft,
            feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        // Destroy the ScopedFTProvider
        destroy self.scopedProvider

        // Wrap NFTs if applicable
        wrapAndTransferNFTsIfApplicable(self.coa,
            nftIDs: [id],
            nftType: self.nftType,
            viewResolver: self.viewResolver,
            recipientIfNotCoa: nil
        )
    }
}

/// Wraps and transfers bridged NFTs into a project's custom ERC721 wrapper contract on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
/// @param recipientIfNotCoa: The EVM address to transfer the wrapped NFTs to, nil if the NFTs should stay in signer's COA
///
access(all) fun wrapAndTransferNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt64],
    nftType: Type,
    viewResolver: &{ViewResolver},
    recipientIfNotCoa: EVM.EVMAddress?
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            // Wrap NFTs if underlying ERC721 address matches bridge's associated address for NFT type
            if underlyingAddress.equals(FlowEVMBridgeConfig.getEVMAddressAssociated(with: nftType)!) {
                // Approve contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, true]
                )

                // Wrap NFTs with provided IDs, and check if the call was successful
                let res = mustCall(coa, crossVMPointer.evmContractAddress,
                    functionSig: "depositFor(address,uint256[])",
                    args: [coa.address(), nftIDs]
                )
                let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                assert(decodedRes.length == 1, message: "Invalid response length")
                assert(decodedRes[0] as! Bool, message: "Failed to wrap NFTs")

                // Transfer NFTs to recipient if provided
                if let to = recipientIfNotCoa {
                    mustTransferNFTs(coa, crossVMPointer.evmContractAddress, nftIDs: nftIDs, to: to)
                }

                // Revoke approval for contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, false]
                )
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is owned by the provided EVM address
///
access(all) fun isOwner(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    _ nftID: UInt64,
    _ ownerToCheck: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: erc721Address,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )
    assert(res.status == EVM.Status.successful, message: "Call to ERC721.ownerOf(uint256) failed")
    let decodedRes = EVM.decodeABI(types: [Type<EVM.EVMAddress>()], data: res.data)
    if decodedRes.length == 1 {
        let actualOwner = decodedRes[0] as! EVM.EVMAddress
        return actualOwner.equals(ownerToCheck)
    }
    return false
}

/// Transfers NFTs from the provided COA to the provided EVM address
///
access(all) fun mustTransferNFTs(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    nftIDs: [UInt64],
    to: EVM.EVMAddress
) {
    for id in nftIDs {
        assert(isOwner(coa, erc721Address, id, coa.address()), message: "NFT not owned by signer's COA")
        mustCall(coa, erc721Address,
            functionSig: "safeTransferFrom(address,address,uint256)",
            args: [coa.address(), to, id]
        )
        assert(isOwner(coa, erc721Address, id, to), message: "NFT not transferred to recipient")
    }
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", + "bridgeTokensFromEoaToFlowV3": "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\u003d\u003d", + "bridgeTokensFromEvm": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYnJpZGdlVG9rZW5zRnJvbUV2bSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDE2NTQ2NTMzOTkwNDBhNjEKCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgVmlld1Jlc29sdmVyIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4MWQ3ZTU3YWE1NTgxNzQ0OAoKaW1wb3J0IEZ1bmdpYmxlVG9rZW5NZXRhZGF0YVZpZXdzIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgoKaW1wb3J0IFNjb3BlZEZUUHJvdmlkZXJzIGZyb20gMHgxZTRhYTBiODdkMTBiMTQxCgoKaW1wb3J0IEVWTSBmcm9tIDB4ZTQ2N2I5ZGQxMWZhMDBkZgoKCmltcG9ydCBGbG93RVZNQnJpZGdlVXRpbHMgZnJvbSAweDFlNGFhMGI4N2QxMGIxNDEKCmltcG9ydCBGbG93RVZNQnJpZGdlIGZyb20gMHgxZTRhYTBiODdkMTBiMTQxCgppbXBvcnQgRmxvd0VWTUJyaWRnZUNvbmZpZyBmcm9tIDB4MWU0YWEwYjg3ZDEwYjE0MQoKCi8vLy8gVGhpcyB0cmFuc2FjdGlvbiBicmlkZ2VzIGZ1bmdpYmxlIHRva2VucyBmcm9tIEVWTSB0byBDYWRlbmNlIGFzc3VtaW5nIGl0IGhhcyBhbHJlYWR5IGJlZW4gb25ib2FyZGVkIHRvIHRoZQovLy8gRmxvd0VWTUJyaWRnZS4KLy8vCi8vLyBOT1RFOiBUaGUgRVJDNzIxIG11c3QgaGF2ZSBmaXJzdCBiZWVuIG9uYm9hcmRlZCB0byB0aGUgYnJpZGdlLiBUaGlzIGNhbiBiZSBjaGVja2VkIHZpYSB0aGUgbWV0aG9kCi8vLyAgICAgRmxvd0VWTUJyaWRnZS5ldm1BZGRyZXNzUmVxdWlyZXNPbmJvYXJkaW5nKGFkZHJlc3M6IHNlbGYuZXZtQ29udHJhY3RBZGRyZXNzKQovLy8KLy8vIEBwYXJhbSB0b2tlbkNvbnRyYWN0QWRkcmVzczogVGhlIEZsb3cgYWNjb3VudCBhZGRyZXNzIGhvc3RpbmcgdGhlIEZULWRlZmluaW5nIENhZGVuY2UgY29udHJhY3QKLy8vIEBwYXJhbSB0b2tlbkNvbnRyYWN0TmFtZTogVGhlIG5hbWUgb2YgdGhlIFZhdWx0LWRlZmluaW5nIENhZGVuY2UgY29udHJhY3QKLy8vIEBwYXJhbSBhbW91bnQ6IFRoZSBhbW91bnQgb2YgdG9rZW5zIHRvIGJyaWRnZSBmcm9tIEVWTQovLy8KdHJhbnNhY3Rpb24odG9rZW5Db250cmFjdEFkZHJlc3M6IEFkZHJlc3MsIHRva2VuQ29udHJhY3ROYW1lOiBTdHJpbmcsIGFtb3VudDogVUludDI1NikgewoKICAgIGxldCB2YXVsdFR5cGU6IFR5cGUKICAgIGxldCByZWNlaXZlcjogJntGdW5naWJsZVRva2VuLlZhdWx0fQogICAgbGV0IHNjb3BlZFByb3ZpZGVyOiBAU2NvcGVkRlRQcm92aWRlcnMuU2NvcGVkRlRQcm92aWRlcgogICAgbGV0IGNvYTogYXV0aChFVk0uQnJpZGdlKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChCb3Jyb3dWYWx1ZSwgQ29weVZhbHVlLCBJc3N1ZVN0b3JhZ2VDYXBhYmlsaXR5Q29udHJvbGxlciwgUHVibGlzaENhcGFiaWxpdHksIFNhdmVWYWx1ZSwgVW5wdWJsaXNoQ2FwYWJpbGl0eSkgJkFjY291bnQpIHsKICAgICAgICAvKiAtLS0gUmVmZXJlbmNlIHRoZSBzaWduZXIncyBDYWRlbmNlT3duZWRBY2NvdW50IC0tLSAqLwogICAgICAgIC8vCiAgICAgICAgLy8gQm9ycm93IGEgcmVmZXJlbmNlIHRvIHRoZSBzaWduZXIncyBDT0EKICAgICAgICBzZWxmLmNvYSA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEVWTS5CcmlkZ2UpICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oZnJvbTogL3N0b3JhZ2UvZXZtKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBDT0EgZnJvbSBwcm92aWRlZCBnYXRld2F5IGFkZHJlc3MiKQoKICAgICAgICAvLyBHZXQgdGhlIEVSQzIwIGNvbnRyYWN0IGFkZHJlc3MgZm9yIHRoZSBnaXZlbiBGdW5naWJsZVRva2VuIFZhdWx0IHR5cGUKICAgICAgICBzZWxmLnZhdWx0VHlwZSA9IEZsb3dFVk1CcmlkZ2VVdGlscy5idWlsZENvbXBvc2l0ZVR5cGUoCiAgICAgICAgICAgICAgICBhZGRyZXNzOiB0b2tlbkNvbnRyYWN0QWRkcmVzcywKICAgICAgICAgICAgICAgIGNvbnRyYWN0TmFtZTogdG9rZW5Db250cmFjdE5hbWUsCiAgICAgICAgICAgICAgICByZXNvdXJjZU5hbWU6ICJWYXVsdCIKICAgICAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGNvbnN0cnVjdCBWYXVsdCB0eXBlIG9mOiAiIC5jb25jYXQodG9rZW5Db250cmFjdEFkZHJlc3MudG9TdHJpbmcoKSkuY29uY2F0KCIuIikuY29uY2F0KHRva2VuQ29udHJhY3ROYW1lKS5jb25jYXQoIi5WYXVsdCIpKQoKICAgICAgICAvKiAtLS0gUmVmZXJlbmNlIHRoZSBzaWduZXIncyBWYXVsdCAtLS0gKi8KICAgICAgICAvLwogICAgICAgIC8vIEJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgRnVuZ2libGVUb2tlbiBWYXVsdCwgY29uZmlndXJpbmcgaWYgbmVjZXNzYXJ5CiAgICAgICAgbGV0IHZpZXdSZXNvbHZlciA9IGdldEFjY291bnQodG9rZW5Db250cmFjdEFkZHJlc3MpLmNvbnRyYWN0cy5ib3Jyb3c8JntWaWV3UmVzb2x2ZXJ9PihuYW1lOiB0b2tlbkNvbnRyYWN0TmFtZSkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgVmlld1Jlc29sdmVyIGZyb20gRnVuZ2libGVUb2tlbiBjb250cmFjdCIpCiAgICAgICAgbGV0IHZhdWx0RGF0YSA9IHZpZXdSZXNvbHZlci5yZXNvbHZlQ29udHJhY3RWaWV3KAogICAgICAgICAgICAgICAgcmVzb3VyY2VUeXBlOiBzZWxmLnZhdWx0VHlwZSwKICAgICAgICAgICAgICAgIHZpZXdUeXBlOiBUeXBlPEZ1bmdpYmxlVG9rZW5NZXRhZGF0YVZpZXdzLkZUVmF1bHREYXRhPigpCiAgICAgICAgICAgICkgYXMhIEZ1bmdpYmxlVG9rZW5NZXRhZGF0YVZpZXdzLkZUVmF1bHREYXRhPyA/PyBwYW5pYygiQ291bGQgbm90IHJlc29sdmUgRlRWYXVsdERhdGEgdmlldyIpCiAgICAgICAgLy8gSWYgdGhlIHZhdWx0IGRvZXMgbm90IGV4aXN0LCBjcmVhdGUgaXQgYW5kIHB1Ymxpc2ggYWNjb3JkaW5nIHRvIHRoZSBjb250cmFjdCdzIGRlZmluZWQgY29uZmlndXJhdGlvbgogICAgICAgIGlmIHNpZ25lci5zdG9yYWdlLmJvcnJvdzwme0Z1bmdpYmxlVG9rZW4uVmF1bHR9Pihmcm9tOiB2YXVsdERhdGEuc3RvcmFnZVBhdGgpID09IG5pbCB7CiAgICAgICAgICAgIHNpZ25lci5zdG9yYWdlLnNhdmUoPC12YXVsdERhdGEuY3JlYXRlRW1wdHlWYXVsdCgpLCB0bzogdmF1bHREYXRhLnN0b3JhZ2VQYXRoKQoKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy51bnB1Ymxpc2godmF1bHREYXRhLnJlY2VpdmVyUGF0aCkKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy51bnB1Ymxpc2godmF1bHREYXRhLm1ldGFkYXRhUGF0aCkKCiAgICAgICAgICAgIGxldCByZWNlaXZlckNhcCA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTwme0Z1bmdpYmxlVG9rZW4uVmF1bHR9Pih2YXVsdERhdGEuc3RvcmFnZVBhdGgpCiAgICAgICAgICAgIGxldCBtZXRhZGF0YUNhcCA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTwme0Z1bmdpYmxlVG9rZW4uVmF1bHR9Pih2YXVsdERhdGEuc3RvcmFnZVBhdGgpCgogICAgICAgICAgICBzaWduZXIuY2FwYWJpbGl0aWVzLnB1Ymxpc2gocmVjZWl2ZXJDYXAsIGF0OiB2YXVsdERhdGEucmVjZWl2ZXJQYXRoKQogICAgICAgICAgICBzaWduZXIuY2FwYWJpbGl0aWVzLnB1Ymxpc2gobWV0YWRhdGFDYXAsIGF0OiB2YXVsdERhdGEubWV0YWRhdGFQYXRoKQogICAgICAgIH0KICAgICAgICBzZWxmLnJlY2VpdmVyID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5WYXVsdH0+KGZyb206IHZhdWx0RGF0YS5zdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgVmF1bHQgZnJvbSBzdG9yYWdlIHBhdGgiKQoKICAgICAgICAvKiAtLS0gQ29uZmlndXJlIGEgU2NvcGVkRlRQcm92aWRlciAtLS0gKi8KICAgICAgICAvLwogICAgICAgIC8vIENhbGN1bGF0ZSB0aGUgYnJpZGdlIGZlZSAtIGJyaWRnaW5nIGZyb20gRVZNIGNvbnN1bWVzIG5vIHN0b3JhZ2UsIHNvIGZsYXQgZmVlCiAgICAgICAgbGV0IGFwcHJveEZlZSA9IEZsb3dFVk1CcmlkZ2VVdGlscy5jYWxjdWxhdGVCcmlkZ2VGZWUoYnl0ZXM6IDQwMF8wMDApCiAgICAgICAgLy8gSXNzdWUgYW5kIHN0b3JlIGJyaWRnZS1kZWRpY2F0ZWQgUHJvdmlkZXIgQ2FwYWJpbGl0eSBpbiBzdG9yYWdlIGlmIG5lY2Vzc2FyeQogICAgICAgIGlmIHNpZ25lci5zdG9yYWdlLnR5cGUoYXQ6IEZsb3dFVk1CcmlkZ2VDb25maWcucHJvdmlkZXJDYXBhYmlsaXR5U3RvcmFnZVBhdGgpID09IG5pbCB7CiAgICAgICAgICAgIGxldCBwcm92aWRlckNhcCA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+KAogICAgICAgICAgICAgICAgL3N0b3JhZ2UvZmxvd1Rva2VuVmF1bHQKICAgICAgICAgICAgKQogICAgICAgICAgICBzaWduZXIuc3RvcmFnZS5zYXZlKHByb3ZpZGVyQ2FwLCB0bzogRmxvd0VWTUJyaWRnZUNvbmZpZy5wcm92aWRlckNhcGFiaWxpdHlTdG9yYWdlUGF0aCkKICAgICAgICB9CiAgICAgICAgLy8gQ29weSB0aGUgc3RvcmVkIFByb3ZpZGVyIGNhcGFiaWxpdHkgYW5kIGNyZWF0ZSBhIFNjb3BlZEZUUHJvdmlkZXIKICAgICAgICBsZXQgcHJvdmlkZXJDYXBDb3B5ID0gc2lnbmVyLnN0b3JhZ2UuY29weTxDYXBhYmlsaXR5PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntGdW5naWJsZVRva2VuLlByb3ZpZGVyfT4+KAogICAgICAgICAgICAgICAgZnJvbTogRmxvd0VWTUJyaWRnZUNvbmZpZy5wcm92aWRlckNhcGFiaWxpdHlTdG9yYWdlUGF0aAogICAgICAgICAgICApID8/IHBhbmljKCJJbnZhbGlkIFByb3ZpZGVyIENhcGFiaWxpdHkgZm91bmQgaW4gc3RvcmFnZS4iKQogICAgICAgIGxldCBwcm92aWRlckZpbHRlciA9IFNjb3BlZEZUUHJvdmlkZXJzLkFsbG93YW5jZUZpbHRlcihhcHByb3hGZWUpCiAgICAgICAgc2VsZi5zY29wZWRQcm92aWRlciA8LSBTY29wZWRGVFByb3ZpZGVycy5jcmVhdGVTY29wZWRGVFByb3ZpZGVyKAogICAgICAgICAgICAgICAgcHJvdmlkZXI6IHByb3ZpZGVyQ2FwQ29weSwKICAgICAgICAgICAgICAgIGZpbHRlcnM6IFsgcHJvdmlkZXJGaWx0ZXIgXSwKICAgICAgICAgICAgICAgIGV4cGlyYXRpb246IGdldEN1cnJlbnRCbG9jaygpLnRpbWVzdGFtcCArIDEuMAogICAgICAgICAgICApCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgLy8gRXhlY3V0ZSB0aGUgYnJpZGdlIHJlcXVlc3QKICAgICAgICBsZXQgdmF1bHQ6IEB7RnVuZ2libGVUb2tlbi5WYXVsdH0gPC0gc2VsZi5jb2Eud2l0aGRyYXdUb2tlbnMoCiAgICAgICAgICAgIHR5cGU6IHNlbGYudmF1bHRUeXBlLAogICAgICAgICAgICBhbW91bnQ6IGFtb3VudCwKICAgICAgICAgICAgZmVlUHJvdmlkZXI6ICZzZWxmLnNjb3BlZFByb3ZpZGVyIGFzIGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntGdW5naWJsZVRva2VuLlByb3ZpZGVyfQogICAgICAgICkKICAgICAgICAvLyBEZXBvc2l0IHRoZSBicmlkZ2VkIHRva2VuIGludG8gdGhlIHNpZ25lcidzIHZhdWx0CiAgICAgICAgc2VsZi5yZWNlaXZlci5kZXBvc2l0KGZyb206IDwtdmF1bHQpCiAgICAgICAgLy8gRGVzdHJveSB0aGUgU2NvcGVkRlRQcm92aWRlcgogICAgICAgIGRlc3Ryb3kgc2VsZi5zY29wZWRQcm92aWRlcgogICAgfQp9Cg\u003d\u003d", + "bridgeTokensFromEvmToFlow": "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\u003d", + "bridgeTokensFromEvmToFlowV2": "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\u003d\u003d", + "bridgeTokensFromEvmToFlowV3": "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\u003d\u003d", + "bridgeTokensFromEvmV2": "// Flow Wallet - mainnet Script  bridgeTokensFromEvmV2 - v2.78
// <platform_info>

import MetadataViews from 0x1d7e57aa55817448

import ViewResolver from 0x1d7e57aa55817448

import NonFungibleToken from 0x1d7e57aa55817448


import FungibleToken from 0xf233dcee88fe0abe

import FlowToken from 0x1654653399040a61

import FungibleTokenMetadataViews from 0xf233dcee88fe0abe


import ScopedFTProviders from 0x1e4aa0b87d10b141


import EVM from 0xe467b9dd11fa00df


import FlowEVMBridgeUtils from 0x1e4aa0b87d10b141

import FlowEVMBridge from 0x1e4aa0b87d10b141

import FlowEVMBridgeConfig from 0x1e4aa0b87d10b141


/// This transaction bridges fungible tokens from EVM to Cadence assuming it has already been onboarded to the
/// FlowEVMBridge.
///
/// NOTE: The ERC20 must have first been onboarded to the bridge. This can be checked via the method
///     FlowEVMBridge.evmAddressRequiresOnboarding(address: self.evmContractAddress)
///
/// @param vaultIdentifier: The Cadence type identifier of the FungibleToken Vault to bridge
///     - e.g. vault.getType().identifier
/// @param amount: The amount of tokens to bridge from EVM
///
transaction(vaultIdentifier: String, amount: UInt256) {
    let vaultType: Type
    let receiver: &{FungibleToken.Vault}
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let coa: auth(EVM.Bridge) &EVM.CadenceOwnedAccount

    prepare(signer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        /* --- Construct the Vault type --- */
        //
        // Construct the Vault type from the provided identifier
        self.vaultType = CompositeType(vaultIdentifier)
            ?? panic("Could not construct Vault type from identifier: ".concat(vaultIdentifier))
        // Parse the Vault identifier into its components
        let tokenContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.vaultType)
            ?? panic("Could not get contract address from identifier: ".concat(vaultIdentifier))
        let tokenContractName = FlowEVMBridgeUtils.getContractName(fromType: self.vaultType)
            ?? panic("Could not get contract name from identifier: ".concat(vaultIdentifier))

        /* --- Reference the signer's Vault --- */
        //
        // Borrow a reference to the FungibleToken Vault, configuring if necessary
        let viewResolver = getAccount(tokenContractAddress).contracts.borrow<&{ViewResolver}>(name: tokenContractName)
            ?? panic("Could not borrow ViewResolver from FungibleToken contract")
        let vaultData = viewResolver.resolveContractView(
                resourceType: self.vaultType,
                viewType: Type<FungibleTokenMetadataViews.FTVaultData>()
            ) as! FungibleTokenMetadataViews.FTVaultData? ?? panic("Could not resolve FTVaultData view")
        // If the vault does not exist, create it and publish according to the contract's defined configuration
        if signer.storage.borrow<&{FungibleToken.Vault}>(from: vaultData.storagePath) == nil {
            signer.storage.save(<-vaultData.createEmptyVault(), to: vaultData.storagePath)

            signer.capabilities.unpublish(vaultData.receiverPath)
            signer.capabilities.unpublish(vaultData.metadataPath)

            let receiverCap = signer.capabilities.storage.issue<&{FungibleToken.Vault}>(vaultData.storagePath)
            let metadataCap = signer.capabilities.storage.issue<&{FungibleToken.Vault}>(vaultData.storagePath)

            signer.capabilities.publish(receiverCap, at: vaultData.receiverPath)
            signer.capabilities.publish(metadataCap, at: vaultData.metadataPath)
        }
        self.receiver = signer.storage.borrow<&{FungibleToken.Vault}>(from: vaultData.storagePath)
            ?? panic("Could not borrow Vault from storage path")

        /* --- Configure a ScopedFTProvider --- */
        //
        // Calculate the bridge fee - bridging from EVM consumes no storage, so flat fee
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000)
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    execute {
        // Execute the bridge request
        let vault: @{FungibleToken.Vault} <- self.coa.withdrawTokens(
            type: self.vaultType,
            amount: amount,
            feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        // Ensure the bridged vault is the correct type
        assert(vault.getType() == self.vaultType, message: "Bridged vault type mismatch")
        // Deposit the bridged token into the signer's vault
        self.receiver.deposit(from: <-vault)
        // Destroy the ScopedFTProvider
        destroy self.scopedProvider
    }
}", + "bridgeTokensToEvm": "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", + "bridgeTokensToEvmAddress": "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", + "bridgeTokensToEvmAddressV2": "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\u003d\u003d", + "bridgeTokensToEvmV2": "// Flow Wallet - mainnet Script  bridgeTokensToEvmV2 - v2.78
// <platform_info>

import MetadataViews from 0x1d7e57aa55817448

import ViewResolver from 0x1d7e57aa55817448

import NonFungibleToken from 0x1d7e57aa55817448


import FungibleToken from 0xf233dcee88fe0abe

import FlowToken from 0x1654653399040a61

import FungibleTokenMetadataViews from 0xf233dcee88fe0abe


import ScopedFTProviders from 0x1e4aa0b87d10b141


import EVM from 0xe467b9dd11fa00df


import FlowEVMBridgeUtils from 0x1e4aa0b87d10b141

import FlowEVMBridge from 0x1e4aa0b87d10b141

import FlowEVMBridgeConfig from 0x1e4aa0b87d10b141

/// Bridges a Vault from the signer's storage to the signer's COA in EVM.Account.
///
/// NOTE: This transaction also onboards the Vault to the bridge if necessary which may incur additional fees
///     than bridging an asset that has already been onboarded.
///
/// @param vaultIdentifier: The Cadence type identifier of the FungibleToken Vault to bridge
///     - e.g. vault.getType().identifier
/// @param amount: The amount of tokens to bridge from EVM
///
transaction(vaultIdentifier: String, amount: UFix64) {
    let sentVault: @{FungibleToken.Vault}
    let coa: auth(EVM.Bridge) &EVM.CadenceOwnedAccount
    let requiresOnboarding: Bool
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider

    prepare(signer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        /* --- Construct the Vault type --- */
        //
        // Construct the Vault type from the provided identifier
        let vaultType = CompositeType(vaultIdentifier)
            ?? panic("Could not construct Vault type from identifier: ".concat(vaultIdentifier))
        // Parse the Vault identifier into its components
        let tokenContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: vaultType)
            ?? panic("Could not get contract address from identifier: ".concat(vaultIdentifier))
        let tokenContractName = FlowEVMBridgeUtils.getContractName(fromType: vaultType)
            ?? panic("Could not get contract name from identifier: ".concat(vaultIdentifier))

        /* --- Retrieve the funds --- */
        //
        // Borrow a reference to the FungibleToken Vault
        let viewResolver = getAccount(tokenContractAddress).contracts.borrow<&{ViewResolver}>(name: tokenContractName)
            ?? panic("Could not borrow ViewResolver from FungibleToken contract")
        let vaultData = viewResolver.resolveContractView(
                resourceType: vaultType,
                viewType: Type<FungibleTokenMetadataViews.FTVaultData>()
            ) as! FungibleTokenMetadataViews.FTVaultData? ?? panic("Could not resolve FTVaultData view")
        let vault = signer.storage.borrow<auth(FungibleToken.Withdraw) &{FungibleToken.Vault}>(
                from: vaultData.storagePath
            ) ?? panic("Could not access signer's FungibleToken Vault")

        // Withdraw the requested balance & calculate the approximate bridge fee based on storage usage
        let currentStorageUsage = signer.storage.used
        self.sentVault <- vault.withdraw(amount: amount)
        let withdrawnStorageUsage = signer.storage.used
        // Approximate the bridge fee based on the difference in storage usage with some buffer
        var approxFee = FlowEVMBridgeUtils.calculateBridgeFee(
                bytes: currentStorageUsage - withdrawnStorageUsage
            ) * 1.10
        // Determine if the Vault requires onboarding - this impacts the fee required
        self.requiresOnboarding = FlowEVMBridge.typeRequiresOnboarding(self.sentVault.getType())
            ?? panic("Bridge does not support this asset type")
        if self.requiresOnboarding {
            approxFee = approxFee + FlowEVMBridgeConfig.onboardFee
        }

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    pre {
        self.sentVault.getType().identifier == vaultIdentifier:
            "Attempting to send invalid vault type - requested: ".concat(vaultIdentifier)
            .concat(", sending: ").concat(self.sentVault.getType().identifier)
    }

    execute {
        if self.requiresOnboarding {
            // Onboard the Vault to the bridge
            FlowEVMBridge.onboardByType(
                self.sentVault.getType(),
                feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
        }
        // Execute the bridge
        self.coa.depositTokens(
            vault: <-self.sentVault,
            feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        // Destroy the ScopedFTProvider
        destroy self.scopedProvider
    }
}", + "calculateBridgeFee": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY2FsY3VsYXRlQnJpZGdlRmVlIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd0VWTUJyaWRnZVV0aWxzIGZyb20gMHgxZTRhYTBiODdkMTBiMTQxCgoKLy8vIFJldHVybnMgdGhlIGNhbGN1bGF0ZWQgZmVlIGJhc2VkIG9uIHRoZSBudW1iZXIgb2YgYnl0ZXMgdXNlZCB0byBlc2Nyb3cgYW4gYXNzZXQgcGx1cyB0aGUgYmFzZSBmZWUuCi8vLwovLy8gQHBhcmFtIGJ5dGVzOiBUaGUgbnVtYmVyIG9mIGJ5dGVzIHVzZWQgdG8gZXNjcm93IGFuIGFzc2V0LgovLy8KLy8vIEByZXR1cm4gVGhlIGNhbGN1bGF0ZWQgZmVlIHRvIGJlIHBhaWQgaW4gRmxvd1Rva2VuCi8vLwphY2Nlc3MoYWxsKQpmdW4gbWFpbihieXRlcyB1c2VkOiBVSW50NjQpOiBVRml4NjQgewogICAgcmV0dXJuIEZsb3dFVk1CcmlkZ2VVdGlscy5jYWxjdWxhdGVCcmlkZ2VGZWUoYnl0ZXM6IHVzZWQpCn0K", + "evmAddressRequiresOnboarding": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZXZtQWRkcmVzc1JlcXVpcmVzT25ib2FyZGluZyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4ZTQ2N2I5ZGQxMWZhMDBkZgoKaW1wb3J0IEZsb3dFVk1CcmlkZ2UgZnJvbSAweDFlNGFhMGI4N2QxMGIxNDEKCgovLy8gUmV0dXJucyB3aGV0aGVyIGEgRVZNIGNvbnRyYWN0IG5lZWRzIHRvIGJlIG9uYm9hcmRlZCB0byB0aGUgRmxvd0VWTUJyaWRnZQovLy8KLy8vIEBwYXJhbSBldm1BZGRyZXNzSGV4OiBUaGUgaGV4LWVuY29kZWQgYWRkcmVzcyBvZiB0aGUgRVZNIGNvbnRyYWN0IGFzIGEgU3RyaW5nIHdpdGhvdXQgMHggcHJlZml4Ci8vLwovLy8gQHJldHVybiBXaGV0aGVyIHRoZSBjb250cmFjdCByZXF1aXJlcyBvbmJvYXJkaW5nIHRvIHRoZSBGbG93RVZNQnJpZGdlIGlmIHRoZSB0eXBlIGlzIGJyaWRnZWFibGUsIG90aGVyd2lzZSBuaWwKLy8vCmFjY2VzcyhhbGwpIGZ1biBtYWluKGV2bUFkZHJlc3NIZXg6IFN0cmluZyk6IEJvb2w/IHsKICAgIGxldCBhZGRyZXNzID0gRVZNLmFkZHJlc3NGcm9tU3RyaW5nKGV2bUFkZHJlc3NIZXgpCiAgICByZXR1cm4gRmxvd0VWTUJyaWRnZS5ldm1BZGRyZXNzUmVxdWlyZXNPbmJvYXJkaW5nKGFkZHJlc3MpCn0K", + "getAssociatedEvmAddress": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QXNzb2NpYXRlZEV2bUFkZHJlc3MgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBFVk0gZnJvbSAweGU0NjdiOWRkMTFmYTAwZGYKCgppbXBvcnQgRmxvd0VWTUJyaWRnZUNvbmZpZyBmcm9tIDB4MWU0YWEwYjg3ZDEwYjE0MQoKCi8vLyBSZXR1cm5zIHRoZSBFVk0gYWRkcmVzcyBhc3NvY2lhdGVkIHdpdGggdGhlIGdpdmVuIENhZGVuY2UgdHlwZSAoYXMgaXRzIGlkZW50aWZpZXIgU3RyaW5nKQovLy8KLy8vIEBwYXJhbSB0eXBlSWRlbnRpZmllciBUaGUgQ2FkZW5jZSB0eXBlIGlkZW50aWZpZXIgU3RyaW5nCi8vLwovLy8gQHJldHVybiBUaGUgRVZNIGFkZHJlc3MgYXMgYSBoZXggc3RyaW5nIGlmIHRoZSB0eXBlIGhhcyBhbiBhc3NvY2lhdGVkIEVWTUFkZHJlc3MsIG90aGVyd2lzZSBuaWwKLy8vCmFjY2VzcyhhbGwpCmZ1biBtYWluKGlkZW50aWZpZXI6IFN0cmluZyk6IFN0cmluZz8gewogICAgaWYgbGV0IHR5cGUgPSBDb21wb3NpdGVUeXBlKGlkZW50aWZpZXIpIHsKICAgICAgICBpZiBsZXQgYWRkcmVzcyA9IEZsb3dFVk1CcmlkZ2VDb25maWcuZ2V0RVZNQWRkcmVzc0Fzc29jaWF0ZWQod2l0aDogdHlwZSkgewogICAgICAgICAgICByZXR1cm4gU3RyaW5nLmVuY29kZUhleChhZGRyZXNzLmJ5dGVzKQogICAgICAgIH0KICAgIH0KICAgIHJldHVybiBuaWwKfQ\u003d\u003d", + "getAssociatedFlowIdentifier": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QXNzb2NpYXRlZEZsb3dJZGVudGlmaWVyIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRVZNIGZyb20gMHhlNDY3YjlkZDExZmEwMGRmCgppbXBvcnQgRmxvd0VWTUJyaWRnZUNvbmZpZyBmcm9tIDB4MWU0YWEwYjg3ZDEwYjE0MQoKCmFjY2VzcyhhbGwpCmZ1biBtYWluKGFkZHJlc3M6IFN0cmluZyk6IFN0cmluZz8gewogICAgaWYgbGV0IHR5cGVJbmZvID0gRmxvd0VWTUJyaWRnZUNvbmZpZy5nZXRUeXBlQXNzb2NpYXRlZCh3aXRoOiBFVk0uYWRkcmVzc0Zyb21TdHJpbmcoYWRkcmVzcykpIHsKICAgICAgICByZXR1cm4gdHlwZUluZm8uaWRlbnRpZmllcgogICAgfQogICAgcmV0dXJuIG5pbAp9", + "getBridgeCoaAddress": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QnJpZGdlQ29hQWRkcmVzcyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4ZTQ2N2I5ZGQxMWZhMDBkZgoKCmltcG9ydCBGbG93RVZNQnJpZGdlIGZyb20gMHgxZTRhYTBiODdkMTBiMTQxCgoKLy8vIFJldHVybnMgdGhlIEVWTSBhZGRyZXNzIGFzc29jaWF0ZWQgd2l0aCB0aGUgRmxvd0VWTUJyaWRnZQovLy8KLy8vIEByZXR1cm4gVGhlIEVWTSBhZGRyZXNzIGFzc29jaWF0ZWQgd2l0aCB0aGUgRmxvd0VWTUJyaWRnZSdzIGNvb3JkaW5hdGluZyBDYWRlbmNlT3duZWRBY2NvdW50Ci8vLwphY2Nlc3MoYWxsKSBmdW4gbWFpbigpOiBTdHJpbmcgewogICAgbGV0IGFkZHJlc3M6IEVWTS5FVk1BZGRyZXNzID0gRmxvd0VWTUJyaWRnZS5nZXRCcmlkZ2VDT0FFVk1BZGRyZXNzKCkKICAgIHJldHVybiBTdHJpbmcuZW5jb2RlSGV4KGFkZHJlc3MuYnl0ZXMpCn0\u003d", + "onboardByEvmAddress": "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\u003d\u003d", + "onboardByType": "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\u003d\u003d", + "onboardByTypeIdentifier": "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\u003d\u003d", + "typeRequiresOnboarding": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgdHlwZVJlcXVpcmVzT25ib2FyZGluZyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dFVk1CcmlkZ2UgZnJvbSAweDFlNGFhMGI4N2QxMGIxNDEKCgovLy8gUmV0dXJucyB3aGV0aGVyIGEgdHlwZSBuZWVkcyB0byBiZSBvbmJvYXJkZWQgdG8gdGhlIEZsb3dFVk1CcmlkZ2UKLy8vCi8vLyBAcGFyYW0gdHlwZTogVGhlIENhZGVuY2UgVHlwZSBpbiBxdWVzdGlvbgovLy8KLy8vIEByZXR1cm4gV2hldGhlciB0aGUgdHlwZSByZXF1aXJlcyBvbmJvYXJkaW5nIHRvIHRoZSBGbG93RVZNQnJpZGdlIGlmIHRoZSB0eXBlIGlzIGJyaWRnZWFibGUsIG90aGVyd2lzZSBuaWwKLy8vCmFjY2VzcyhhbGwpIGZ1biBtYWluKHR5cGU6IFR5cGUpOiBCb29sPyB7CiAgICByZXR1cm4gRmxvd0VWTUJyaWRnZS50eXBlUmVxdWlyZXNPbmJvYXJkaW5nKHR5cGUpCn0K", + "typeRequiresOnboardingByIdentifier": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgdHlwZVJlcXVpcmVzT25ib2FyZGluZ0J5SWRlbnRpZmllciAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dFVk1CcmlkZ2UgZnJvbSAweDFlNGFhMGI4N2QxMGIxNDEKCgovLy8gUmV0dXJucyB3aGV0aGVyIGEgdHlwZSBuZWVkcyB0byBiZSBvbmJvYXJkZWQgdG8gdGhlIEZsb3dFVk1CcmlkZ2UKLy8vCi8vLyBAcGFyYW0gaWRlbnRpZmllcjogVGhlIGlkZW50aWZpZXIgb2YgdGhlIENhZGVuY2UgVHlwZSBpbiBxdWVzdGlvbgovLy8KLy8vIEByZXR1cm4gV2hldGhlciB0aGUgdHlwZSByZXF1aXJlcyBvbmJvYXJkaW5nIHRvIHRoZSBGbG93RVZNQnJpZGdlIGlmIHRoZSB0eXBlIGlzIGJyaWRnZWFibGUsIG90aGVyd2lzZSBuaWwKLy8vCmFjY2VzcyhhbGwpIGZ1biBtYWluKGlkZW50aWZpZXI6IFN0cmluZyk6IEJvb2w/IHsKICAgIGlmIGxldCB0eXBlID0gQ29tcG9zaXRlVHlwZShpZGVudGlmaWVyKSB7CiAgICAgICAgcmV0dXJuIEZsb3dFVk1CcmlkZ2UudHlwZVJlcXVpcmVzT25ib2FyZGluZyh0eXBlKQogICAgfQogICAgcmV0dXJuIG5pbAp9Cg\u003d\u003d" + }, + "collection": { + "batchSendNFTV3": "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\u003d\u003d", + "checkNFTCollection": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY2hlY2tORlRDb2xsZWN0aW9uIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgogICAgaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCiAgICBpbXBvcnQgPE5GVD4gZnJvbSA8TkZUQWRkcmVzcz4KCiAgICAvLyBUaGlzIHRyYW5zYWN0aW9uIGlzIGZvciB0cmFuc2ZlcnJpbmcgYW5kIE5GVCBmcm9tCiAgICAvLyBvbmUgYWNjb3VudCB0byBhbm90aGVyCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrPFRva2VuPlZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAgbGV0IHZhdWx0UmVmID0gYWNjb3VudC5jYXBhYmlsaXRpZXMuZXhpc3QoPFRva2VuQ29sbGVjdGlvblB1YmxpY1BhdGg+KQogICAgICAgIHJldHVybiB2YXVsdFJlZgogICAgfQoKICAgIGFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgICAgcmV0dXJuIGNoZWNrPFRva2VuPlZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICB9", + "enableNFTStorage": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZW5hYmxlTkZUU3RvcmFnZSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgPE5GVD4gZnJvbSA8TkZUQWRkcmVzcz4KCnRyYW5zYWN0aW9uIHsKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChDYXBhYmlsaXRpZXMsIFNhdmVWYWx1ZSkgJkFjY291bnQpIHsKICAgICAgICBpZiBzaWduZXIuY2FwYWJpbGl0aWVzLmJvcnJvdzwmPE5GVD4uQ29sbGVjdGlvbj4oPENvbGxlY3Rpb25QdWJsaWNQYXRoPikgPT0gbmlsIHsKICAgICAgICAgICAgbGV0IGNvbGxlY3Rpb24gPC0gPE5GVD4uY3JlYXRlRW1wdHlDb2xsZWN0aW9uKG5mdFR5cGU6IFR5cGU8QDxORlQ+Lk5GVD4oKSkKICAgICAgICAgICAgc2lnbmVyLnN0b3JhZ2Uuc2F2ZSg8LWNvbGxlY3Rpb24sIHRvOiA8Q29sbGVjdGlvblN0b3JhZ2VQYXRoPikKICAgICAgICB9CiAgICAgICAgaWYgKHNpZ25lci5jYXBhYmlsaXRpZXMuYm9ycm93PCY8TkZUPi5Db2xsZWN0aW9uPig8Q29sbGVjdGlvblB1YmxpY1BhdGg+KSA9PSBuaWwpIHsKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy51bnB1Ymxpc2goPENvbGxlY3Rpb25QdWJsaWNQYXRoPikKICAgICAgICAgICAgbGV0IGNhcCA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTwmPE5GVD4uQ29sbGVjdGlvbj4oPENvbGxlY3Rpb25TdG9yYWdlUGF0aD4pICAgICAgICAgICAgCiAgICAgICAgICAgIHNpZ25lci5jYXBhYmlsaXRpZXMucHVibGlzaChjYXAsIGF0OiA8Q29sbGVjdGlvblB1YmxpY1BhdGg+KQoKICAgICAgICB9CiAgICB9Cn0\u003d", + "enableNFTStorageV2": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZW5hYmxlTkZUU3RvcmFnZVYyIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4MWQ3ZTU3YWE1NTgxNzQ0OAoKaW1wb3J0IE1ldGFkYXRhVmlld3MgZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCmltcG9ydCBWaWV3UmVzb2x2ZXIgZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCgp0cmFuc2FjdGlvbihuZnRJZGVudGlmaWVyOiBTdHJpbmcpIHsKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChDYXBhYmlsaXRpZXMsIFNhdmVWYWx1ZSkgJkFjY291bnQpIHsKCiAgICAgICAgbGV0IHR5cGUgPSBDb21wb3NpdGVUeXBlKG5mdElkZW50aWZpZXIpCiAgICAgICAgbGV0IGlkZW50aWZpZXJTcGxpdCA9IG5mdElkZW50aWZpZXIuc3BsaXQoc2VwYXJhdG9yOiAiLiIpCiAgICAgICAgbGV0IGFkZHJlc3MgPSBBZGRyZXNzLmZyb21TdHJpbmcoIjB4Ii5jb25jYXQoaWRlbnRpZmllclNwbGl0WzFdKSkhCiAgICAgICAgbGV0IG5hbWUgPSBpZGVudGlmaWVyU3BsaXRbMl0hCgogICAgICAgIGxldCB2aWV3UmVzb2x2ZXIgPSBnZXRBY2NvdW50KGFkZHJlc3MpLmNvbnRyYWN0cy5ib3Jyb3c8JntWaWV3UmVzb2x2ZXJ9PihuYW1lOiBuYW1lKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBWaWV3UmVzb2x2ZXIgZnJvbSBORlQgY29udHJhY3QiKQogICAgICAgIGxldCBjb2xsZWN0aW9uRGF0YSA9IHZpZXdSZXNvbHZlci5yZXNvbHZlQ29udHJhY3RWaWV3KAogICAgICAgICAgICAgICAgcmVzb3VyY2VUeXBlOiB0eXBlLAogICAgICAgICAgICAgICAgdmlld1R5cGU6IFR5cGU8TWV0YWRhdGFWaWV3cy5ORlRDb2xsZWN0aW9uRGF0YT4oKQogICAgICAgICAgICApIGFzISBNZXRhZGF0YVZpZXdzLk5GVENvbGxlY3Rpb25EYXRhPyA/PyBwYW5pYygiQ291bGQgbm90IHJlc29sdmUgTkZUQ29sbGVjdGlvbkRhdGEgdmlldyIpCgogICAgICAgIGlmIHNpZ25lci5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7Tm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9ufT4oY29sbGVjdGlvbkRhdGEucHVibGljUGF0aCkgPT0gbmlsIHsKICAgICAgICAgICAgbGV0IGNvbGxlY3Rpb24gPC0gY29sbGVjdGlvbkRhdGEuY3JlYXRlRW1wdHlDb2xsZWN0aW9uKCkKICAgICAgICAgICAgc2lnbmVyLnN0b3JhZ2Uuc2F2ZSg8LWNvbGxlY3Rpb24sIHRvOiBjb2xsZWN0aW9uRGF0YS5zdG9yYWdlUGF0aCkKICAgICAgICB9CiAgICAgICAgaWYgKHNpZ25lci5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7Tm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9ufT4oY29sbGVjdGlvbkRhdGEucHVibGljUGF0aCkgPT0gbmlsKSB7CiAgICAgICAgICAgIHNpZ25lci5jYXBhYmlsaXRpZXMudW5wdWJsaXNoKGNvbGxlY3Rpb25EYXRhLnB1YmxpY1BhdGgpCiAgICAgICAgICAgIGxldCBjYXAgPSBzaWduZXIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8JntOb25GdW5naWJsZVRva2VuLkNvbGxlY3Rpb259Pihjb2xsZWN0aW9uRGF0YS5zdG9yYWdlUGF0aCkgICAgICAgICAgICAKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5wdWJsaXNoKGNhcCwgYXQ6IGNvbGxlY3Rpb25EYXRhLnB1YmxpY1BhdGgpCiAgICAgICAgfQogICAgfQp9", + "getCatalogTypeData": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Q2F0YWxvZ1R5cGVEYXRhIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTkZUQ2F0YWxvZyBmcm9tIDB4TkZUQ2F0YWxvZwoKYWNjZXNzKGFsbCkgZnVuIG1haW4oKToge1N0cmluZyA6IHtTdHJpbmcgOiBCb29sfX0gewogIGxldCBjYXRhbG9nID0gTkZUQ2F0YWxvZy5nZXRDYXRhbG9nVHlwZURhdGEoKQogIHJldHVybiBjYXRhbG9nCn0\u003d", + "getNFT": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0TkZUIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4MWQ3ZTU3YWE1NTgxNzQ0OAoKaW1wb3J0IE1ldGFkYXRhVmlld3MgZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCmltcG9ydCBWaWV3UmVzb2x2ZXIgZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCgoKYWNjZXNzKGFsbCkgc3RydWN0IFZpZXdJbmZvIHsKICBhY2Nlc3MoYWxsKSBsZXQgbmFtZTogU3RyaW5nCiAgYWNjZXNzKGFsbCkgbGV0IGRlc2NyaXB0aW9uOiBTdHJpbmcKICBhY2Nlc3MoYWxsKSBsZXQgdGh1bWJuYWlsOiB7TWV0YWRhdGFWaWV3cy5GaWxlfQogIGFjY2VzcyhhbGwpIGxldCByYXJpdHk6IFN0cmluZz8KCiAgaW5pdChuYW1lOiBTdHJpbmcsIGRlc2NyaXB0aW9uOiBTdHJpbmcsIHRodW1ibmFpbDoge01ldGFkYXRhVmlld3MuRmlsZX0sIHJhcml0eTogU3RyaW5nPykgewogICAgc2VsZi5uYW1lID0gbmFtZQogICAgc2VsZi5kZXNjcmlwdGlvbiA9IGRlc2NyaXB0aW9uCiAgICBzZWxmLnRodW1ibmFpbCA9IHRodW1ibmFpbAogICAgc2VsZi5yYXJpdHkgPSByYXJpdHkKICB9Cn0KCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MsIHBhdGhJZDogU3RyaW5nLCB0b2tlbklEczogW1VJbnQ2NF0pOiB7VUludDY0OiBWaWV3SW5mb30gewogIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogIGxldCByZXM6IHtVSW50NjQ6IFZpZXdJbmZvfSA9IHt9CiAgdmFyIGNvbGxlY3Rpb25EaXNwbGF5RmV0Y2hlZCA9IGZhbHNlCgogIGlmIHRva2VuSURzLmxlbmd0aCA9PSAwIHsKICAgIHJldHVybiByZXMKICB9CgogIGxldCBzdG9yYWdlUGF0aCA9IFN0b3JhZ2VQYXRoKGlkZW50aWZpZXI6IHBhdGhJZCkhCiAgbGV0IHB1YmxpY1BhdGggPSBQdWJsaWNQYXRoKGlkZW50aWZpZXI6IHBhdGhJZCkhCiAgbGV0IHR5cGUgPSBhY2NvdW50LnN0b3JhZ2UudHlwZShhdDogc3RvcmFnZVBhdGgpCiAgaWYgdHlwZSA9PSBuaWwgewogICAgcmV0dXJuIHJlcwogIH0KCiAgbGV0IG1ldGFkYXRhVmlld1R5cGUgPSBUeXBlPEB7Vmlld1Jlc29sdmVyLlJlc29sdmVyQ29sbGVjdGlvbn0+KCkKCiAgbGV0IGNvbmZvcm1lZE1ldGFkYXRhVmlld3MgPSB0eXBlIS5pc1N1YnR5cGUob2Y6IG1ldGFkYXRhVmlld1R5cGUpCiAgaWYgIWNvbmZvcm1lZE1ldGFkYXRhVmlld3MgewogICAgZm9yIHRva2VuSUQgaW4gdG9rZW5JRHMgewogICAgICByZXNbdG9rZW5JRF0gPSBWaWV3SW5mbygKICAgICAgICBuYW1lOiBwYXRoSWQsCiAgICAgICAgZGVzY3JpcHRpb246ICIiLAogICAgICAgIHRodW1ibmFpbDogTWV0YWRhdGFWaWV3cy5IVFRQRmlsZSh1cmw6ICIiKSwKICAgICAgICByYXJpdHk6IG5pbAogICAgICApCiAgICB9CiAgICByZXR1cm4gcmVzCiAgfQoKICBsZXQgY29sbGVjdGlvblJlZiA9IGFjY291bnQuY2FwYWJpbGl0aWVzLmJvcnJvdzwme1ZpZXdSZXNvbHZlci5SZXNvbHZlckNvbGxlY3Rpb24sIE5vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0+KHB1YmxpY1BhdGgpCiAgZm9yIHRva2VuSUQgaW4gdG9rZW5JRHMgewogICAgbGV0IHJlc29sdmVyID0gY29sbGVjdGlvblJlZiEuYm9ycm93Vmlld1Jlc29sdmVyKGlkOiB0b2tlbklEKQogICAgaWYgcmVzb2x2ZXIgIT0gbmlsIHsKICAgICAgIGlmIGxldCBkaXNwbGF5ID0gTWV0YWRhdGFWaWV3cy5nZXREaXNwbGF5KHJlc29sdmVyISkgewogICAgICAgIHZhciByYXJpdHlEZXNjOiBTdHJpbmc/ID0gbmlsCiAgICAgICAgaWYgbGV0IHJhcml0eVZpZXcgPSBNZXRhZGF0YVZpZXdzLmdldFJhcml0eShyZXNvbHZlciEpIHsKICAgICAgICAgIHJhcml0eURlc2MgPSByYXJpdHlWaWV3LmRlc2NyaXB0aW9uCiAgICAgICAgfQoKICAgICAgICByZXNbdG9rZW5JRF0gPSBWaWV3SW5mbygKICAgICAgICAgIG5hbWU6IGRpc3BsYXkubmFtZSwKICAgICAgICAgIGRlc2NyaXB0aW9uOiBkaXNwbGF5LmRlc2NyaXB0aW9uLAogICAgICAgICAgdGh1bWJuYWlsOiBkaXNwbGF5LnRodW1ibmFpbCwKICAgICAgICAgIHJhcml0eTogcmFyaXR5RGVzYwogICAgICAgICkKICAgICAgfSAKICAgIH0KICAgZWxzZSB7CiAgICAgIHJlc1t0b2tlbklEXSA9IFZpZXdJbmZvKAogICAgICAgIG5hbWU6IHBhdGhJZCwKICAgICAgICBkZXNjcmlwdGlvbjogIiIsCiAgICAgICAgdGh1bWJuYWlsOiBNZXRhZGF0YVZpZXdzLkhUVFBGaWxlKHVybDogIiIpLAogICAgICAgIHJhcml0eTogbmlsCiAgICAgICkKICAgIH0KICB9CiAgcmV0dXJuIHJlcwp9", + "getNFTBalanceStorage": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0TkZUQmFsYW5jZVN0b3JhZ2UgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBOb25GdW5naWJsZVRva2VuIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgoKLy8vIEhlbHBlciBmdW5jdGlvbiB0aGF0IHJldHJpZXZlcyBkYXRhIGFib3V0IGFsbCBwdWJsaWNseSBhY2Nlc3NpYmxlIE5GVHMgY291bnQgIGFuIGFjY291bnQKLy8vCmFjY2VzcyhhbGwpIGZ1biBtYWluKF8gYWRkcmVzczogQWRkcmVzcyk6IHtTdHJpbmc6IEludH0gewogICAgbGV0IGFjY291bnQgPSBnZXRBdXRoQWNjb3VudDxhdXRoKEJvcnJvd1ZhbHVlKSAmQWNjb3VudD4oYWRkcmVzcykKICAgIGxldCBkYXRhOiB7U3RyaW5nOiBJbnR9ID0ge30KICAgIGxldCBjb2xsZWN0aW9uVHlwZTogVHlwZSA9IFR5cGU8QHtOb25GdW5naWJsZVRva2VuLkNvbGxlY3Rpb259PigpCgogICAgLy8gSXRlcmF0ZSBvdmVyIGVhY2ggcHVibGljIHBhdGgKICAgIGFjY291bnQuc3RvcmFnZS5mb3JFYWNoU3RvcmVkKGZ1biAocGF0aDogU3RvcmFnZVBhdGgsIHR5cGU6IFR5cGUpOiBCb29sIHsKICAgICAgICAvLyBSZXR1cm4gZWFybHkgaWYgdGhlIGNvbGxlY3Rpb24gaXMgYnJva2VuIG9yIGlzIG5vdCB0aGUgdHlwZSB3ZSdyZSBsb29raW5nIGZvcgogICAgICAgIGlmIHR5cGUuaXNSZWNvdmVyZWQgfHwgKCF0eXBlLmlzSW5zdGFuY2UoY29sbGVjdGlvblR5cGUpICYmICF0eXBlLmlzU3VidHlwZShvZjogY29sbGVjdGlvblR5cGUpKSB7CiAgICAgICAgICAgIHJldHVybiB0cnVlCiAgICAgICAgfQogICAgICAgIGlmIGxldCBjb2xsZWN0aW9uUmVmID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzwme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0+KGZyb206IHBhdGgpIHsKICAgICAgICAgICAgLy8gUmV0dXJuIGVhcmx5IGlmIG5vIFJlc29sdmVyIGZvdW5kIGluIHRoZSBDb2xsZWN0aW9uCiAgICAgICAgICAgIGxldCBpZHM6IFtVSW50NjRdPSBjb2xsZWN0aW9uUmVmLmdldElEcygpCiAgICAgICAgICAgIGRhdGEuaW5zZXJ0KGtleTogdHlwZS5pZGVudGlmaWVyLCBpZHMubGVuZ3RoKQogICAgICAgIH0KICAgICAgICByZXR1cm4gdHJ1ZQogICAgfSkKICAgIHJldHVybiBkYXRhCn0\u003d", + "getNFTCollection": "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\u003d\u003d", + "getNFTDisplays": "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", + "getNFTMetadataViews": "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\u003d\u003d", + "getUserCollections": "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\u003d", + "getUserCollectionsPage": "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", + "sendNbaNFT": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgc2VuZE5iYU5GVCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCgppbXBvcnQgPE5GVD4gZnJvbSA8TkZUQWRkcmVzcz4KCnRyYW5zYWN0aW9uKHJlY2lwaWVudEFkZHI6IEFkZHJlc3MsIHdpdGhkcmF3SUQ6IFVJbnQ2NCkgewogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSwgQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgLy8gZ2V0IHRoZSByZWNpcGllbnRzIHB1YmxpYyBhY2NvdW50IG9iamVjdAogICAgICAgIGxldCByZWNpcGllbnQgPSBnZXRBY2NvdW50KHJlY2lwaWVudEFkZHIpCiAgICAgICAgLy8gYm9ycm93IGEgcmVmZXJlbmNlIHRvIHRoZSBzaWduZXInJ3MgTkZUIGNvbGxlY3Rpb24KICAgICAgICBsZXQgY29sbGVjdGlvblJlZiA9IHNpZ25lci5zdG9yYWdlCiAgICAgICAgLmJvcnJvdzxhdXRoKE5vbkZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7Tm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9ufT4oZnJvbTogL3N0b3JhZ2UvTW9tZW50Q29sbGVjdGlvbikKICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgb3duZXInJ3MgY29sbGVjdGlvbiIpCiAgICAgICAgbGV0IHNlbmRlclJlZiA9IHNpZ25lcgogICAgICAgIC5jYXBhYmlsaXRpZXMKICAgICAgICAuYm9ycm93PCZ7Tm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9uUHVibGljfT4oL3B1YmxpYy9Nb21lbnRDb2xsZWN0aW9uKQogICAgICAgIC8vIGJvcnJvdyBhIHB1YmxpYyByZWZlcmVuY2UgdG8gdGhlIHJlY2VpdmVycyBjb2xsZWN0aW9uCiAgICAgICAgbGV0IHJlY2lwaWVudFJlZiA9IHJlY2lwaWVudAogICAgICAgIC5jYXBhYmlsaXRpZXMKICAgICAgICAuYm9ycm93PCZ7VG9wU2hvdC5Nb21lbnRDb2xsZWN0aW9uUHVibGljfT4oL3B1YmxpYy9Nb21lbnRDb2xsZWN0aW9uKSA/PyBwYW5pYygiVW5hYmxlIHRvIGJvcnJvdyByZWNlaXZlciByZWZlcmVuY2UiKQogICAgICAgIAogICAgICAgIC8vIHdpdGhkcmF3IHRoZSBORlQgZnJvbSB0aGUgb3duZXInJ3MgY29sbGVjdGlvbgogICAgICAgIGxldCBuZnQgPC0gY29sbGVjdGlvblJlZi53aXRoZHJhdyh3aXRoZHJhd0lEOiB3aXRoZHJhd0lEKQogICAgICAgIC8vIERlcG9zaXQgdGhlIE5GVCBpbiB0aGUgcmVjaXBpZW50JydzIGNvbGxlY3Rpb24KICAgICAgICByZWNpcGllbnRSZWYhLmRlcG9zaXQodG9rZW46IDwtbmZ0KQogICAgfQp9", + "sendNbaNFTV3": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgc2VuZE5iYU5GVFYzIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4MWQ3ZTU3YWE1NTgxNzQ0OAoKaW1wb3J0IFN0b3JhZ2VSZW50IGZyb20gMHg3MDdhZGJhZDE0MjhjNjI0CgoKaW1wb3J0IDxORlQ+IGZyb20gPE5GVEFkZHJlc3M+Cgp0cmFuc2FjdGlvbihyZWNpcGllbnRBZGRyOiBBZGRyZXNzLCB3aXRoZHJhd0lEOiBVSW50NjQpIHsKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgIC8vIGdldCB0aGUgcmVjaXBpZW50cyBwdWJsaWMgYWNjb3VudCBvYmplY3QKICAgICAgICBsZXQgcmVjaXBpZW50ID0gZ2V0QWNjb3VudChyZWNpcGllbnRBZGRyKQogICAgICAgIC8vIGJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgc2lnbmVyJydzIE5GVCBjb2xsZWN0aW9uCiAgICAgICAgbGV0IGNvbGxlY3Rpb25SZWYgPSBzaWduZXIuc3RvcmFnZQogICAgICAgIC5ib3Jyb3c8YXV0aChOb25GdW5naWJsZVRva2VuLldpdGhkcmF3KSAme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0+KGZyb206IC9zdG9yYWdlL01vbWVudENvbGxlY3Rpb24pCiAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgYSByZWZlcmVuY2UgdG8gdGhlIG93bmVyJydzIGNvbGxlY3Rpb24iKQogICAgICAgIGxldCBzZW5kZXJSZWYgPSBzaWduZXIKICAgICAgICAuY2FwYWJpbGl0aWVzCiAgICAgICAgLmJvcnJvdzwme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvblB1YmxpY30+KC9wdWJsaWMvTW9tZW50Q29sbGVjdGlvbikKICAgICAgICAvLyBib3Jyb3cgYSBwdWJsaWMgcmVmZXJlbmNlIHRvIHRoZSByZWNlaXZlcnMgY29sbGVjdGlvbgogICAgICAgIGxldCByZWNpcGllbnRSZWYgPSByZWNpcGllbnQKICAgICAgICAuY2FwYWJpbGl0aWVzCiAgICAgICAgLmJvcnJvdzwme1RvcFNob3QuTW9tZW50Q29sbGVjdGlvblB1YmxpY30+KC9wdWJsaWMvTW9tZW50Q29sbGVjdGlvbikgPz8gcGFuaWMoIlVuYWJsZSB0byBib3Jyb3cgcmVjZWl2ZXIgcmVmZXJlbmNlIikKICAgICAgICAKICAgICAgICAvLyB3aXRoZHJhdyB0aGUgTkZUIGZyb20gdGhlIG93bmVyJydzIGNvbGxlY3Rpb24KICAgICAgICBsZXQgbmZ0IDwtIGNvbGxlY3Rpb25SZWYud2l0aGRyYXcod2l0aGRyYXdJRDogd2l0aGRyYXdJRCkKICAgICAgICAvLyBEZXBvc2l0IHRoZSBORlQgaW4gdGhlIHJlY2lwaWVudCcncyBjb2xsZWN0aW9uCiAgICAgICAgcmVjaXBpZW50UmVmIS5kZXBvc2l0KHRva2VuOiA8LW5mdCkKICAgICAgICBTdG9yYWdlUmVudC50cnlSZWZpbGwocmVjaXBpZW50QWRkcikKICAgIH0KfQ\u003d\u003d", + "sendNFT": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgc2VuZE5GVCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCmltcG9ydCA8TkZUPiBmcm9tIDxORlRBZGRyZXNzPgoKLy8gdG9kbwovLyBUaGlzIHRyYW5zYWN0aW9uIGlzIGZvciB0cmFuc2ZlcnJpbmcgYW5kIE5GVCBmcm9tCi8vIG9uZSBhY2NvdW50IHRvIGFub3RoZXIKCnRyYW5zYWN0aW9uKHJlY2lwaWVudEFkZHI6IEFkZHJlc3MsIHdpdGhkcmF3SUQ6IFVJbnQ2NCkgewoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgIC8vIGdldCB0aGUgcmVjaXBpZW50cyBwdWJsaWMgYWNjb3VudCBvYmplY3QKICAgICAgICBsZXQgcmVjaXBpZW50ID0gZ2V0QWNjb3VudChyZWNpcGllbnRBZGRyKQoKICAgICAgICAvLyBib3Jyb3cgYSByZWZlcmVuY2UgdG8gdGhlIHNpZ25lcidzIE5GVCBjb2xsZWN0aW9uCiAgICAgICAgbGV0IGNvbGxlY3Rpb25SZWYgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChOb25GdW5naWJsZVRva2VuLldpdGhkcmF3KSAme05vbkZ1bmdpYmxlVG9rZW4uUHJvdmlkZXJ9Pihmcm9tOiA8Q29sbGVjdGlvblN0b3JhZ2VQYXRoPikKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgYSByZWZlcmVuY2UgdG8gdGhlIG93bmVyJ3MgY29sbGVjdGlvbiIpCgogICAgICAgIC8vIGJvcnJvdyBhIHB1YmxpYyByZWZlcmVuY2UgdG8gdGhlIHJlY2VpdmVycyBjb2xsZWN0aW9uCiAgICAgICAgbGV0IGRlcG9zaXRSZWYgPSByZWNpcGllbnQKICAgICAgICAgICAgLmNhcGFiaWxpdGllcwogICAgICAgICAgICAuYm9ycm93PCZ7Tm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9ufT4oPENvbGxlY3Rpb25QdWJsaWNQYXRoPikKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgYSByZWZlcmVuY2UgdG8gdGhlIHJlY2VpdmVyJ3MgY29sbGVjdGlvbiIpCgogICAgICAgIC8vIHdpdGhkcmF3IHRoZSBORlQgZnJvbSB0aGUgb3duZXIncyBjb2xsZWN0aW9uCiAgICAgICAgbGV0IG5mdCA8LSBjb2xsZWN0aW9uUmVmLndpdGhkcmF3KHdpdGhkcmF3SUQ6IHdpdGhkcmF3SUQpCgogICAgICAgIC8vIERlcG9zaXQgdGhlIE5GVCBpbiB0aGUgcmVjaXBpZW50J3MgY29sbGVjdGlvbgogICAgICAgIGRlcG9zaXRSZWYuZGVwb3NpdCh0b2tlbjogPC1uZnQpCgogICAgfQp9", + "sendNFTV3": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgc2VuZE5GVFYzIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4MWQ3ZTU3YWE1NTgxNzQ0OAoKaW1wb3J0IFN0b3JhZ2VSZW50IGZyb20gMHg3MDdhZGJhZDE0MjhjNjI0CgppbXBvcnQgPE5GVD4gZnJvbSA8TkZUQWRkcmVzcz4KCi8vIFRoaXMgdHJhbnNhY3Rpb24gaXMgZm9yIHRyYW5zZmVycmluZyBhbmQgTkZUIGZyb20KLy8gb25lIGFjY291bnQgdG8gYW5vdGhlcgoKdHJhbnNhY3Rpb24ocmVjaXBpZW50QWRkcjogQWRkcmVzcywgd2l0aGRyYXdJRDogVUludDY0KSB7CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSwgQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgLy8gZ2V0IHRoZSByZWNpcGllbnRzIHB1YmxpYyBhY2NvdW50IG9iamVjdAogICAgICAgIGxldCByZWNpcGllbnQgPSBnZXRBY2NvdW50KHJlY2lwaWVudEFkZHIpCgogICAgICAgIC8vIGJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgc2lnbmVyJ3MgTkZUIGNvbGxlY3Rpb24KICAgICAgICBsZXQgY29sbGVjdGlvblJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKE5vbkZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7Tm9uRnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+KGZyb206IDxDb2xsZWN0aW9uU3RvcmFnZVBhdGg+KQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgb3duZXIncyBjb2xsZWN0aW9uIikKCiAgICAgICAgLy8gYm9ycm93IGEgcHVibGljIHJlZmVyZW5jZSB0byB0aGUgcmVjZWl2ZXJzIGNvbGxlY3Rpb24KICAgICAgICBsZXQgZGVwb3NpdFJlZiA9IHJlY2lwaWVudAogICAgICAgICAgICAuY2FwYWJpbGl0aWVzCiAgICAgICAgICAgIC5ib3Jyb3c8JntOb25GdW5naWJsZVRva2VuLkNvbGxlY3Rpb259Pig8Q29sbGVjdGlvblB1YmxpY1BhdGg+KQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgcmVjZWl2ZXIncyBjb2xsZWN0aW9uIikKCiAgICAgICAgLy8gd2l0aGRyYXcgdGhlIE5GVCBmcm9tIHRoZSBvd25lcidzIGNvbGxlY3Rpb24KICAgICAgICBsZXQgbmZ0IDwtIGNvbGxlY3Rpb25SZWYud2l0aGRyYXcod2l0aGRyYXdJRDogd2l0aGRyYXdJRCkKCiAgICAgICAgLy8gRGVwb3NpdCB0aGUgTkZUIGluIHRoZSByZWNpcGllbnQncyBjb2xsZWN0aW9uCiAgICAgICAgZGVwb3NpdFJlZi5kZXBvc2l0KHRva2VuOiA8LW5mdCkKICAgICAgICBTdG9yYWdlUmVudC50cnlSZWZpbGwocmVjaXBpZW50QWRkcikKCiAgICB9Cn0\u003d" + }, + "contract": { + "getContractByName": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Q29udHJhY3RCeU5hbWUgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MsIGNvbnRyYWN0TmFtZTogU3RyaW5nKTogU3RyaW5nPyB7CiAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgbGV0IGRlcGxveWVkQ29udHJhY3QgPSBhY2NvdW50LmNvbnRyYWN0cy5nZXQobmFtZTogY29udHJhY3ROYW1lKQoKICByZXR1cm4gU3RyaW5nLmZyb21VVEY4KGRlcGxveWVkQ29udHJhY3Q/LmNvZGUhKQp9", + "getContractNames": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Q29udHJhY3ROYW1lcyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6ICZbU3RyaW5nXSB7CiAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgcmV0dXJuIGFjY291bnQuY29udHJhY3RzLm5hbWVzCn0\u003d" + }, + "evm": { + "batchEoaCallContract": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYmF0Y2hFb2FDYWxsQ29udHJhY3QgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHgxNjU0NjUzMzk5MDQwYTYxCgppbXBvcnQgRVZNIGZyb20gMHhlNDY3YjlkZDExZmEwMGRmCgoKdHJhbnNhY3Rpb24ocmxwRW5jb2RlZFRyYW5zYWN0aW9uczogW1tVSW50OF1dLCAgY29pbmJhc2VBZGRyOiBTdHJpbmcpIHsKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChTdG9yYWdlLCBFVk0uV2l0aGRyYXcpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IGNvaW5iYXNlID0gRVZNLmFkZHJlc3NGcm9tU3RyaW5nKGNvaW5iYXNlQWRkcikKCiAgICAgICAgZm9yIGluZGV4LCBybHBFbmNvZGVkVHJhbnNhY3Rpb24gaW4gcmxwRW5jb2RlZFRyYW5zYWN0aW9ucyB7CiAgICAgICAgICAgIGxldCBydW5SZXN1bHQgPSBFVk0ucnVuKHR4OiBybHBFbmNvZGVkVHJhbnNhY3Rpb24sIGNvaW5iYXNlOiBjb2luYmFzZSkKICAgICAgICAgICAgYXNzZXJ0KAogICAgICAgICAgICAgICAgcnVuUmVzdWx0LnN0YXR1cyA9PSBFVk0uU3RhdHVzLnN1Y2Nlc3NmdWwsCiAgICAgICAgICAgICAgICBtZXNzYWdlOiAiZXZtIHR4IHdhcyBub3QgZXhlY3V0ZWQgc3VjY2Vzc2Z1bGx5LiIKICAgICAgICAgICAgKQogICAgICAgIH0KICAgIH0KICAgIAogICAgZXhlY3V0ZSB7CiAgICB9Cn0K", + "call": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY2FsbCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4ZTQ2N2I5ZGQxMWZhMDBkZgoKCmFjY2VzcyhhbGwpCmZ1biBtYWluKGhleEVuY29kZWREYXRhOiBTdHJpbmcsIGhleEVuY29kZWRBZGRyZXNzOiBTdHJpbmcpOiBTdHJpbmcgewogICAgbGV0IGFjY291bnQgPSBnZXRBdXRoQWNjb3VudDxhdXRoKFN0b3JhZ2UpICZBY2NvdW50PihBZGRyZXNzKDB4Q09BKSkKCiAgICBsZXQgY29hID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzxhdXRoKEVWTS5DYWxsKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KAogICAgICAgIGZyb206IC9zdG9yYWdlL2V2bQogICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQogICAgbGV0IGFkZHJlc3NCeXRlcyA9IGhleEVuY29kZWRBZGRyZXNzLmRlY29kZUhleCgpLnRvQ29uc3RhbnRTaXplZDxbVUludDg7IDIwXT4oKSEKCiAgICBsZXQgdHhSZXN1bHQgPSBjb2EuY2FsbCgKICAgICAgICB0bzogRVZNLkVWTUFkZHJlc3MoYnl0ZXM6IGFkZHJlc3NCeXRlcyksCiAgICAgICAgZGF0YTogaGV4RW5jb2RlZERhdGEuZGVjb2RlSGV4KCksCiAgICAgICAgZ2FzTGltaXQ6IDE1MDAwMDAwLCAvLyB0b2RvIG1ha2UgaXQgY29uZmlndXJhYmxlLCBtYXggZm9yIG5vdwogICAgICAgIHZhbHVlOiBFVk0uQmFsYW5jZShhdHRvZmxvdzogMCkKICAgICkKCiAgICBhc3NlcnQoCiAgICAgICAgdHhSZXN1bHQuc3RhdHVzID09IEVWTS5TdGF0dXMuZmFpbGVkIHx8IHR4UmVzdWx0LnN0YXR1cyA9PSBFVk0uU3RhdHVzLnN1Y2Nlc3NmdWwsCiAgICAgICAgbWVzc2FnZTogImV2bV9lcnJvcj0iLmNvbmNhdCh0eFJlc3VsdC5lcnJvck1lc3NhZ2UpLmNvbmNhdCgiXG4iKQogICAgKQoKICAgIHJldHVybiBTdHJpbmcuZW5jb2RlSGV4KGNhbGxSZXN1bHQuZGF0YSkKfQo\u003d", + "callContract": "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\u003d\u003d", + "callContractV2": "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", + "checkCoaLink": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY2hlY2tDb2FMaW5rIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRVZNIGZyb20gMHhlNDY3YjlkZDExZmEwMGRmCgoKLy8vIFJldHVybnMgd2hldGhlciBhIENPQSBpcyBzdG9yZWQgYW5kIGl0cyBwdWJsaWMgY2FwYWJpbGl0eSBpcyBwdWJsaXNoZWQKLy8vCi8vLyBAcGFyYW0gZmxvd0FkZHJlc3M6IFRoZSBGbG93IGFkZHJlc3MgdG8gY2hlY2sgZm9yIGEgQ09BCi8vLwovLy8gQHJldHVybiBCb29sOiBXaGV0aGVyIGEgQ09BIGlzIHN0b3JlZCBhbmQgaXRzIHB1YmxpYyBjYXBhYmlsaXR5IGlzIHB1Ymxpc2hlZCwgbmlsIGlmIG5vIENPQSBpcyBzdG9yZWQKLy8vCmFjY2VzcyhhbGwpIGZ1biBtYWluKGZsb3dBZGRyZXNzOiBBZGRyZXNzKTogQm9vbD8gewogICAgLy8gQm9ycm93IHRoZSBDT0EgdG8gY2hlY2sgaWYgb25lIGlzIHN0b3JlZAogICAgaWYgbGV0IGFkZHJlc3M6IEVWTS5FVk1BZGRyZXNzID0gZ2V0QXV0aEFjY291bnQ8YXV0aChCb3Jyb3dWYWx1ZSkgJkFjY291bnQ+KGZsb3dBZGRyZXNzKQogICAgICAgIC5zdG9yYWdlLmJvcnJvdzwmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KGZyb206IC9zdG9yYWdlL2V2bSk/LmFkZHJlc3MoKSB7CiAgICAgICAgLy8gQ09BIGZvdW5kIC0gY2hlY2sgaWYgdGhlIHB1YmxpYyBjYXBhYmlsaXR5IGlzIHB1Ymxpc2hlZAogICAgICAgIHJldHVybiBnZXRBY2NvdW50KGZsb3dBZGRyZXNzKS5jYXBhYmlsaXRpZXMuYm9ycm93PCZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oL3B1YmxpYy9ldm0pICE9IG5pbAogICAgfQogICAgLy8gTm8gQ09BIGZvdW5kIC0gcmV0dXJuIG5pbAogICAgcmV0dXJuIG5pbAp9", + "coaLink": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY29hTGluayAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IENyeXB0bwppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKaW1wb3J0IEZsb3dUb2tlbiBmcm9tIDB4MTY1NDY1MzM5OTA0MGE2MQoKaW1wb3J0IEVWTSBmcm9tIDB4ZTQ2N2I5ZGQxMWZhMDBkZgoKCi8vLyBUaGlzIHRyYW5zYWN0aW9uIHB1Ymxpc2hlcyBhIHB1YmxpYyAqKnVuZW50aXRsZWQqKiBjYXBhYmlsaXR5IGZvciB0aGUgQ09BIHN0b3JlZCBpbiB0aGUgc2lnbmluZyBhY2NvdW50J3Mgc3RvcmFnZQovLy8gd2hlcmUgYSBDT0EgaGFzIGFscmVhZHkgYmVlbiBzdG9yZWQuCi8vLwp0cmFuc2FjdGlvbiB7CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoQm9ycm93VmFsdWUsIFN0b3JhZ2VDYXBhYmlsaXRpZXMsIFB1Ymxpc2hDYXBhYmlsaXR5LCBVbnB1Ymxpc2hDYXBhYmlsaXR5KSAmQWNjb3VudCkgewogICAgICAgIC8vIEVuc3VyZSBhIENPQSBpcyBzdG9yZWQKICAgICAgICBsZXQgY29hUGF0aCA9IC9zdG9yYWdlL2V2bQogICAgICAgIGxldCBjb2EgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChFVk0uQ2FsbCkgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50Pihmcm9tOiAvc3RvcmFnZS9ldm0pCiAgICAgICAgICAgID8/IHBhbmljKAogICAgICAgICAgICAgICAgIkNvdWxkIG5vdCBmaW5kIENPQSBpbiBzdG9yYWdlIGF0IHBhdGggIi5jb25jYXQoY29hUGF0aC50b1N0cmluZygpKQogICAgICAgICAgICAgICAgLmNvbmNhdCgiLiBNYWtlIHN1cmUgdGhlIHNpZ25pbmcgYWNjb3VudCBoYXMgaW5pdGlhbGl6ZWQgYSBDT0EgYXQgdGhlIGV4cGVjdGVkIHBhdGguIikKICAgICAgICAgICAgKQoKICAgICAgICAvLyBQdWJsaXNoIGEgcHVibGljICoqdW5lbnRpdGxlZCoqIGNhcGFiaWxpdHkKICAgICAgICBsZXQgY29hUHVibGljUGF0aCA9IC9wdWJsaWMvZXZtCiAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy51bnB1Ymxpc2goY29hUHVibGljUGF0aCkKICAgICAgICBsZXQgY29hQ2FwYWJpbGl0eSA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTwmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KGNvYVBhdGgpCiAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5wdWJsaXNoKGNvYUNhcGFiaWxpdHksIGF0OiBjb2FQdWJsaWNQYXRoKQogICAgfQp9", + "createCoa": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY3JlYXRlQ29hIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKaW1wb3J0IEZsb3dUb2tlbiBmcm9tIDB4MTY1NDY1MzM5OTA0MGE2MQoKaW1wb3J0IEVWTSBmcm9tIDB4ZTQ2N2I5ZGQxMWZhMDBkZgoKCgovLy8gQ3JlYXRlcyBhIENPQSBhbmQgc2F2ZXMgaXQgaW4gdGhlIHNpZ25lcidzIEZsb3cgYWNjb3VudCAmIHBhc3NpbmcgdGhlIGdpdmVuIHZhbHVlIG9mIEZsb3cgaW50byBGbG93RVZNCnRyYW5zYWN0aW9uKGFtb3VudDogVUZpeDY0KSB7CiAgICBsZXQgc2VudFZhdWx0OiBARmxvd1Rva2VuLlZhdWx0CiAgICBsZXQgYXV0aDogYXV0aChJc3N1ZVN0b3JhZ2VDYXBhYmlsaXR5Q29udHJvbGxlciwgSXNzdWVTdG9yYWdlQ2FwYWJpbGl0eUNvbnRyb2xsZXIsIFB1Ymxpc2hDYXBhYmlsaXR5LCBTYXZlVmFsdWUsIFVucHVibGlzaENhcGFiaWxpdHkpICZBY2NvdW50CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoQm9ycm93VmFsdWUsIElzc3VlU3RvcmFnZUNhcGFiaWxpdHlDb250cm9sbGVyLCBQdWJsaXNoQ2FwYWJpbGl0eSwgU2F2ZVZhbHVlLCBVbnB1Ymxpc2hDYXBhYmlsaXR5KSAmQWNjb3VudCkgewogICAgICAgIGxldCB2YXVsdFJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZGbG93VG9rZW4uVmF1bHQ+KAogICAgICAgICAgICAgICAgZnJvbTogL3N0b3JhZ2UvZmxvd1Rva2VuVmF1bHQKICAgICAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIG93bmVyJ3MgVmF1bHQhIikKCiAgICAgICAgc2VsZi5zZW50VmF1bHQgPC0gdmF1bHRSZWYud2l0aGRyYXcoYW1vdW50OiBhbW91bnQpIGFzISBARmxvd1Rva2VuLlZhdWx0CiAgICAgICAgc2VsZi5hdXRoID0gc2lnbmVyCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgbGV0IGNvYSA8LSBFVk0uY3JlYXRlQ2FkZW5jZU93bmVkQWNjb3VudCgpCiAgICAgICAgY29hLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKCiAgICAgICAgbG9nKGNvYS5iYWxhbmNlKCkuaW5GTE9XKCkpCiAgICAgICAgbGV0IHN0b3JhZ2VQYXRoID0gU3RvcmFnZVBhdGgoaWRlbnRpZmllcjogImV2bSIpIQogICAgICAgIGxldCBwdWJsaWNQYXRoID0gUHVibGljUGF0aChpZGVudGlmaWVyOiAiZXZtIikhCiAgICAgICAgc2VsZi5hdXRoLnN0b3JhZ2Uuc2F2ZTxARVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KDwtY29hLCB0bzogc3RvcmFnZVBhdGgpCiAgICAgICAgbGV0IGFkZHJlc3NhYmxlQ2FwID0gc2VsZi5hdXRoLmNhcGFiaWxpdGllcy5zdG9yYWdlLmlzc3VlPCZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oc3RvcmFnZVBhdGgpCiAgICAgICAgc2VsZi5hdXRoLmNhcGFiaWxpdGllcy51bnB1Ymxpc2gocHVibGljUGF0aCkKICAgICAgICBzZWxmLmF1dGguY2FwYWJpbGl0aWVzLnB1Ymxpc2goYWRkcmVzc2FibGVDYXAsIGF0OiBwdWJsaWNQYXRoKQogICAgfQp9", + "createCoaEmpty": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY3JlYXRlQ29hRW1wdHkgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHgxNjU0NjUzMzk5MDQwYTYxCgppbXBvcnQgRVZNIGZyb20gMHhlNDY3YjlkZDExZmEwMGRmCgoKCi8vLyBDcmVhdGVzIGEgQ09BIGFuZCBzYXZlcyBpdCBpbiB0aGUgc2lnbmVyJ3MgRmxvdyBhY2NvdW50ICYgcGFzc2luZyB0aGUgZ2l2ZW4gdmFsdWUgb2YgRmxvdyBpbnRvIEZsb3dFVk0KdHJhbnNhY3Rpb24oKSB7CiAgICBsZXQgYXV0aDogYXV0aChJc3N1ZVN0b3JhZ2VDYXBhYmlsaXR5Q29udHJvbGxlciwgSXNzdWVTdG9yYWdlQ2FwYWJpbGl0eUNvbnRyb2xsZXIsIFB1Ymxpc2hDYXBhYmlsaXR5LCBTYXZlVmFsdWUsIFVucHVibGlzaENhcGFiaWxpdHkpICZBY2NvdW50CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoQm9ycm93VmFsdWUsIElzc3VlU3RvcmFnZUNhcGFiaWxpdHlDb250cm9sbGVyLCBQdWJsaXNoQ2FwYWJpbGl0eSwgU2F2ZVZhbHVlLCBVbnB1Ymxpc2hDYXBhYmlsaXR5KSAmQWNjb3VudCkgewogICAgICAgIGxldCB2YXVsdFJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZGbG93VG9rZW4uVmF1bHQ+KAogICAgICAgICAgICAgICAgZnJvbTogL3N0b3JhZ2UvZmxvd1Rva2VuVmF1bHQKICAgICAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIG93bmVyJ3MgVmF1bHQhIikKICAgICAgICBzZWxmLmF1dGggPSBzaWduZXIKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBsZXQgY29hIDwtIEVWTS5jcmVhdGVDYWRlbmNlT3duZWRBY2NvdW50KCkKICAgICAgICBsZXQgc3RvcmFnZVBhdGggPSBTdG9yYWdlUGF0aChpZGVudGlmaWVyOiAiZXZtIikhCiAgICAgICAgbGV0IHB1YmxpY1BhdGggPSBQdWJsaWNQYXRoKGlkZW50aWZpZXI6ICJldm0iKSEKICAgICAgICBzZWxmLmF1dGguc3RvcmFnZS5zYXZlPEBFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oPC1jb2EsIHRvOiBzdG9yYWdlUGF0aCkKICAgICAgICBsZXQgYWRkcmVzc2FibGVDYXAgPSBzZWxmLmF1dGguY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8JkVWTS5DYWRlbmNlT3duZWRBY2NvdW50PihzdG9yYWdlUGF0aCkKICAgICAgICBzZWxmLmF1dGguY2FwYWJpbGl0aWVzLnVucHVibGlzaChwdWJsaWNQYXRoKQogICAgICAgIHNlbGYuYXV0aC5jYXBhYmlsaXRpZXMucHVibGlzaChhZGRyZXNzYWJsZUNhcCwgYXQ6IHB1YmxpY1BhdGgpCiAgICB9Cn0\u003d", + "deployContract": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZGVwbG95Q29udHJhY3QgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBFVk0gZnJvbSAweGU0NjdiOWRkMTFmYTAwZGYKCgoKdHJhbnNhY3Rpb24oY29kZTogU3RyaW5nKSB7CiAgICBsZXQgY29hOiBhdXRoKEVWTS5EZXBsb3kpICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudAoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgc2VsZi5jb2EgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChFVk0uRGVwbG95KSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KAogICAgICAgIGZyb206IC9zdG9yYWdlL2V2bSkgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgcmVmZXJlbmNlIHRvIHRoZSBDT0EhIikKCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgIHNlbGYuY29hLmRlcGxveShjb2RlOiBjb2RlLmRlY29kZUhleCgpLCAgZ2FzTGltaXQ6IDE1MDAwMDAwLCB2YWx1ZTogRVZNLkJhbGFuY2UoYXR0b2Zsb3c6IDApKQogICAgfQp9Cg\u003d\u003d", + "estimateGas": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZXN0aW1hdGVHYXMgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBFVk0gZnJvbSAweGU0NjdiOWRkMTFmYTAwZGYKCgphY2Nlc3MoYWxsKQpmdW4gbWFpbihoZXhFbmNvZGVkVHg6IFN0cmluZywgYWRkcmVzczogQWRkcmVzcyk6IFtVSW50NjQ7IDJdIHsKICAgIGxldCBhY2NvdW50ID0gZ2V0QXV0aEFjY291bnQ8YXV0aChTdG9yYWdlKSAmQWNjb3VudD4oYWRkcmVzcykKCiAgICBsZXQgY29hID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzwmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KAogICAgICAgIGZyb206IC9zdG9yYWdlL2V2bQogICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQogICAgbGV0IHR4UmVzdWx0ID0gRVZNLnJ1bih0eDogaGV4RW5jb2RlZFR4LmRlY29kZUhleCgpLCBjb2luYmFzZTogY29hLmFkZHJlc3MoKSkKCiAgICBhc3NlcnQoCiAgICAgICAgdHhSZXN1bHQuc3RhdHVzID09IEVWTS5TdGF0dXMuZmFpbGVkIHx8IHR4UmVzdWx0LnN0YXR1cyA9PSBFVk0uU3RhdHVzLnN1Y2Nlc3NmdWwsCiAgICAgICAgbWVzc2FnZTogImV2bV9lcnJvcj0iLmNvbmNhdCh0eFJlc3VsdC5lcnJvck1lc3NhZ2UpLmNvbmNhdCgiXG4iKQogICAgKQoKICAgIHJldHVybiBbdHhSZXN1bHQuZXJyb3JDb2RlLCB0eFJlc3VsdC5nYXNVc2VkXQp9Cg\u003d\u003d", + "fundCoa": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZnVuZENvYSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDE2NTQ2NTMzOTkwNDBhNjEKCmltcG9ydCBFVk0gZnJvbSAweGU0NjdiOWRkMTFmYTAwZGYKCgp0cmFuc2FjdGlvbihhbW91bnQ6IFVGaXg2NCkgewogICAgbGV0IHNlbnRWYXVsdDogQEZsb3dUb2tlbi5WYXVsdAogICAgbGV0IGF1dGg6IGF1dGgoU3RvcmFnZSkgJkFjY291bnQKICAgIGxldCBjb2E6ICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudAoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IHZhdWx0UmVmID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJkZsb3dUb2tlbi5WYXVsdD4oCiAgICAgICAgICAgIGZyb206IC9zdG9yYWdlL2Zsb3dUb2tlblZhdWx0CiAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIG93bmVyJ3MgVmF1bHQhIikKCgogICAgICAgIGxldCBjb2EgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8JkVWTS5DYWRlbmNlT3duZWRBY2NvdW50PigKICAgICAgICAgICAgZnJvbTogL3N0b3JhZ2UvZXZtCiAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQoKICAgICAgICBzZWxmLnNlbnRWYXVsdCA8LSB2YXVsdFJlZi53aXRoZHJhdyhhbW91bnQ6IGFtb3VudCkgYXMhIEBGbG93VG9rZW4uVmF1bHQKICAgICAgICBzZWxmLmF1dGggPSBzaWduZXIKICAgICAgICBzZWxmLmNvYSA9IGNvYQogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIHNlbGYuY29hLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKICAgIH0KfQo\u003d", + "fundEvmAddr": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZnVuZEV2bUFkZHIgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHgxNjU0NjUzMzk5MDQwYTYxCgppbXBvcnQgRVZNIGZyb20gMHhlNDY3YjlkZDExZmEwMGRmCgoKdHJhbnNhY3Rpb24oZXZtQWRkcjogU3RyaW5nLCBhbW91bnQ6IFVGaXg2NCkgewoKICAgIC8vIFRoZSBWYXVsdCByZXNvdXJjZSB0aGF0IGhvbGRzIHRoZSB0b2tlbnMgdGhhdCBhcmUgYmVpbmcgdHJhbnNmZXJlZAogICAgbGV0IHNlbnRWYXVsdDogQHtGdW5naWJsZVRva2VuLlZhdWx0fQoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgICAvLyBHZXQgYSByZWZlcmVuY2UgdG8gdGhlIHNpZ25lcidzIHN0b3JlZCB2YXVsdAogICAgICAgIGxldCB2YXVsdFJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICY8VG9rZW4+LlZhdWx0Pihmcm9tOiA8VG9rZW5TdG9yYWdlUGF0aD4pCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IHJlZmVyZW5jZSB0byB0aGUgb3duZXIncyBWYXVsdCEiKQoKICAgICAgICAvLyBXaXRoZHJhdyB0b2tlbnMgZnJvbSB0aGUgc2lnbmVyJ3Mgc3RvcmVkIHZhdWx0CiAgICAgICAgc2VsZi5zZW50VmF1bHQgPC0gdmF1bHRSZWYud2l0aGRyYXcoYW1vdW50OiBhbW91bnQpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgLy8gR2V0IHRoZSByZWNpcGllbnQncyBwdWJsaWMgYWNjb3VudCBvYmplY3QKICAgICAgICBsZXQgcmVjaXBpZW50QWNjb3VudCA9IGdldEFjY291bnQocmVjaXBpZW50KQoKICAgICAgICAvLyBHZXQgYSByZWZlcmVuY2UgdG8gdGhlIHJlY2lwaWVudCdzIFJlY2VpdmVyCiAgICAgICAgbGV0IHJlY2VpdmVyUmVmID0gcmVjaXBpZW50QWNjb3VudC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5SZWNlaXZlcn0+KDxUb2tlblJlY2VpdmVyUGF0aD4pIQogICAgICAgICAgICAKICAgICAgICAvLyBEZXBvc2l0IHRoZSB3aXRoZHJhd24gdG9rZW5zIGluIHRoZSByZWNpcGllbnQncyByZWNlaXZlcgogICAgICAgIHJlY2VpdmVyUmVmLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKICAgIH0KfQ\u003d\u003d", + "getAddr": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QWRkciAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4ZTQ2N2I5ZGQxMWZhMDBkZgoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGZsb3dBZGRyZXNzOiBBZGRyZXNzKTogU3RyaW5nPyB7CiAgICBpZiBsZXQgYWRkcmVzczogRVZNLkVWTUFkZHJlc3MgPSBnZXRBdXRoQWNjb3VudDxhdXRoKEJvcnJvd1ZhbHVlKSAmQWNjb3VudD4oZmxvd0FkZHJlc3MpCiAgICAgICAgLnN0b3JhZ2UuYm9ycm93PCZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oZnJvbTogL3N0b3JhZ2UvZXZtKT8uYWRkcmVzcygpIHsKICAgICAgICBsZXQgYnl0ZXM6IFtVSW50OF0gPSBbXQogICAgICAgIGZvciBieXRlIGluIGFkZHJlc3MuYnl0ZXMgewogICAgICAgICAgICBieXRlcy5hcHBlbmQoYnl0ZSkKICAgICAgICB9CiAgICAgICAgcmV0dXJuIFN0cmluZy5lbmNvZGVIZXgoYnl0ZXMpCiAgICB9CiAgICByZXR1cm4gbmlsCn0\u003d", + "getAssociatedFlowIdentifier": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QXNzb2NpYXRlZEZsb3dJZGVudGlmaWVyIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRVZNIGZyb20gMHhlNDY3YjlkZDExZmEwMGRmCgppbXBvcnQgRmxvd0VWTUJyaWRnZUNvbmZpZyBmcm9tIDB4MWU0YWEwYjg3ZDEwYjE0MQoKCmFjY2VzcyhhbGwpCmZ1biBtYWluKGFkZHJlc3M6IFN0cmluZyk6IFN0cmluZz8gewogICAgaWYgbGV0IHR5cGVJbmZvID0gRmxvd0VWTUJyaWRnZUNvbmZpZy5nZXRUeXBlQXNzb2NpYXRlZCh3aXRoOiBFVk0uYWRkcmVzc0Zyb21TdHJpbmcoYWRkcmVzcykpIHsKICAgICAgICByZXR1cm4gdHlwZUluZm8uaWRlbnRpZmllcgogICAgfQogICAgcmV0dXJuIG5pbAp9", + "getBalance": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QmFsYW5jZSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4ZTQ2N2I5ZGQxMWZhMDBkZgoKCmFjY2VzcyhhbGwpCmZ1biBtYWluKGhleEVuY29kZWRBZGRyZXNzOiBTdHJpbmcpOiBVSW50IHsKICAgIGxldCBhZGRyZXNzQnl0ZXMgPSBoZXhFbmNvZGVkQWRkcmVzcy5kZWNvZGVIZXgoKS50b0NvbnN0YW50U2l6ZWQ8W1VJbnQ4OyAyMF0+KCkhCiAgICBsZXQgYWRkcmVzcyA9IEVWTS5FVk1BZGRyZXNzKGJ5dGVzOiBhZGRyZXNzQnl0ZXMpCgogICAgcmV0dXJuIGFkZHJlc3MuYmFsYW5jZSgpLmluQXR0b0ZMT1coKQp9Cg\u003d\u003d", + "getCoaAddr": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Q29hQWRkciAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4ZTQ2N2I5ZGQxMWZhMDBkZgoKCmFjY2VzcyhhbGwpCmZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBTdHJpbmcgewogICAgbGV0IGFjY291bnQgPSBnZXRBdXRoQWNjb3VudDxhdXRoKFN0b3JhZ2UpICZBY2NvdW50PihhZGRyZXNzKQoKICAgIGxldCBjb2EgPSBhY2NvdW50LnN0b3JhZ2UuYm9ycm93PCZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oCiAgICAgICAgZnJvbTogL3N0b3JhZ2UvZXZtCiAgICApCgogICAgaWYgY29hID09IG5pbCB7IAogICAgICAgIHJldHVybiAiIgogICAgfSBlbHNlIHsKICAgICAgICBsZXQgY29hQWRkciA9IGNvYT8uYWRkcmVzcygpIAoKICAgICAgICBsZXQgYWRkckJ5dGU6IFtVSW50OF0gPSBbXQoKICAgICAgICBmb3IgYnl0ZSBpbiBjb2FBZGRyPy5ieXRlcyEgewogICAgICAgICAgICBhZGRyQnl0ZS5hcHBlbmQoYnl0ZSkKICAgICAgICB9CgogICAgICAgIHJldHVybiBTdHJpbmcuZW5jb2RlSGV4KGFkZHJCeXRlKQogICAgfQp9Cg\u003d\u003d", + "getCoaBalance": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Q29hQmFsYW5jZSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4ZTQ2N2I5ZGQxMWZhMDBkZgoKCmFjY2VzcyhhbGwpCmZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBVRml4NjQgewogICAgIGxldCBhY2NvdW50ID0gZ2V0QXV0aEFjY291bnQ8YXV0aChTdG9yYWdlKSAmQWNjb3VudD4oYWRkcmVzcykKCiAgICBsZXQgY29hID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzwmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KAogICAgICAgIGZyb206IC9zdG9yYWdlL2V2bQogICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQogICAgCiAgICByZXR1cm4gY29hLmJhbGFuY2UoKS5pbkZMT1coKQp9Cg\u003d\u003d", + "getCode": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Q29kZSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4ZTQ2N2I5ZGQxMWZhMDBkZgoKCmFjY2VzcyhhbGwpCmZ1biBtYWluKGhleEVuY29kZWRBZGRyZXNzOiBTdHJpbmcpOiBTdHJpbmcgewogICAgbGV0IGFkZHJlc3NCeXRlcyA9IGhleEVuY29kZWRBZGRyZXNzLmRlY29kZUhleCgpLnRvQ29uc3RhbnRTaXplZDxbVUludDg7IDIwXT4oKSEKICAgIGxldCBhZGRyZXNzID0gRVZNLkVWTUFkZHJlc3MoYnl0ZXM6IGFkZHJlc3NCeXRlcykKCiAgICByZXR1cm4gU3RyaW5nLmVuY29kZUhleChhZGRyZXNzLmNvZGUoKSkKfQo\u003d", + "getNonce": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Tm9uY2UgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBFVk0gZnJvbSAweGU0NjdiOWRkMTFmYTAwZGYKCgphY2Nlc3MoYWxsKQpmdW4gbWFpbihoZXhFbmNvZGVkQWRkcmVzczogU3RyaW5nKTogVUludDY0IHsKICAgIGxldCBhZGRyZXNzQnl0ZXMgPSBoZXhFbmNvZGVkQWRkcmVzcy5kZWNvZGVIZXgoKS50b0NvbnN0YW50U2l6ZWQ8W1VJbnQ4OyAyMF0+KCkhCiAgICBsZXQgYWRkcmVzcyA9IEVWTS5FVk1BZGRyZXNzKGJ5dGVzOiBhZGRyZXNzQnl0ZXMpCgogICAgcmV0dXJuIGFkZHJlc3Mubm9uY2UoKQp9Cg\u003d\u003d", + "newAccountAndCoa": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgbmV3QWNjb3VudEFuZENvYSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IENyeXB0bwppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKaW1wb3J0IEZsb3dUb2tlbiBmcm9tIDB4MTY1NDY1MzM5OTA0MGE2MQoKaW1wb3J0IEVWTSBmcm9tIDB4ZTQ2N2I5ZGQxMWZhMDBkZgoKCnRyYW5zYWN0aW9uKHB1YmxpY0tleTogU3RyaW5nLCBzaWduYXR1cmVBbGdvcml0aG06IFVJbnQ4LCBoYXNoQWxnb3JpdGhtOiBVSW50OCwgd2VpZ2h0OiBVRml4NjQpIHsKICAgIGxldCBzZW50VmF1bHQ6IEBGbG93VG9rZW4uVmF1bHQKICAgIGxldCBhdXRoOiBhdXRoKFN0b3JhZ2UpICZBY2NvdW50CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSkgJkFjY291bnQpIHsKCiAgICAgICAgbGV0IGFjY291bnQgPSBBY2NvdW50KHBheWVyOiBzaWduZXIpCgogICAgICAgIGxldCBrZXkgPSBQdWJsaWNLZXkoCiAgICAgICAgICAgIHB1YmxpY0tleTogcHVibGljS2V5LmRlY29kZUhleCgpLAogICAgICAgICAgICBzaWduYXR1cmVBbGdvcml0aG06IFNpZ25hdHVyZUFsZ29yaXRobShyYXdWYWx1ZTogc2lnbmF0dXJlQWxnb3JpdGhtKSEKICAgICAgICApCgogICAgICAgIGFjY291bnQua2V5cy5hZGQocHVibGljS2V5OiBrZXksIGhhc2hBbGdvcml0aG06IEhhc2hBbGdvcml0aG0ocmF3VmFsdWU6IGhhc2hBbGdvcml0aG0pISwgd2VpZ2h0OiB3ZWlnaHQpCgkJCiAgICAgICAgbGV0IHZhdWx0UmVmID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZGbG93VG9rZW4uVmF1bHQ+KAogICAgICAgICAgICBmcm9tOiAvc3RvcmFnZS9mbG93VG9rZW5WYXVsdAogICAgICAgICkgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgcmVmZXJlbmNlIHRvIHRoZSBvd25lcidzIFZhdWx0ISIpCgogICAgICAgIHNlbGYuc2VudFZhdWx0IDwtIHZhdWx0UmVmLndpdGhkcmF3KGFtb3VudDogMC4wKSBhcyEgQEZsb3dUb2tlbi5WYXVsdAogICAgICAgIHNlbGYuYXV0aCA9IGFjY291bnQKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBsZXQgYWNjb3VudCA8LSBFVk0uY3JlYXRlQ2FkZW5jZU93bmVkQWNjb3VudCgpCiAgICAgICAgbG9nKGFjY291bnQuYWRkcmVzcygpKQogICAgICAgIGFjY291bnQuZGVwb3NpdChmcm9tOiA8LXNlbGYuc2VudFZhdWx0KQoKICAgICAgICBsb2coYWNjb3VudC5iYWxhbmNlKCkpCiAgICAgICAgc2VsZi5hdXRoLnN0b3JhZ2Uuc2F2ZTxARVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KDwtYWNjb3VudCwgdG86IFN0b3JhZ2VQYXRoKGlkZW50aWZpZXI6ICJldm0iKSEpCiAgICB9Cn0K", + "removeCoa": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcmVtb3ZlQ29hIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRVZNIGZyb20gMHhlNDY3YjlkZDExZmEwMGRmCgoKdHJhbnNhY3Rpb24oKSB7CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSwgVW5wdWJsaXNoQ2FwYWJpbGl0eSkgJkFjY291bnQpIHsKICAgICAgICBsZXQgY29hUmVmID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PCZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oCiAgICAgICAgICAgIGZyb206IC9zdG9yYWdlL2V2bQogICAgICAgICkgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgcmVmZXJlbmNlIHRvIHRoZSBDT0EhIikKICAgICAgICBpZiBjb2FSZWYgIT0gbmlsIHsKICAgICAgICAgICAgbGV0IGNvYSA8LSBzaWduZXIuc3RvcmFnZS5sb2FkPEBFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oZnJvbTogL3N0b3JhZ2UvZXZtKSAKICAgICAgICAgICAgbGV0IHB1YmxpY1BhdGggPSBQdWJsaWNQYXRoKGlkZW50aWZpZXI6ICJldm0iKSEKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy51bnB1Ymxpc2gocHVibGljUGF0aCkKICAgICAgICAgICAgZGVzdHJveSBjb2EKICAgICAgICB9CiAgICB9Cn0K", + "run": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcnVuIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRVZNIGZyb20gMHhlNDY3YjlkZDExZmEwMGRmCgoKdHJhbnNhY3Rpb24oaGV4RW5jb2RlZFR4OiBTdHJpbmcpIHsKICAgIGxldCBjb2E6ICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudAoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgc2VsZi5jb2EgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8JkVWTS5DYWRlbmNlT3duZWRBY2NvdW50PigKICAgICAgICAgICAgZnJvbTogL3N0b3JhZ2UvZXZtCiAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIGxldCB0eFJlc3VsdCA9IEVWTS5ydW4odHg6IGhleEVuY29kZWRUeC5kZWNvZGVIZXgoKSwgY29pbmJhc2U6IHNlbGYuY29hLmFkZHJlc3MoKSkKICAgICAgICAvLyB0b2RvIG9ubHkgdGVtcG9yYXJ5IHVudGlsIHdlIGNvcnJlY3RseSBoYW5kbGUgZmFpbHVyZSBldmVudHMKICAgICAgICBhc3NlcnQoCiAgICAgICAgICAgIHR4UmVzdWx0LnN0YXR1cyA9PSBFVk0uU3RhdHVzLmZhaWxlZCB8fCB0eFJlc3VsdC5zdGF0dXMgPT0gRVZNLlN0YXR1cy5zdWNjZXNzZnVsLAogICAgICAgICAgICBtZXNzYWdlOiAiZXZtX2Vycm9yPSIuY29uY2F0KHR4UmVzdWx0LmVycm9yTWVzc2FnZSkuY29uY2F0KCJcbiIpCiAgICAgICAgKQogICAgfQp9Cg\u003d\u003d", + "transferCoa": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgdHJhbnNmZXJDb2EgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHgxNjU0NjUzMzk5MDQwYTYxCgppbXBvcnQgRVZNIGZyb20gMHhlNDY3YjlkZDExZmEwMGRmCgoKdHJhbnNhY3Rpb24oYW1vdW50OiBVRml4NjQsIGFkZHJlc3M6IEFkZHJlc3MpIHsKICAgIGxldCBzZW50VmF1bHQ6IEBGbG93VG9rZW4uVmF1bHQKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChTdG9yYWdlLCBFVk0uV2l0aGRyYXcpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IGNvYSA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEVWTS5XaXRoZHJhdykgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50PigKICAgICAgICAgICAgZnJvbTogL3N0b3JhZ2UvZXZtCiAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQoKICAgICAgICBzZWxmLnNlbnRWYXVsdCA8LSBjb2Eud2l0aGRyYXcoYmFsYW5jZTogRVZNLkJhbGFuY2UoYXR0b2Zsb3c6IFVJbnQoYW1vdW50KSAqIDEwMDAwMDAwMDAwMDAwMDAwMCkpIGFzISBARmxvd1Rva2VuLlZhdWx0CiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAgbGV0IHJlY2VpdmVyID0gYWNjb3VudC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5SZWNlaXZlcn0+KC9wdWJsaWMvZmxvd1Rva2VuUmVjZWl2ZXIpIQogICAgICAgIHJlY2VpdmVyLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKICAgIH0KfQo\u003d", + "transferFlowFromCoaToFlow": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgdHJhbnNmZXJGbG93RnJvbUNvYVRvRmxvdyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDE2NTQ2NTMzOTkwNDBhNjEKCmltcG9ydCBFVk0gZnJvbSAweGU0NjdiOWRkMTFmYTAwZGYKCgp0cmFuc2FjdGlvbihhbW91bnQ6IFVGaXg2NCwgYWRkcmVzczogQWRkcmVzcykgewogICAgbGV0IHNlbnRWYXVsdDogQEZsb3dUb2tlbi5WYXVsdAoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIEVWTS5XaXRoZHJhdykgJkFjY291bnQpIHsKICAgICAgICBsZXQgY29hID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoRVZNLldpdGhkcmF3KSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KAogICAgICAgICAgICBmcm9tOiAvc3RvcmFnZS9ldm0KICAgICAgICApID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IHJlZmVyZW5jZSB0byB0aGUgQ09BISIpCiAgICAgICAgbGV0IHdpdGhkcmF3QmFsYW5jZSA9IEVWTS5CYWxhbmNlKGF0dG9mbG93OiAwKQogICAgICAgIHdpdGhkcmF3QmFsYW5jZS5zZXRGTE9XKGZsb3c6IGFtb3VudCkKICAgICAgICBzZWxmLnNlbnRWYXVsdCA8LSBjb2Eud2l0aGRyYXcoYmFsYW5jZTogd2l0aGRyYXdCYWxhbmNlKSBhcyEgQEZsb3dUb2tlbi5WYXVsdAogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgIGxldCByZWNlaXZlciA9IGFjY291bnQuY2FwYWJpbGl0aWVzLmJvcnJvdzwme0Z1bmdpYmxlVG9rZW4uUmVjZWl2ZXJ9PigvcHVibGljL2Zsb3dUb2tlblJlY2VpdmVyKSEKICAgICAgICByZWNlaXZlci5kZXBvc2l0KGZyb206IDwtc2VsZi5zZW50VmF1bHQpCiAgICB9Cn0K", + "transferFlowToEvmAddress": "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", + "withdrawCoa": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgd2l0aGRyYXdDb2EgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHgxNjU0NjUzMzk5MDQwYTYxCgppbXBvcnQgRVZNIGZyb20gMHhlNDY3YjlkZDExZmEwMGRmCgoKdHJhbnNhY3Rpb24oYW1vdW50OiBVRml4NjQsIGFkZHJlc3M6IEFkZHJlc3MpIHsKICAgIGxldCBzZW50VmF1bHQ6IEBGbG93VG9rZW4uVmF1bHQKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChTdG9yYWdlLCBFVk0uV2l0aGRyYXcpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IGNvYSA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEVWTS5XaXRoZHJhdykgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50PigKICAgICAgICAgICAgZnJvbTogL3N0b3JhZ2UvZXZtCiAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQogICAgICAgIGxldCB3aXRoZHJhd0JhbGFuY2UgPSBFVk0uQmFsYW5jZShhdHRvZmxvdzogMCkKICAgICAgICB3aXRoZHJhd0JhbGFuY2Uuc2V0RkxPVyhmbG93OiBhbW91bnQpCiAgICAgICAgc2VsZi5zZW50VmF1bHQgPC0gY29hLndpdGhkcmF3KGJhbGFuY2U6IHdpdGhkcmF3QmFsYW5jZSkgYXMhIEBGbG93VG9rZW4uVmF1bHQKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBsZXQgYWNjb3VudCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgICBsZXQgcmVjZWl2ZXIgPSBhY2NvdW50LmNhcGFiaWxpdGllcy5ib3Jyb3c8JntGdW5naWJsZVRva2VuLlJlY2VpdmVyfT4oL3B1YmxpYy9mbG93VG9rZW5SZWNlaXZlcikhCiAgICAgICAgcmVjZWl2ZXIuZGVwb3NpdChmcm9tOiA8LXNlbGYuc2VudFZhdWx0KQogICAgfQp9Cg\u003d\u003d" + }, "ft": { - "isTokenListEnabled": "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\u003d\u003d", - "isLinkedAccountTokenListEnabled": "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\u003d\u003d", - "getTokenListBalance": "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\u003d\u003d", - "addToken": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYWRkVG9rZW4gLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgppbXBvcnQgPFRva2VuPiBmcm9tIDxUb2tlbkFkZHJlc3M+Cgp0cmFuc2FjdGlvbiB7CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSwgQ2FwYWJpbGl0aWVzKSAmQWNjb3VudCkgewoKICAgICAgICBpZiBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8JjxUb2tlbj4uVmF1bHQ+KGZyb206IDxUb2tlblN0b3JhZ2VQYXRoPiApID09IG5pbCB7CiAgICAgICAgICAgIHNpZ25lci5zdG9yYWdlLnNhdmUoPC0gPFRva2VuPi5jcmVhdGVFbXB0eVZhdWx0KHZhdWx0VHlwZTogVHlwZTxAPFRva2VuPi5WYXVsdD4oKSksIHRvOiA8VG9rZW5TdG9yYWdlUGF0aD4pCiAgICAgICAgfQoKICAgICAgICBpZiBzaWduZXIuY2FwYWJpbGl0aWVzLmV4aXN0cyg8VG9rZW5SZWNlaXZlclBhdGg+KSA9PSBmYWxzZSB7CiAgICAgICAgICAgIGxldCByZWNlaXZlckNhcGFiaWxpdHkgPSBzaWduZXIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8JjxUb2tlbj4uVmF1bHQ+KDxUb2tlblN0b3JhZ2VQYXRoPikKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5wdWJsaXNoKHJlY2VpdmVyQ2FwYWJpbGl0eSwgYXQ6IDxUb2tlblJlY2VpdmVyUGF0aD4pCiAgICAgICAgCiAgICAgICAgfQogICAgICAgCiAgICAgICAgaWYgc2lnbmVyLmNhcGFiaWxpdGllcy5leGlzdHMoPFRva2VuQmFsYW5jZVBhdGg+KSA9PSBmYWxzZSB7CiAgICAgICAgICAgIGxldCBiYWxhbmNlQ2FwYWJpbGl0eSA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTwmPFRva2VuPi5WYXVsdD4oPFRva2VuU3RvcmFnZVBhdGg+KQogICAgICAgICAgICBzaWduZXIuY2FwYWJpbGl0aWVzLnB1Ymxpc2goYmFsYW5jZUNhcGFiaWxpdHksIGF0OiA8VG9rZW5CYWxhbmNlUGF0aD4pCiAgICAgICAgfQogICAgCiAgICB9Cn0\u003d", - "enableTokenStorage": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZW5hYmxlVG9rZW5TdG9yYWdlIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKaW1wb3J0IDxUb2tlbj4gZnJvbSA8VG9rZW5BZGRyZXNzPgoKdHJhbnNhY3Rpb24gewoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIENhcGFiaWxpdGllcykgJkFjY291bnQpIHsKCiAgICAgICAgaWYgc2lnbmVyLnN0b3JhZ2UuYm9ycm93PCY8VG9rZW4+LlZhdWx0Pihmcm9tOiA8VG9rZW5TdG9yYWdlUGF0aD4gKSA9PSBuaWwgewogICAgICAgICAgICBzaWduZXIuc3RvcmFnZS5zYXZlKDwtIDxUb2tlbj4uY3JlYXRlRW1wdHlWYXVsdCh2YXVsdFR5cGU6IFR5cGU8QDxUb2tlbj4uVmF1bHQ+KCkpLCB0bzogPFRva2VuU3RvcmFnZVBhdGg+KQogICAgICAgIH0KCiAgICAgICAgaWYgc2lnbmVyLmNhcGFiaWxpdGllcy5leGlzdHMoPFRva2VuUmVjZWl2ZXJQYXRoPikgPT0gZmFsc2UgewogICAgICAgICAgICBsZXQgcmVjZWl2ZXJDYXBhYmlsaXR5ID0gc2lnbmVyLmNhcGFiaWxpdGllcy5zdG9yYWdlLmlzc3VlPCY8VG9rZW4+LlZhdWx0Pig8VG9rZW5TdG9yYWdlUGF0aD4pCiAgICAgICAgICAgIHNpZ25lci5jYXBhYmlsaXRpZXMucHVibGlzaChyZWNlaXZlckNhcGFiaWxpdHksIGF0OiA8VG9rZW5SZWNlaXZlclBhdGg+KQogICAgICAgIAogICAgICAgIH0KICAgICAgIAogICAgICAgIGlmIHNpZ25lci5jYXBhYmlsaXRpZXMuZXhpc3RzKDxUb2tlbkJhbGFuY2VQYXRoPikgPT0gZmFsc2UgewogICAgICAgICAgICBsZXQgYmFsYW5jZUNhcGFiaWxpdHkgPSBzaWduZXIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8JjxUb2tlbj4uVmF1bHQ+KDxUb2tlblN0b3JhZ2VQYXRoPikKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5wdWJsaXNoKGJhbGFuY2VDYXBhYmlsaXR5LCBhdDogPFRva2VuQmFsYW5jZVBhdGg+KQogICAgICAgIH0KICAgIAogICAgfQp9", - "enableTokenStorageV2": "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", - "getTokenBalanceStorage": "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\u003d\u003d", - "transferEvmTokens": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgdHJhbnNmZXJFdm1Ub2tlbnMgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBFVk0gZnJvbSAweGU0NjdiOWRkMTFmYTAwZGYKCgovLy8gVHJhbnNmZXJzICRGTE9XIGZyb20gdGhlIHNpZ25lcidzIGFjY291bnQgQ2FkZW5jZSBGbG93IGJhbGFuY2UgdG8gdGhlIHJlY2lwaWVudCdzIGhleC1lbmNvZGVkIEVWTSBhZGRyZXNzLgovLy8gTm90ZSB0aGF0IGEgQ09BIG11c3QgaGF2ZSBhICRGTE9XIGJhbGFuY2UgaW4gRVZNIGJlZm9yZSB0cmFuc2ZlcnJpbmcgdmFsdWUgdG8gYW5vdGhlciBFVk0gYWRkcmVzcy4KLy8vCnRyYW5zYWN0aW9uKHRvRVZNQWRkcmVzc0hleDogU3RyaW5nLCBhbW91bnQ6IFVJbnQyNTYsIGdhc0xpbWl0OiBVSW50NjQpIHsKCiAgICBsZXQgY29hOiBhdXRoKEVWTS5XaXRoZHJhdywgRVZNLkNhbGwpICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudAogICAgbGV0IHJlY2lwaWVudEVWTUFkZHJlc3M6IEVWTS5FVk1BZGRyZXNzCgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoQm9ycm93VmFsdWUsIFNhdmVWYWx1ZSkgJkFjY291bnQpIHsKICAgICAgICBpZiBzaWduZXIuc3RvcmFnZS50eXBlKGF0OiAvc3RvcmFnZS9ldm0pID09IG5pbCB7CiAgICAgICAgICAgIHNpZ25lci5zdG9yYWdlLnNhdmUoPC1FVk0uY3JlYXRlQ2FkZW5jZU93bmVkQWNjb3VudCgpLCB0bzogL3N0b3JhZ2UvZXZtKQogICAgICAgIH0KICAgICAgICBzZWxmLmNvYSA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEVWTS5XaXRoZHJhdywgRVZNLkNhbGwpICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oZnJvbTogL3N0b3JhZ2UvZXZtKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIHNpZ25lcidzIGJyaWRnZWQgYWNjb3VudCIpCgogICAgICAgIHNlbGYucmVjaXBpZW50RVZNQWRkcmVzcyA9IEVWTS5hZGRyZXNzRnJvbVN0cmluZyh0b0VWTUFkZHJlc3NIZXgpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgLy8gaWYgc2VsZi5yZWNpcGllbnRFVk1BZGRyZXNzLmJ5dGVzID09IHNlbGYuY29hLmFkZHJlc3MoKS5ieXRlcyB7CiAgICAgICAgLy8gICAgIHJldHVybgogICAgICAgIC8vIH0KICAgICAgICBsZXQgZGF0YSA9ICIiCiAgICAgICAgbGV0IHR4UmVzdWx0ID0gc2VsZi5jb2EuY2FsbCgKICAgICAgICAgICAgdG86IHNlbGYucmVjaXBpZW50RVZNQWRkcmVzcywKICAgICAgICAgICAgZGF0YTogZGF0YSwKICAgICAgICAgICAgZ2FzTGltaXQ6IGdhc0xpbWl0LAogICAgICAgICAgICB2YWx1ZTogdmFsdWVCYWxhbmNlCiAgICAgICAgKQogICAgICAgIGFzc2VydCgKICAgICAgICAgICAgdHhSZXN1bHQuc3RhdHVzID09IEVWTS5TdGF0dXMuZmFpbGVkIHx8IHR4UmVzdWx0LnN0YXR1cyA9PSBFVk0uU3RhdHVzLnN1Y2Nlc3NmdWwsCiAgICAgICAgICAgIG1lc3NhZ2U6ICJldm1fZXJyb3I9Ii5jb25jYXQodHhSZXN1bHQuZXJyb3JNZXNzYWdlKS5jb25jYXQoIlxuIikKICAgICAgICApCiAgICB9Cn0\u003d", - "transferTokens": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgdHJhbnNmZXJUb2tlbnMgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgppbXBvcnQgPFRva2VuPiBmcm9tIDxUb2tlbkFkZHJlc3M+CgoKdHJhbnNhY3Rpb24oYW1vdW50OiBVRml4NjQsIHJlY2lwaWVudDogQWRkcmVzcykgewoKICAgIC8vIFRoZSBWYXVsdCByZXNvdXJjZSB0aGF0IGhvbGRzIHRoZSB0b2tlbnMgdGhhdCBhcmUgYmVpbmcgdHJhbnNmZXJlZAogICAgbGV0IHNlbnRWYXVsdDogQHtGdW5naWJsZVRva2VuLlZhdWx0fQoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgICAvLyBHZXQgYSByZWZlcmVuY2UgdG8gdGhlIHNpZ25lcidzIHN0b3JlZCB2YXVsdAogICAgICAgIGxldCB2YXVsdFJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICY8VG9rZW4+LlZhdWx0Pihmcm9tOiA8VG9rZW5TdG9yYWdlUGF0aD4pCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IHJlZmVyZW5jZSB0byB0aGUgb3duZXIncyBWYXVsdCEiKQoKICAgICAgICAvLyBXaXRoZHJhdyB0b2tlbnMgZnJvbSB0aGUgc2lnbmVyJ3Mgc3RvcmVkIHZhdWx0CiAgICAgICAgc2VsZi5zZW50VmF1bHQgPC0gdmF1bHRSZWYud2l0aGRyYXcoYW1vdW50OiBhbW91bnQpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgLy8gR2V0IHRoZSByZWNpcGllbnQncyBwdWJsaWMgYWNjb3VudCBvYmplY3QKICAgICAgICBsZXQgcmVjaXBpZW50QWNjb3VudCA9IGdldEFjY291bnQocmVjaXBpZW50KQoKICAgICAgICAvLyBHZXQgYSByZWZlcmVuY2UgdG8gdGhlIHJlY2lwaWVudCdzIFJlY2VpdmVyCiAgICAgICAgbGV0IHJlY2VpdmVyUmVmID0gcmVjaXBpZW50QWNjb3VudC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5WYXVsdH0+KDxUb2tlblJlY2VpdmVyUGF0aD4pIQogICAgICAgICAgICAKICAgICAgICAvLyBEZXBvc2l0IHRoZSB3aXRoZHJhd24gdG9rZW5zIGluIHRoZSByZWNpcGllbnQncyByZWNlaXZlcgogICAgICAgIHJlY2VpdmVyUmVmLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKCiAgICB9Cn0\u003d", - "transferTokensV3": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgdHJhbnNmZXJUb2tlbnNWMyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKCmltcG9ydCBTdG9yYWdlUmVudCBmcm9tIDB4NzA3YWRiYWQxNDI4YzYyNAoKaW1wb3J0IDxUb2tlbj4gZnJvbSA8VG9rZW5BZGRyZXNzPgoKCnRyYW5zYWN0aW9uKGFtb3VudDogVUZpeDY0LCByZWNpcGllbnQ6IEFkZHJlc3MpIHsKCiAgICAvLyBUaGUgVmF1bHQgcmVzb3VyY2UgdGhhdCBob2xkcyB0aGUgdG9rZW5zIHRoYXQgYXJlIGJlaW5nIHRyYW5zZmVyZWQKICAgIGxldCBzZW50VmF1bHQ6IEB7RnVuZ2libGVUb2tlbi5WYXVsdH0KCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChTdG9yYWdlLCBCb3Jyb3dWYWx1ZSkgJkFjY291bnQpIHsKICAgICAgICAgLy8gR2V0IGEgcmVmZXJlbmNlIHRvIHRoZSBzaWduZXIncyBzdG9yZWQgdmF1bHQKICAgICAgICBsZXQgdmF1bHRSZWYgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAmPFRva2VuPi5WYXVsdD4oZnJvbTogPFRva2VuU3RvcmFnZVBhdGg+KQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIG93bmVyJ3MgVmF1bHQhIikKCiAgICAgICAgLy8gV2l0aGRyYXcgdG9rZW5zIGZyb20gdGhlIHNpZ25lcidzIHN0b3JlZCB2YXVsdAogICAgICAgIHNlbGYuc2VudFZhdWx0IDwtIHZhdWx0UmVmLndpdGhkcmF3KGFtb3VudDogYW1vdW50KQogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIC8vIEdldCB0aGUgcmVjaXBpZW50J3MgcHVibGljIGFjY291bnQgb2JqZWN0CiAgICAgICAgbGV0IHJlY2lwaWVudEFjY291bnQgPSBnZXRBY2NvdW50KHJlY2lwaWVudCkKCiAgICAgICAgLy8gR2V0IGEgcmVmZXJlbmNlIHRvIHRoZSByZWNpcGllbnQncyBSZWNlaXZlcgogICAgICAgIGxldCByZWNlaXZlclJlZiA9IHJlY2lwaWVudEFjY291bnQuY2FwYWJpbGl0aWVzLmJvcnJvdzwme0Z1bmdpYmxlVG9rZW4uVmF1bHR9Pig8VG9rZW5SZWNlaXZlclBhdGg+KSEKICAgICAgICAgICAgCiAgICAgICAgLy8gRGVwb3NpdCB0aGUgd2l0aGRyYXduIHRva2VucyBpbiB0aGUgcmVjaXBpZW50J3MgcmVjZWl2ZXIKICAgICAgICByZWNlaXZlclJlZi5kZXBvc2l0KGZyb206IDwtc2VsZi5zZW50VmF1bHQpCiAgICAgICAgU3RvcmFnZVJlbnQudHJ5UmVmaWxsKHJlY2lwaWVudCkKCiAgICB9Cn0\u003d" + "isTokenListEnabled": "CiAgICAvLyBGbG93IFdhbGxldCAtIG1haW5uZXQgU2NyaXB0ICBpc1Rva2VuTGlzdEVuYWJsZWQgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCgogICAgaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKCgogICAgCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tGbG93VG9rZW4weDE2NTQ2NTMzOTkwNDBhNjFWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvZmxvd1Rva2VuUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9mbG93VG9rZW5CYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrQURVVG9rZW4weGU0NTJhMmY1NjY1NzI4ZjVWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvQURVVG9rZW5SZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0FEVVRva2VuTWV0YWRhdGEpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2thaVNwb3J0c0p1aWNlMHg5ZGI5NGM5NTY0MjQzYmE3VmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL2FpU3BvcnRzSnVpY2VSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL2FpU3BvcnRzSnVpY2VNZXRhZGF0YSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0JhbGxlcnpGQzB4NGVhMDQ3YzNlNzNjYTQ2MFZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9CYWxsZXJ6RkNSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0JhbGxlcnpGQ01ldGFkYXRhKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrQmVhdmVyMHg2ODdlMWE3YWVmMTdiNzhiVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0JlYXZlclJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvQmVhdmVyTWV0YWRhdGEpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tCbG9jdG9Ub2tlbjB4MGY5ZGY5MWM5MTIxYzQ2MFZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9ibG9jdG9Ub2tlblJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvYmxvY3RvVG9rZW5CYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrYnJhc2lsMHg3YmYwN2Q3MTlkY2I4NDgwVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL2JyYXNpbFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvYnJhc2lsTWV0YWRhdGEpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tjZUFWQVgweDIzMWNjMGRiYmNmZmM0YjdWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvY2VBVkFYUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9jZUFWQVhCYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrY2VCTkIweDIzMWNjMGRiYmNmZmM0YjdWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvY2VCTkJSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL2NlQk5CQmFsYW5jZSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja2NlQlVTRDB4MjMxY2MwZGJiY2ZmYzRiN1ZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9jZUJVU0RSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL2NlQlVTREJhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tjZURBSTB4MjMxY2MwZGJiY2ZmYzRiN1ZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9jZURBSVJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvY2VEQUlCYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrY2VGVE0weDIzMWNjMGRiYmNmZmM0YjdWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvY2VGVE1SZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL2NlRlRNQmFsYW5jZSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja2NlTUFUSUMweDIzMWNjMGRiYmNmZmM0YjdWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvY2VNQVRJQ1JlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvY2VNQVRJQ0JhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tjZVVTRFQweDIzMWNjMGRiYmNmZmM0YjdWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvY2VVU0RUUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9jZVVTRFRCYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrY2VXQlRDMHgyMzFjYzBkYmJjZmZjNGI3VmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL2NlV0JUQ1JlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvY2VXQlRDQmFsYW5jZSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja2NlV0VUSDB4MjMxY2MwZGJiY2ZmYzRiN1ZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9jZVdFVEhSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL2NlV0VUSEJhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tEQU1PNDIwMHgzMzk5ZDdjNmM2MDliN2U1VmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0RBTU80MjBSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0RBTU80MjBNZXRhZGF0YSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0Zsb3ZhdGFyRHVzdFRva2VuMHg5MjFlYTQ0OWRmZmVjNjhhVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0Zsb3ZhdGFyRHVzdFRva2VuUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9GbG92YXRhckR1c3RUb2tlbkJhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tGbG93QmxvY2tjaGFpbmhpdENvaW4weGQzYjYyZmZiYmM2MzJmNWFWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRmxvd0Jsb2NrY2hhaW5oaXRDb2luUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9GbG93QmxvY2tjaGFpbmhpdENvaW5NZXRhZGF0YSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0ZVU0QweDNjNTk1OWI1Njg4OTYzOTNWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvZnVzZFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvZnVzZEJhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tNYWlubGVkZ2VyMHhmZDFjY2FhYWUzOWQwZTc5VmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL01haW5sZWRnZXJSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL01haW5sZWRnZXJNZXRhZGF0YSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja1BldEpva2ljc0hvcnNlczB4NmZkMjQ2NWYzYTIyZTM0Y1ZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9QZXRKb2tpY3NIb3JzZXNSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL1BldEpva2ljc0hvcnNlc01ldGFkYXRhKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrUG9rZXJ0aW1lMHhmZDFjY2FhYWUzOWQwZTc5VmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL1Bva2VydGltZVJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvUG9rZXJ0aW1lTWV0YWRhdGEpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tSRVZWMHhkMDFlNDgyZWI2ODBlYzlmVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL3JldnZSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL3JldnZCYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrUkxZMHgyMzFjYzBkYmJjZmZjNGI3VmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL1JMWVJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvUkxZQmFsYW5jZSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja1Nsb3BweVN0YWtlczB4NTNmMzg5ZDk2ZmI0Y2U1ZVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9TbG9wcHlTdGFrZXNSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL1Nsb3BweVN0YWtlc01ldGFkYXRhKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrU3Rhcmx5VG9rZW4weDE0MmZhNjU3MGI2MmZkOTdWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvc3Rhcmx5VG9rZW5SZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL3N0YXJseVRva2VuQmFsYW5jZSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja3N0Rmxvd1Rva2VuMHhkNmY4MDU2NTE5M2FkNzI3VmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL3N0Rmxvd1Rva2VuUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9zdEZsb3dUb2tlbkJhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tUZWxlcG9ydGVkVGV0aGVyVG9rZW4weGNmZGQ5MGQ0YTAwZjdiNWJWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvdGVsZXBvcnRlZFRldGhlclRva2VuUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy90ZWxlcG9ydGVkVGV0aGVyVG9rZW5CYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrVGhlV29sZm9mRmxvdzB4ODI1OWM3M2U0ODc0MjJkN1ZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9UaGVXb2xmb2ZGbG93UmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9UaGVXb2xmb2ZGbG93TWV0YWRhdGEpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tUb3BTaG90QkVUQTB4ZWUwOTAyOWYxZGJjZDlkMVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9Ub3BTaG90QkVUQVJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvVG9wU2hvdEJFVEFNZXRhZGF0YSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja1V0YWhKYXp6TGVnZW5kc0NsdWIweGNiYmE0ZDQxYWVmODNmZTNWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvVXRhaEphenpMZWdlbmRzQ2x1YlJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvVXRhaEphenpMZWdlbmRzQ2x1Yk1ldGFkYXRhKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrVmFtcGlyZTB4NjdkYWFkOTFlMzc4MmM4MFZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9WYW1waXJlUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9WYW1waXJlTWV0YWRhdGEpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tWcm9vbVRva2VuMHhmODg3ZWNlMzkxNjY5MDZlVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL1Zyb29tVG9rZW5SZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL1Zyb29tVG9rZW5CYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRGFwcGVyVXRpbGl0eUNvaW4weGVhZDg5MjA4M2IzZTJjNmNWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvZGFwcGVyVXRpbGl0eUNvaW5SZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL2RhcHBlclV0aWxpdHlDb2luQmFsYW5jZSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja1VTRENGbG93MHhmMWFiOTljODJkZWUzNTI2VmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL3VzZGNGbG93UmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy91c2RjRmxvd01ldGFkYXRhKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fMWI5NzEwMGVhMWQ3MTI2YzRkNjAwMjdlMjMxZWE0Y2IyNTMxNGJkYjB4MWU0YWEwYjg3ZDEwYjE0MVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl8xYjk3MTAwZWExZDcxMjZjNGQ2MDAyN2UyMzFlYTRjYjI1MzE0YmRiUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl8xYjk3MTAwZWExZDcxMjZjNGQ2MDAyN2UyMzFlYTRjYjI1MzE0YmRiVmF1bHQpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tFVk1WTUJyaWRnZWRUb2tlbl9kOGFkOGFlODM3NWFhMzFiZmY1NDFlMTdkYzRiNDkxNzAxNGViZGFhMHgxZTRhYTBiODdkMTBiMTQxVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0VWTVZNQnJpZGdlZFRva2VuX2Q4YWQ4YWU4Mzc1YWEzMWJmZjU0MWUxN2RjNGI0OTE3MDE0ZWJkYWFSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0VWTVZNQnJpZGdlZFRva2VuX2Q4YWQ4YWU4Mzc1YWEzMWJmZjU0MWUxN2RjNGI0OTE3MDE0ZWJkYWFWYXVsdCkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0VWTVZNQnJpZGdlZFRva2VuXzk5NTI1OGNlYTQ5YzI1NTk1Y2Q5NDQwN2ZhZDllOTliODE0MDZhODQweDFlNGFhMGI4N2QxMGIxNDFWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRVZNVk1CcmlkZ2VkVG9rZW5fOTk1MjU4Y2VhNDljMjU1OTVjZDk0NDA3ZmFkOWU5OWI4MTQwNmE4NFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRVZNVk1CcmlkZ2VkVG9rZW5fOTk1MjU4Y2VhNDljMjU1OTVjZDk0NDA3ZmFkOWU5OWI4MTQwNmE4NFZhdWx0KQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fYjczYmY4ZTZhNDQ3N2E5NTJlMDMzOGU2Y2MwMGNjMGNlNWFkMDRiYTB4MWU0YWEwYjg3ZDEwYjE0MVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl9iNzNiZjhlNmE0NDc3YTk1MmUwMzM4ZTZjYzAwY2MwY2U1YWQwNGJhUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl9iNzNiZjhlNmE0NDc3YTk1MmUwMzM4ZTZjYzAwY2MwY2U1YWQwNGJhVmF1bHQpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tFVk1WTUJyaWRnZWRUb2tlbl82YTJjZDE0MWQ3NTg2NDk0NDMxOGFjZjI3MjQ0M2ZlYmM1NDg1NWE5MHgxZTRhYTBiODdkMTBiMTQxVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0VWTVZNQnJpZGdlZFRva2VuXzZhMmNkMTQxZDc1ODY0OTQ0MzE4YWNmMjcyNDQzZmViYzU0ODU1YTlSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0VWTVZNQnJpZGdlZFRva2VuXzZhMmNkMTQxZDc1ODY0OTQ0MzE4YWNmMjcyNDQzZmViYzU0ODU1YTlWYXVsdCkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0VWTVZNQnJpZGdlZFRva2VuXzY4ZWI2ODNhMzkzYzhhMWM4MTYyNTViNGZjNGI4OWQ3M2M1MmFkNGIweDFlNGFhMGI4N2QxMGIxNDFWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRVZNVk1CcmlkZ2VkVG9rZW5fNjhlYjY4M2EzOTNjOGExYzgxNjI1NWI0ZmM0Yjg5ZDczYzUyYWQ0YlJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRVZNVk1CcmlkZ2VkVG9rZW5fNjhlYjY4M2EzOTNjOGExYzgxNjI1NWI0ZmM0Yjg5ZDczYzUyYWQ0YlZhdWx0KQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRml4ZXNGdW5naWJsZVRva2VuMHhiOWNkOTNkM2JiMzFiNDk3VmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0ZpeHNTdGFuZGFyZEZUXzB4YjljZDkzZDNiYjMxYjQ5N0ZJWF9SZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0ZpeHNTdGFuZGFyZEZUXzB4YjljZDkzZDNiYjMxYjQ5N0ZJWF9CYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fZDMzNzhiNDE5ZmVhZTRlM2E0YmI0ZjMzNDlkYmE0M2ExYjUxMTc2MDB4MWU0YWEwYjg3ZDEwYjE0MVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl9kMzM3OGI0MTlmZWFlNGUzYTRiYjRmMzM0OWRiYTQzYTFiNTExNzYwUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl9kMzM3OGI0MTlmZWFlNGUzYTRiYjRmMzM0OWRiYTQzYTFiNTExNzYwVmF1bHQpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tFVk1WTUJyaWRnZWRUb2tlbl84MzkwMGM3ZmZlY2UyYTQ3Y2FjODY3Zjg3MjUyY2RmNTJiZDAxN2EyMHgxZTRhYTBiODdkMTBiMTQxVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0VWTVZNQnJpZGdlZFRva2VuXzgzOTAwYzdmZmVjZTJhNDdjYWM4NjdmODcyNTJjZGY1MmJkMDE3YTJSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0VWTVZNQnJpZGdlZFRva2VuXzgzOTAwYzdmZmVjZTJhNDdjYWM4NjdmODcyNTJjZGY1MmJkMDE3YTJWYXVsdCkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0VWTVZNQnJpZGdlZFRva2VuX2YxODE1YmQ1MDM4OWM0Njg0N2YwYmRhODI0ZWM4ZGE5MTQwNDVkMTQweDFlNGFhMGI4N2QxMGIxNDFWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRVZNVk1CcmlkZ2VkVG9rZW5fZjE4MTViZDUwMzg5YzQ2ODQ3ZjBiZGE4MjRlYzhkYTkxNDA0NWQxNFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRVZNVk1CcmlkZ2VkVG9rZW5fZjE4MTViZDUwMzg5YzQ2ODQ3ZjBiZGE4MjRlYzhkYTkxNDA0NWQxNFZhdWx0KQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fMmFhYmVhMjA1OGI1YWMyZDMzOWIxNjNjNmFiNmYyYjZkNTNhYWJlZDB4MWU0YWEwYjg3ZDEwYjE0MVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl8yYWFiZWEyMDU4YjVhYzJkMzM5YjE2M2M2YWI2ZjJiNmQ1M2FhYmVkUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl8yYWFiZWEyMDU4YjVhYzJkMzM5YjE2M2M2YWI2ZjJiNmQ1M2FhYmVkVmF1bHQpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tUU0hPVDB4MDViNjdiYTMxNDAwMGIyZFZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9UU0hPVFRva2VuUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9UU0hPVFRva2VuQmFsYW5jZSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0VWTVZNQnJpZGdlZFRva2VuX2EwMTk3YjIwNDRkMjhiMDhiZTM0ZDk4YjIzYzkzMTIxNThlYTlhMTgweDFlNGFhMGI4N2QxMGIxNDFWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRVZNVk1CcmlkZ2VkVG9rZW5fYTAxOTdiMjA0NGQyOGIwOGJlMzRkOThiMjNjOTMxMjE1OGVhOWExOFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRVZNVk1CcmlkZ2VkVG9rZW5fYTAxOTdiMjA0NGQyOGIwOGJlMzRkOThiMjNjOTMxMjE1OGVhOWExOFZhdWx0KQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fNmE2NGUwMjdlM2Y2YTk0YWNiZGNmMzljZjBjYmI0YmVhZDVmNWVjYjB4MWU0YWEwYjg3ZDEwYjE0MVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl82YTY0ZTAyN2UzZjZhOTRhY2JkY2YzOWNmMGNiYjRiZWFkNWY1ZWNiUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl82YTY0ZTAyN2UzZjZhOTRhY2JkY2YzOWNmMGNiYjRiZWFkNWY1ZWNiVmF1bHQpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tFVk1WTUJyaWRnZWRUb2tlbl83Mjk2ZWJjYTMyNWU4MzVlYjZjMWI2OTA0ODRjZjZmYjRjMzk2ZDJjMHgxZTRhYTBiODdkMTBiMTQxVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0VWTVZNQnJpZGdlZFRva2VuXzcyOTZlYmNhMzI1ZTgzNWViNmMxYjY5MDQ4NGNmNmZiNGMzOTZkMmNSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0VWTVZNQnJpZGdlZFRva2VuXzcyOTZlYmNhMzI1ZTgzNWViNmMxYjY5MDQ4NGNmNmZiNGMzOTZkMmNWYXVsdCkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0VWTVZNQnJpZGdlZFRva2VuXzEwNDQ4NDgxNjMwZmI2ZDIwYjU5N2U1YjNkN2U0MmRjYjEyNDdjOGEweDFlNGFhMGI4N2QxMGIxNDFWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRVZNVk1CcmlkZ2VkVG9rZW5fMTA0NDg0ODE2MzBmYjZkMjBiNTk3ZTViM2Q3ZTQyZGNiMTI0N2M4YVJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRVZNVk1CcmlkZ2VkVG9rZW5fMTA0NDg0ODE2MzBmYjZkMjBiNTk3ZTViM2Q3ZTQyZGNiMTI0N2M4YVZhdWx0KQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fOWI1NjU1MDc4NTg4MTJlOGI1ZmZiZmJkZTliMjAwYTNiYzJlOGY3NjB4MWU0YWEwYjg3ZDEwYjE0MVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl85YjU2NTUwNzg1ODgxMmU4YjVmZmJmYmRlOWIyMDBhM2JjMmU4Zjc2UmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl85YjU2NTUwNzg1ODgxMmU4YjVmZmJmYmRlOWIyMDBhM2JjMmU4Zjc2VmF1bHQpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tFVk1WTUJyaWRnZWRUb2tlbl9lOGI3NDIzYjgwZjlhZjMzNDgwZDM2NTE3MWM3Y2VkYTM1ODZhYTM1MHgxZTRhYTBiODdkMTBiMTQxVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0VWTVZNQnJpZGdlZFRva2VuX2U4Yjc0MjNiODBmOWFmMzM0ODBkMzY1MTcxYzdjZWRhMzU4NmFhMzVSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0VWTVZNQnJpZGdlZFRva2VuX2U4Yjc0MjNiODBmOWFmMzM0ODBkMzY1MTcxYzdjZWRhMzU4NmFhMzVWYXVsdCkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0VWTVZNQnJpZGdlZFRva2VuX2Y0NWNiZTMwYmQ5NTM1OTBjOTkxNzc5OTE0MmVkYjA1YmUzZjI5M2YweDFlNGFhMGI4N2QxMGIxNDFWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRVZNVk1CcmlkZ2VkVG9rZW5fZjQ1Y2JlMzBiZDk1MzU5MGM5OTE3Nzk5MTQyZWRiMDViZTNmMjkzZlJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRVZNVk1CcmlkZ2VkVG9rZW5fZjQ1Y2JlMzBiZDk1MzU5MGM5OTE3Nzk5MTQyZWRiMDViZTNmMjkzZlZhdWx0KQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrSk9TSElOMHg4MmVkMWI5Y2JhNWJiMWIzVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0pPU0hJTjI0S2FyYXRSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0pPU0hJTjI0S2FyYXRCYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrVG9wU2hvdFJld2FyZHNDb21tdW5pdHkweGJiMzlmMGRhZTE1NDcyNTZWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvVG9wU2hvdFJld2FyZHNDb21tdW5pdHlSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL1RvcFNob3RSZXdhcmRzQ29tbXVuaXR5TWV0YWRhdGEpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tBSUlDT1NNUExHMHg4MmVkMWI5Y2JhNWJiMWIzVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0FJSUNPU01QTEdSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0FJSUNPU01QTEdCYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrTUVESTB4ODJlZDFiOWNiYTViYjFiM1ZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9NRURJMjRLYXJhdFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvTUVESTI0S2FyYXRCYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrUkVSRVBPMHg4MmVkMWI5Y2JhNWJiMWIzVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL1JFUkVQT1JlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvUkVSRVBPQmFsYW5jZSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0ZpeGVzRnVuZ2libGVUb2tlbjB4ZjVlMWU3NjlmOGNjNjEyYVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9GaXhzU3RhbmRhcmRGVF8weGY1ZTFlNzY5ZjhjYzYxMmFST0dFUl9SZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0ZpeHNTdGFuZGFyZEZUXzB4ZjVlMWU3NjlmOGNjNjEyYVJPR0VSX0JhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tGaXhlc0Z1bmdpYmxlVG9rZW4weDUwYTU4NzdjYjU0Y2UyZmJWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRml4c1N0YW5kYXJkRlRfMHg1MGE1ODc3Y2I1NGNlMmZiV0FWRV9SZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0ZpeHNTdGFuZGFyZEZUXzB4NTBhNTg3N2NiNTRjZTJmYldBVkVfQmFsYW5jZSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0thcmF0djIweDgyZWQxYjljYmE1YmIxYjNWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMva2FyYXR2MlJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMva2FyYXR2MkJhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tTb3JhY2hpMHg4MmVkMWI5Y2JhNWJiMWIzVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL3NvcmFjaGlSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL3NvcmFjaGlCYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRml4ZXNGdW5naWJsZVRva2VuMHg3NjM5OTFiMTExOGMyMGU3VmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0ZpeHNTdGFuZGFyZEZUXzB4NzYzOTkxYjExMThjMjBlN1NGRl9SZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0ZpeHNTdGFuZGFyZEZUXzB4NzYzOTkxYjExMThjMjBlN1NGRl9CYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRml4ZXNGdW5naWJsZVRva2VuMHgxNDM3ZDM0MDU2ZjZhNDlkVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0ZpeHNTdGFuZGFyZEZUXzB4MTQzN2QzNDA1NmY2YTQ5ZFRJVF9SZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0ZpeHNTdGFuZGFyZEZUXzB4MTQzN2QzNDA1NmY2YTQ5ZFRJVF9CYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRml4ZXNGdW5naWJsZVRva2VuMHgwMTY5YWYzMDc4ZDRlZmZmVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0ZpeHNTdGFuZGFyZEZUXzB4MDE2OWFmMzA3OGQ0ZWZmZlJORF9SZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0ZpeHNTdGFuZGFyZEZUXzB4MDE2OWFmMzA3OGQ0ZWZmZlJORF9CYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRml4ZXNGdW5naWJsZVRva2VuMHgyZmMwZDA4MDYxOGVlNDE5VmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0ZpeHNTdGFuZGFyZEZUXzB4MmZjMGQwODA2MThlZTQxOVJVR19SZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0ZpeHNTdGFuZGFyZEZUXzB4MmZjMGQwODA2MThlZTQxOVJVR19CYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrVFMweDgyZWQxYjljYmE1YmIxYjNWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvVFNSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL1RTQmFsYW5jZSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja1RpdFRva2VuMHg2NmI2MDY0MzI0NGE3NzM4VmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL1RpdFRva2VuUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9UaXRUb2tlbkJhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tLQVJBVE5WTUZEMHg4MmVkMWI5Y2JhNWJiMWIzVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0tBUkFUTlZNRkRSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0tBUkFUTlZNRkRCYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRml4ZXNGdW5naWJsZVRva2VuMHhlZjQxNjIyNzljM2RhYmFmVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0ZpeHNTdGFuZGFyZEZUXzB4ZWY0MTYyMjc5YzNkYWJhZlRCSF9SZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0ZpeHNTdGFuZGFyZEZUXzB4ZWY0MTYyMjc5YzNkYWJhZlRCSF9CYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrV2VuUGFja3NEaWdpdGFsZVRva2VuMHg5M2QzMWM2MzE0OWQ1YTY3VmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL1dlblBhY2tzRGlnaXRhbGVUb2tlblJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvV2VuUGFja3NEaWdpdGFsZVRva2VuTWV0YWRhdGEpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tGaXhlc0Z1bmdpYmxlVG9rZW4weDBhZDIxMmY4OWY2M2FkZWRWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRml4c1N0YW5kYXJkRlRfMHgwYWQyMTJmODlmNjNhZGVkRkZSX1JlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRml4c1N0YW5kYXJkRlRfMHgwYWQyMTJmODlmNjNhZGVkRkZSX0JhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tLYXJhdDB4ODJlZDFiOWNiYTViYjFiM1ZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9rYXJhdFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMva2FyYXRCYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRm9vNVRva2VuMHg2YmFmZDdhZGZjNzQ5YmNmVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL2ZvbzVUb2tlblZhdWx0KQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvZm9vNVRva2VuTWV0YWRhdGEpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tEV0xDMHg4MmVkMWI5Y2JhNWJiMWIzVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0RXTENSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0RXTENCYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrTUlHVTB4ODJlZDFiOWNiYTViYjFiM1ZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9NSUdVUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9NSUdVQmFsYW5jZSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja05XYXlVdGlsaXR5Q29pbjB4MDExYjZmMTQyNTM4OTU1MFZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9OV2F5VXRpbGl0eUNvaW5SZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL05XYXlVdGlsaXR5Q29pbkJhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tGbG93U3dhcFBhaXIweGM2Yzc3YjlmNWM3YTM3OGZWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvZmxvd1VzZHRGc3BMcFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvZmxvd1VzZHRGc3BMcEJhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tTdGFybHlVc2R0U3dhcFBhaXIweDZlZmFiNjZkZjkyYzM3ZTRWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvU3Rhcmx5VXNkdFN3YXBMcFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvU3Rhcmx5VXNkdFN3YXBMcEJhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tLQVJBVFpIU0pSMjB4ODJlZDFiOWNiYTViYjFiM1ZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9LQVJBVFpIU0pSMlJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvS0FSQVRaSFNKUjJCYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fMmY2ZjA3Y2RjZjM1ODg5NDRiZjRjNDJhYzc0ZmYyNGJmNTZlNzU5MDB4MWU0YWEwYjg3ZDEwYjE0MVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl8yZjZmMDdjZGNmMzU4ODk0NGJmNGM0MmFjNzRmZjI0YmY1NmU3NTkwUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl8yZjZmMDdjZGNmMzU4ODk0NGJmNGM0MmFjNzRmZjI0YmY1NmU3NTkwVmF1bHQpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tLQVJBVFoyTlBGVjQweDgyZWQxYjljYmE1YmIxYjNWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvS0FSQVRaMk5QRlY0UmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9LQVJBVFoyTlBGVjRCYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrTUFSSzB4ODJlZDFiOWNiYTViYjFiM1ZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9NQVJLMjRLYXJhdFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvTUFSSzI0S2FyYXRCYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRFVOSzB4ODJlZDFiOWNiYTViYjFiM1ZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9EVU5LUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9EVU5LQmFsYW5jZSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0VWTVZNQnJpZGdlZFRva2VuXzY3NDg0M2MwNmZmODM1MDJkZGI0ZDM3YzJlMDljMDFjZGEzOGNiYzgweDFlNGFhMGI4N2QxMGIxNDFWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRVZNVk1CcmlkZ2VkVG9rZW5fNjc0ODQzYzA2ZmY4MzUwMmRkYjRkMzdjMmUwOWMwMWNkYTM4Y2JjOFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRVZNVk1CcmlkZ2VkVG9rZW5fNjc0ODQzYzA2ZmY4MzUwMmRkYjRkMzdjMmUwOWMwMWNkYTM4Y2JjOFZhdWx0KQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fMDBmNGNlNDAwMTMwYzkzODMxMTVmMzg1OGY5Y2E1NDY3NzQyNjU4MzB4MWU0YWEwYjg3ZDEwYjE0MVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl8wMGY0Y2U0MDAxMzBjOTM4MzExNWYzODU4ZjljYTU0Njc3NDI2NTgzUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl8wMGY0Y2U0MDAxMzBjOTM4MzExNWYzODU4ZjljYTU0Njc3NDI2NTgzVmF1bHQpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tLQVJBVFpLR0dNTDB4ODJlZDFiOWNiYTViYjFiM1ZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9LQVJBVFpLR0dNTFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvS0FSQVRaS0dHTUxCYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fMWZlYjMyZjk2NmRjYzRhMTkyZWVjZDg5MTg2NTc4ODQzMTlmODBjMzB4MWU0YWEwYjg3ZDEwYjE0MVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl8xZmViMzJmOTY2ZGNjNGExOTJlZWNkODkxODY1Nzg4NDMxOWY4MGMzUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl8xZmViMzJmOTY2ZGNjNGExOTJlZWNkODkxODY1Nzg4NDMxOWY4MGMzVmF1bHQpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tGb29Ub2tlbjB4M2VlYmUxY2I0YTExMjZiMlZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9mb29Ub2tlblZhdWx0KQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvZm9vVG9rZW5WYXVsdCkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0RBT1RFU1QweDNlZWJlMWNiNGExMTI2YjJWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvREFPVEVTVFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvREFPVEVTVE1ldGFkYXRhKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrQUNDT19TT0xFSUwweDgyZWQxYjljYmE1YmIxYjNWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvQUNDT19TT0xFSUwyNEthcmF0UmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9BQ0NPX1NPTEVJTDI0S2FyYXRCYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrTXlGaXJzdFRva2VuMHg2MTkzYjExNzIxNDI2ODVmVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL015Rmlyc3RUb2tlblJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvTXlGaXJzdFRva2VuTWV0YWRhdGEpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tLQVJBVDE4UkxPTTB4ODJlZDFiOWNiYTViYjFiM1ZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9LQVJBVDE4UkxPTVJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvS0FSQVQxOFJMT01CYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrTU9FVDB4NmIwMGZmODc2YzI5OWM2MVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9tb2V0VG9rZW5SZWNlaXZlcl8weDZiMDBmZjg3NmMyOTljNjEpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9tb2V0VG9rZW5WYXVsdF8weDZiMDBmZjg3NmMyOTljNjEpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tCYWl0Q29pbjB4ZWQyMjAyZGU4MDE5NTQzOFZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9iYWl0Q29pblJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvYmFpdENvaW5WYXVsdCkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0tBUkFUWklDTVEzMHg4MmVkMWI5Y2JhNWJiMWIzVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0tBUkFUWklDTVEzUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9LQVJBVFpJQ01RM0JhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tKUFkyNDB4MjE1ZjNhYzc2Y2I0OTY1NlZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9qcHkyNFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvanB5MjRCYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrUE9JTlQyNDB4MjE1ZjNhYzc2Y2I0OTY1NlZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9wb2ludDI0UmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9wb2ludDI0QmFsYW5jZSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0JsdFVzZHRTd2FwUGFpcjB4ZmNiMDZhNWFlNWIyMWEyZFZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9ibHRVc2R0RnNwTHBSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL2JsdFVzZHRGc3BMcEJhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tLQVJBVFoxRFlJVkUweDgyZWQxYjljYmE1YmIxYjNWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvS0FSQVRaMURZSVZFUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9LQVJBVFoxRFlJVkVCYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fNzE3ZGFlMmJhZjc2NTZiZTlhOWIwMWRlZTMxZDU3MWE5ZDRjOTU3OTB4MWU0YWEwYjg3ZDEwYjE0MVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl83MTdkYWUyYmFmNzY1NmJlOWE5YjAxZGVlMzFkNTcxYTlkNGM5NTc5UmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl83MTdkYWUyYmFmNzY1NmJlOWE5YjAxZGVlMzFkNTcxYTlkNGM5NTc5VmF1bHQpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tSZXZ2Rmxvd1N3YXBQYWlyMHg1ZTI4NGZiN2NmZjIzYTNmVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL3JldnZGbG93U3dhcExwUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9yZXZ2Rmxvd1N3YXBMcEJhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tFVk1WTUJyaWRnZWRUb2tlbl9jNTJlODIwZDJkNjIwN2QxODY2N2E5N2UyYzZhYzIyZWIyNmU4MDNjMHgxZTRhYTBiODdkMTBiMTQxVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0VWTVZNQnJpZGdlZFRva2VuX2M1MmU4MjBkMmQ2MjA3ZDE4NjY3YTk3ZTJjNmFjMjJlYjI2ZTgwM2NSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0VWTVZNQnJpZGdlZFRva2VuX2M1MmU4MjBkMmQ2MjA3ZDE4NjY3YTk3ZTJjNmFjMjJlYjI2ZTgwM2NWYXVsdCkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0VWTVZNQnJpZGdlZFRva2VuXzk5YWYzZWVhODU2NTU2NjQ2Yzk4YzhiOWIyNTQ4ZmU4MTUyNDA3NTAweDFlNGFhMGI4N2QxMGIxNDFWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRVZNVk1CcmlkZ2VkVG9rZW5fOTlhZjNlZWE4NTY1NTY2NDZjOThjOGI5YjI1NDhmZTgxNTI0MDc1MFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRVZNVk1CcmlkZ2VkVG9rZW5fOTlhZjNlZWE4NTY1NTY2NDZjOThjOGI5YjI1NDhmZTgxNTI0MDc1MFZhdWx0KQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fY2JmOWE3NzUzZjlkMmQwZTgxNDFlYmIzNmQ5OWY4N2FjZWY5ODU5NzB4MWU0YWEwYjg3ZDEwYjE0MVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl9jYmY5YTc3NTNmOWQyZDBlODE0MWViYjM2ZDk5Zjg3YWNlZjk4NTk3UmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl9jYmY5YTc3NTNmOWQyZDBlODE0MWViYjM2ZDk5Zjg3YWNlZjk4NTk3VmF1bHQpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tFVk1WTUJyaWRnZWRUb2tlbl9kMDY5ZDk4OWUyZjQ0YjcwYzY1MzQ3ZDE4NTNjMGM2N2UxMGE5ZjhkMHgxZTRhYTBiODdkMTBiMTQxVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0VWTVZNQnJpZGdlZFRva2VuX2QwNjlkOTg5ZTJmNDRiNzBjNjUzNDdkMTg1M2MwYzY3ZTEwYTlmOGRSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0VWTVZNQnJpZGdlZFRva2VuX2QwNjlkOTg5ZTJmNDRiNzBjNjUzNDdkMTg1M2MwYzY3ZTEwYTlmOGRWYXVsdCkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0ZpeGVzRnVuZ2libGVUb2tlbjB4ODQ1MDljMmEyOGMwZGU0MVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9GaXhzU3RhbmRhcmRGVF8weDg0NTA5YzJhMjhjMGRlNDFSREJfUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9GaXhzU3RhbmRhcmRGVF8weDg0NTA5YzJhMjhjMGRlNDFSREJfQmFsYW5jZSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgCiAgICBhY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzKSA6IHtTdHJpbmc6IEJvb2x9IHsKICAgICAgcmV0dXJuIHsKICAgICJBLjE2NTQ2NTMzOTkwNDBhNjEuRmxvd1Rva2VuIiA6CiAgICBjaGVja0Zsb3dUb2tlbjB4MTY1NDY1MzM5OTA0MGE2MVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS5lNDUyYTJmNTY2NTcyOGY1LkFEVVRva2VuIiA6CiAgICBjaGVja0FEVVRva2VuMHhlNDUyYTJmNTY2NTcyOGY1VmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjlkYjk0Yzk1NjQyNDNiYTcuYWlTcG9ydHNKdWljZSIgOgogICAgY2hlY2thaVNwb3J0c0p1aWNlMHg5ZGI5NGM5NTY0MjQzYmE3VmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjRlYTA0N2MzZTczY2E0NjAuQmFsbGVyekZDIiA6CiAgICBjaGVja0JhbGxlcnpGQzB4NGVhMDQ3YzNlNzNjYTQ2MFZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS42ODdlMWE3YWVmMTdiNzhiLkJlYXZlciIgOgogICAgY2hlY2tCZWF2ZXIweDY4N2UxYTdhZWYxN2I3OGJWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuMGY5ZGY5MWM5MTIxYzQ2MC5CbG9jdG9Ub2tlbiIgOgogICAgY2hlY2tCbG9jdG9Ub2tlbjB4MGY5ZGY5MWM5MTIxYzQ2MFZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS43YmYwN2Q3MTlkY2I4NDgwLmJyYXNpbCIgOgogICAgY2hlY2ticmFzaWwweDdiZjA3ZDcxOWRjYjg0ODBWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuMjMxY2MwZGJiY2ZmYzRiNy5jZUFWQVgiIDoKICAgIGNoZWNrY2VBVkFYMHgyMzFjYzBkYmJjZmZjNGI3VmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjIzMWNjMGRiYmNmZmM0YjcuY2VCTkIiIDoKICAgIGNoZWNrY2VCTkIweDIzMWNjMGRiYmNmZmM0YjdWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuMjMxY2MwZGJiY2ZmYzRiNy5jZUJVU0QiIDoKICAgIGNoZWNrY2VCVVNEMHgyMzFjYzBkYmJjZmZjNGI3VmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjIzMWNjMGRiYmNmZmM0YjcuY2VEQUkiIDoKICAgIGNoZWNrY2VEQUkweDIzMWNjMGRiYmNmZmM0YjdWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuMjMxY2MwZGJiY2ZmYzRiNy5jZUZUTSIgOgogICAgY2hlY2tjZUZUTTB4MjMxY2MwZGJiY2ZmYzRiN1ZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS4yMzFjYzBkYmJjZmZjNGI3LmNlTUFUSUMiIDoKICAgIGNoZWNrY2VNQVRJQzB4MjMxY2MwZGJiY2ZmYzRiN1ZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS4yMzFjYzBkYmJjZmZjNGI3LmNlVVNEVCIgOgogICAgY2hlY2tjZVVTRFQweDIzMWNjMGRiYmNmZmM0YjdWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuMjMxY2MwZGJiY2ZmYzRiNy5jZVdCVEMiIDoKICAgIGNoZWNrY2VXQlRDMHgyMzFjYzBkYmJjZmZjNGI3VmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjIzMWNjMGRiYmNmZmM0YjcuY2VXRVRIIiA6CiAgICBjaGVja2NlV0VUSDB4MjMxY2MwZGJiY2ZmYzRiN1ZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS4zMzk5ZDdjNmM2MDliN2U1LkRBTU80MjAiIDoKICAgIGNoZWNrREFNTzQyMDB4MzM5OWQ3YzZjNjA5YjdlNVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS45MjFlYTQ0OWRmZmVjNjhhLkZsb3ZhdGFyRHVzdFRva2VuIiA6CiAgICBjaGVja0Zsb3ZhdGFyRHVzdFRva2VuMHg5MjFlYTQ0OWRmZmVjNjhhVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLmQzYjYyZmZiYmM2MzJmNWEuRmxvd0Jsb2NrY2hhaW5oaXRDb2luIiA6CiAgICBjaGVja0Zsb3dCbG9ja2NoYWluaGl0Q29pbjB4ZDNiNjJmZmJiYzYzMmY1YVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS4zYzU5NTliNTY4ODk2MzkzLkZVU0QiIDoKICAgIGNoZWNrRlVTRDB4M2M1OTU5YjU2ODg5NjM5M1ZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS5mZDFjY2FhYWUzOWQwZTc5Lk1haW5sZWRnZXIiIDoKICAgIGNoZWNrTWFpbmxlZGdlcjB4ZmQxY2NhYWFlMzlkMGU3OVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS42ZmQyNDY1ZjNhMjJlMzRjLlBldEpva2ljc0hvcnNlcyIgOgogICAgY2hlY2tQZXRKb2tpY3NIb3JzZXMweDZmZDI0NjVmM2EyMmUzNGNWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuZmQxY2NhYWFlMzlkMGU3OS5Qb2tlcnRpbWUiIDoKICAgIGNoZWNrUG9rZXJ0aW1lMHhmZDFjY2FhYWUzOWQwZTc5VmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLmQwMWU0ODJlYjY4MGVjOWYuUkVWViIgOgogICAgY2hlY2tSRVZWMHhkMDFlNDgyZWI2ODBlYzlmVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjIzMWNjMGRiYmNmZmM0YjcuUkxZIiA6CiAgICBjaGVja1JMWTB4MjMxY2MwZGJiY2ZmYzRiN1ZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS41M2YzODlkOTZmYjRjZTVlLlNsb3BweVN0YWtlcyIgOgogICAgY2hlY2tTbG9wcHlTdGFrZXMweDUzZjM4OWQ5NmZiNGNlNWVWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuMTQyZmE2NTcwYjYyZmQ5Ny5TdGFybHlUb2tlbiIgOgogICAgY2hlY2tTdGFybHlUb2tlbjB4MTQyZmE2NTcwYjYyZmQ5N1ZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS5kNmY4MDU2NTE5M2FkNzI3LnN0Rmxvd1Rva2VuIiA6CiAgICBjaGVja3N0Rmxvd1Rva2VuMHhkNmY4MDU2NTE5M2FkNzI3VmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLmNmZGQ5MGQ0YTAwZjdiNWIuVGVsZXBvcnRlZFRldGhlclRva2VuIiA6CiAgICBjaGVja1RlbGVwb3J0ZWRUZXRoZXJUb2tlbjB4Y2ZkZDkwZDRhMDBmN2I1YlZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS44MjU5YzczZTQ4NzQyMmQ3LlRoZVdvbGZvZkZsb3ciIDoKICAgIGNoZWNrVGhlV29sZm9mRmxvdzB4ODI1OWM3M2U0ODc0MjJkN1ZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS5lZTA5MDI5ZjFkYmNkOWQxLlRvcFNob3RCRVRBIiA6CiAgICBjaGVja1RvcFNob3RCRVRBMHhlZTA5MDI5ZjFkYmNkOWQxVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLmNiYmE0ZDQxYWVmODNmZTMuVXRhaEphenpMZWdlbmRzQ2x1YiIgOgogICAgY2hlY2tVdGFoSmF6ekxlZ2VuZHNDbHViMHhjYmJhNGQ0MWFlZjgzZmUzVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjY3ZGFhZDkxZTM3ODJjODAuVmFtcGlyZSIgOgogICAgY2hlY2tWYW1waXJlMHg2N2RhYWQ5MWUzNzgyYzgwVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLmY4ODdlY2UzOTE2NjkwNmUuVnJvb21Ub2tlbiIgOgogICAgY2hlY2tWcm9vbVRva2VuMHhmODg3ZWNlMzkxNjY5MDZlVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLmVhZDg5MjA4M2IzZTJjNmMuRGFwcGVyVXRpbGl0eUNvaW4iIDoKICAgIGNoZWNrRGFwcGVyVXRpbGl0eUNvaW4weGVhZDg5MjA4M2IzZTJjNmNWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuZjFhYjk5YzgyZGVlMzUyNi5VU0RDRmxvdyIgOgogICAgY2hlY2tVU0RDRmxvdzB4ZjFhYjk5YzgyZGVlMzUyNlZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS4xZTRhYTBiODdkMTBiMTQxLkVWTVZNQnJpZGdlZFRva2VuXzFiOTcxMDBlYTFkNzEyNmM0ZDYwMDI3ZTIzMWVhNGNiMjUzMTRiZGIiIDoKICAgIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fMWI5NzEwMGVhMWQ3MTI2YzRkNjAwMjdlMjMxZWE0Y2IyNTMxNGJkYjB4MWU0YWEwYjg3ZDEwYjE0MVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS4xZTRhYTBiODdkMTBiMTQxLkVWTVZNQnJpZGdlZFRva2VuX2Q4YWQ4YWU4Mzc1YWEzMWJmZjU0MWUxN2RjNGI0OTE3MDE0ZWJkYWEiIDoKICAgIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fZDhhZDhhZTgzNzVhYTMxYmZmNTQxZTE3ZGM0YjQ5MTcwMTRlYmRhYTB4MWU0YWEwYjg3ZDEwYjE0MVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS4xZTRhYTBiODdkMTBiMTQxLkVWTVZNQnJpZGdlZFRva2VuXzk5NTI1OGNlYTQ5YzI1NTk1Y2Q5NDQwN2ZhZDllOTliODE0MDZhODQiIDoKICAgIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fOTk1MjU4Y2VhNDljMjU1OTVjZDk0NDA3ZmFkOWU5OWI4MTQwNmE4NDB4MWU0YWEwYjg3ZDEwYjE0MVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS4xZTRhYTBiODdkMTBiMTQxLkVWTVZNQnJpZGdlZFRva2VuX2I3M2JmOGU2YTQ0NzdhOTUyZTAzMzhlNmNjMDBjYzBjZTVhZDA0YmEiIDoKICAgIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fYjczYmY4ZTZhNDQ3N2E5NTJlMDMzOGU2Y2MwMGNjMGNlNWFkMDRiYTB4MWU0YWEwYjg3ZDEwYjE0MVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS4xZTRhYTBiODdkMTBiMTQxLkVWTVZNQnJpZGdlZFRva2VuXzZhMmNkMTQxZDc1ODY0OTQ0MzE4YWNmMjcyNDQzZmViYzU0ODU1YTkiIDoKICAgIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fNmEyY2QxNDFkNzU4NjQ5NDQzMThhY2YyNzI0NDNmZWJjNTQ4NTVhOTB4MWU0YWEwYjg3ZDEwYjE0MVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS4xZTRhYTBiODdkMTBiMTQxLkVWTVZNQnJpZGdlZFRva2VuXzY4ZWI2ODNhMzkzYzhhMWM4MTYyNTViNGZjNGI4OWQ3M2M1MmFkNGIiIDoKICAgIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fNjhlYjY4M2EzOTNjOGExYzgxNjI1NWI0ZmM0Yjg5ZDczYzUyYWQ0YjB4MWU0YWEwYjg3ZDEwYjE0MVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS5iOWNkOTNkM2JiMzFiNDk3LkZpeGVzRnVuZ2libGVUb2tlbiIgOgogICAgY2hlY2tGaXhlc0Z1bmdpYmxlVG9rZW4weGI5Y2Q5M2QzYmIzMWI0OTdWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuMWU0YWEwYjg3ZDEwYjE0MS5FVk1WTUJyaWRnZWRUb2tlbl9kMzM3OGI0MTlmZWFlNGUzYTRiYjRmMzM0OWRiYTQzYTFiNTExNzYwIiA6CiAgICBjaGVja0VWTVZNQnJpZGdlZFRva2VuX2QzMzc4YjQxOWZlYWU0ZTNhNGJiNGYzMzQ5ZGJhNDNhMWI1MTE3NjAweDFlNGFhMGI4N2QxMGIxNDFWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuMWU0YWEwYjg3ZDEwYjE0MS5FVk1WTUJyaWRnZWRUb2tlbl84MzkwMGM3ZmZlY2UyYTQ3Y2FjODY3Zjg3MjUyY2RmNTJiZDAxN2EyIiA6CiAgICBjaGVja0VWTVZNQnJpZGdlZFRva2VuXzgzOTAwYzdmZmVjZTJhNDdjYWM4NjdmODcyNTJjZGY1MmJkMDE3YTIweDFlNGFhMGI4N2QxMGIxNDFWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuMWU0YWEwYjg3ZDEwYjE0MS5FVk1WTUJyaWRnZWRUb2tlbl9mMTgxNWJkNTAzODljNDY4NDdmMGJkYTgyNGVjOGRhOTE0MDQ1ZDE0IiA6CiAgICBjaGVja0VWTVZNQnJpZGdlZFRva2VuX2YxODE1YmQ1MDM4OWM0Njg0N2YwYmRhODI0ZWM4ZGE5MTQwNDVkMTQweDFlNGFhMGI4N2QxMGIxNDFWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuMWU0YWEwYjg3ZDEwYjE0MS5FVk1WTUJyaWRnZWRUb2tlbl8yYWFiZWEyMDU4YjVhYzJkMzM5YjE2M2M2YWI2ZjJiNmQ1M2FhYmVkIiA6CiAgICBjaGVja0VWTVZNQnJpZGdlZFRva2VuXzJhYWJlYTIwNThiNWFjMmQzMzliMTYzYzZhYjZmMmI2ZDUzYWFiZWQweDFlNGFhMGI4N2QxMGIxNDFWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuMDViNjdiYTMxNDAwMGIyZC5UU0hPVCIgOgogICAgY2hlY2tUU0hPVDB4MDViNjdiYTMxNDAwMGIyZFZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS4xZTRhYTBiODdkMTBiMTQxLkVWTVZNQnJpZGdlZFRva2VuX2EwMTk3YjIwNDRkMjhiMDhiZTM0ZDk4YjIzYzkzMTIxNThlYTlhMTgiIDoKICAgIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fYTAxOTdiMjA0NGQyOGIwOGJlMzRkOThiMjNjOTMxMjE1OGVhOWExODB4MWU0YWEwYjg3ZDEwYjE0MVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS4xZTRhYTBiODdkMTBiMTQxLkVWTVZNQnJpZGdlZFRva2VuXzZhNjRlMDI3ZTNmNmE5NGFjYmRjZjM5Y2YwY2JiNGJlYWQ1ZjVlY2IiIDoKICAgIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fNmE2NGUwMjdlM2Y2YTk0YWNiZGNmMzljZjBjYmI0YmVhZDVmNWVjYjB4MWU0YWEwYjg3ZDEwYjE0MVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS4xZTRhYTBiODdkMTBiMTQxLkVWTVZNQnJpZGdlZFRva2VuXzcyOTZlYmNhMzI1ZTgzNWViNmMxYjY5MDQ4NGNmNmZiNGMzOTZkMmMiIDoKICAgIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fNzI5NmViY2EzMjVlODM1ZWI2YzFiNjkwNDg0Y2Y2ZmI0YzM5NmQyYzB4MWU0YWEwYjg3ZDEwYjE0MVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS4xZTRhYTBiODdkMTBiMTQxLkVWTVZNQnJpZGdlZFRva2VuXzEwNDQ4NDgxNjMwZmI2ZDIwYjU5N2U1YjNkN2U0MmRjYjEyNDdjOGEiIDoKICAgIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fMTA0NDg0ODE2MzBmYjZkMjBiNTk3ZTViM2Q3ZTQyZGNiMTI0N2M4YTB4MWU0YWEwYjg3ZDEwYjE0MVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS4xZTRhYTBiODdkMTBiMTQxLkVWTVZNQnJpZGdlZFRva2VuXzliNTY1NTA3ODU4ODEyZThiNWZmYmZiZGU5YjIwMGEzYmMyZThmNzYiIDoKICAgIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fOWI1NjU1MDc4NTg4MTJlOGI1ZmZiZmJkZTliMjAwYTNiYzJlOGY3NjB4MWU0YWEwYjg3ZDEwYjE0MVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS4xZTRhYTBiODdkMTBiMTQxLkVWTVZNQnJpZGdlZFRva2VuX2U4Yjc0MjNiODBmOWFmMzM0ODBkMzY1MTcxYzdjZWRhMzU4NmFhMzUiIDoKICAgIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fZThiNzQyM2I4MGY5YWYzMzQ4MGQzNjUxNzFjN2NlZGEzNTg2YWEzNTB4MWU0YWEwYjg3ZDEwYjE0MVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS4xZTRhYTBiODdkMTBiMTQxLkVWTVZNQnJpZGdlZFRva2VuX2Y0NWNiZTMwYmQ5NTM1OTBjOTkxNzc5OTE0MmVkYjA1YmUzZjI5M2YiIDoKICAgIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fZjQ1Y2JlMzBiZDk1MzU5MGM5OTE3Nzk5MTQyZWRiMDViZTNmMjkzZjB4MWU0YWEwYjg3ZDEwYjE0MVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS44MmVkMWI5Y2JhNWJiMWIzLkpPU0hJTiIgOgogICAgY2hlY2tKT1NISU4weDgyZWQxYjljYmE1YmIxYjNWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuYmIzOWYwZGFlMTU0NzI1Ni5Ub3BTaG90UmV3YXJkc0NvbW11bml0eSIgOgogICAgY2hlY2tUb3BTaG90UmV3YXJkc0NvbW11bml0eTB4YmIzOWYwZGFlMTU0NzI1NlZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS44MmVkMWI5Y2JhNWJiMWIzLkFJSUNPU01QTEciIDoKICAgIGNoZWNrQUlJQ09TTVBMRzB4ODJlZDFiOWNiYTViYjFiM1ZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS44MmVkMWI5Y2JhNWJiMWIzLk1FREkiIDoKICAgIGNoZWNrTUVESTB4ODJlZDFiOWNiYTViYjFiM1ZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS44MmVkMWI5Y2JhNWJiMWIzLlJFUkVQTyIgOgogICAgY2hlY2tSRVJFUE8weDgyZWQxYjljYmE1YmIxYjNWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuZjVlMWU3NjlmOGNjNjEyYS5GaXhlc0Z1bmdpYmxlVG9rZW4iIDoKICAgIGNoZWNrRml4ZXNGdW5naWJsZVRva2VuMHhmNWUxZTc2OWY4Y2M2MTJhVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjUwYTU4NzdjYjU0Y2UyZmIuRml4ZXNGdW5naWJsZVRva2VuIiA6CiAgICBjaGVja0ZpeGVzRnVuZ2libGVUb2tlbjB4NTBhNTg3N2NiNTRjZTJmYlZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS44MmVkMWI5Y2JhNWJiMWIzLkthcmF0djIiIDoKICAgIGNoZWNrS2FyYXR2MjB4ODJlZDFiOWNiYTViYjFiM1ZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS44MmVkMWI5Y2JhNWJiMWIzLlNvcmFjaGkiIDoKICAgIGNoZWNrU29yYWNoaTB4ODJlZDFiOWNiYTViYjFiM1ZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS43NjM5OTFiMTExOGMyMGU3LkZpeGVzRnVuZ2libGVUb2tlbiIgOgogICAgY2hlY2tGaXhlc0Z1bmdpYmxlVG9rZW4weDc2Mzk5MWIxMTE4YzIwZTdWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuMTQzN2QzNDA1NmY2YTQ5ZC5GaXhlc0Z1bmdpYmxlVG9rZW4iIDoKICAgIGNoZWNrRml4ZXNGdW5naWJsZVRva2VuMHgxNDM3ZDM0MDU2ZjZhNDlkVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjAxNjlhZjMwNzhkNGVmZmYuRml4ZXNGdW5naWJsZVRva2VuIiA6CiAgICBjaGVja0ZpeGVzRnVuZ2libGVUb2tlbjB4MDE2OWFmMzA3OGQ0ZWZmZlZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS4yZmMwZDA4MDYxOGVlNDE5LkZpeGVzRnVuZ2libGVUb2tlbiIgOgogICAgY2hlY2tGaXhlc0Z1bmdpYmxlVG9rZW4weDJmYzBkMDgwNjE4ZWU0MTlWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuODJlZDFiOWNiYTViYjFiMy5UUyIgOgogICAgY2hlY2tUUzB4ODJlZDFiOWNiYTViYjFiM1ZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS42NmI2MDY0MzI0NGE3NzM4LlRpdFRva2VuIiA6CiAgICBjaGVja1RpdFRva2VuMHg2NmI2MDY0MzI0NGE3NzM4VmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjgyZWQxYjljYmE1YmIxYjMuS0FSQVROVk1GRCIgOgogICAgY2hlY2tLQVJBVE5WTUZEMHg4MmVkMWI5Y2JhNWJiMWIzVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLmVmNDE2MjI3OWMzZGFiYWYuRml4ZXNGdW5naWJsZVRva2VuIiA6CiAgICBjaGVja0ZpeGVzRnVuZ2libGVUb2tlbjB4ZWY0MTYyMjc5YzNkYWJhZlZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS45M2QzMWM2MzE0OWQ1YTY3LldlblBhY2tzRGlnaXRhbGVUb2tlbiIgOgogICAgY2hlY2tXZW5QYWNrc0RpZ2l0YWxlVG9rZW4weDkzZDMxYzYzMTQ5ZDVhNjdWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuMGFkMjEyZjg5ZjYzYWRlZC5GaXhlc0Z1bmdpYmxlVG9rZW4iIDoKICAgIGNoZWNrRml4ZXNGdW5naWJsZVRva2VuMHgwYWQyMTJmODlmNjNhZGVkVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjgyZWQxYjljYmE1YmIxYjMuS2FyYXQiIDoKICAgIGNoZWNrS2FyYXQweDgyZWQxYjljYmE1YmIxYjNWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuNmJhZmQ3YWRmYzc0OWJjZi5Gb281VG9rZW4iIDoKICAgIGNoZWNrRm9vNVRva2VuMHg2YmFmZDdhZGZjNzQ5YmNmVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjgyZWQxYjljYmE1YmIxYjMuRFdMQyIgOgogICAgY2hlY2tEV0xDMHg4MmVkMWI5Y2JhNWJiMWIzVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjgyZWQxYjljYmE1YmIxYjMuTUlHVSIgOgogICAgY2hlY2tNSUdVMHg4MmVkMWI5Y2JhNWJiMWIzVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjAxMWI2ZjE0MjUzODk1NTAuTldheVV0aWxpdHlDb2luIiA6CiAgICBjaGVja05XYXlVdGlsaXR5Q29pbjB4MDExYjZmMTQyNTM4OTU1MFZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS5jNmM3N2I5ZjVjN2EzNzhmLkZsb3dTd2FwUGFpciIgOgogICAgY2hlY2tGbG93U3dhcFBhaXIweGM2Yzc3YjlmNWM3YTM3OGZWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuNmVmYWI2NmRmOTJjMzdlNC5TdGFybHlVc2R0U3dhcFBhaXIiIDoKICAgIGNoZWNrU3Rhcmx5VXNkdFN3YXBQYWlyMHg2ZWZhYjY2ZGY5MmMzN2U0VmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjgyZWQxYjljYmE1YmIxYjMuS0FSQVRaSFNKUjIiIDoKICAgIGNoZWNrS0FSQVRaSFNKUjIweDgyZWQxYjljYmE1YmIxYjNWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuMWU0YWEwYjg3ZDEwYjE0MS5FVk1WTUJyaWRnZWRUb2tlbl8yZjZmMDdjZGNmMzU4ODk0NGJmNGM0MmFjNzRmZjI0YmY1NmU3NTkwIiA6CiAgICBjaGVja0VWTVZNQnJpZGdlZFRva2VuXzJmNmYwN2NkY2YzNTg4OTQ0YmY0YzQyYWM3NGZmMjRiZjU2ZTc1OTAweDFlNGFhMGI4N2QxMGIxNDFWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuODJlZDFiOWNiYTViYjFiMy5LQVJBVFoyTlBGVjQiIDoKICAgIGNoZWNrS0FSQVRaMk5QRlY0MHg4MmVkMWI5Y2JhNWJiMWIzVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjgyZWQxYjljYmE1YmIxYjMuTUFSSyIgOgogICAgY2hlY2tNQVJLMHg4MmVkMWI5Y2JhNWJiMWIzVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjgyZWQxYjljYmE1YmIxYjMuRFVOSyIgOgogICAgY2hlY2tEVU5LMHg4MmVkMWI5Y2JhNWJiMWIzVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjFlNGFhMGI4N2QxMGIxNDEuRVZNVk1CcmlkZ2VkVG9rZW5fNjc0ODQzYzA2ZmY4MzUwMmRkYjRkMzdjMmUwOWMwMWNkYTM4Y2JjOCIgOgogICAgY2hlY2tFVk1WTUJyaWRnZWRUb2tlbl82NzQ4NDNjMDZmZjgzNTAyZGRiNGQzN2MyZTA5YzAxY2RhMzhjYmM4MHgxZTRhYTBiODdkMTBiMTQxVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjFlNGFhMGI4N2QxMGIxNDEuRVZNVk1CcmlkZ2VkVG9rZW5fMDBmNGNlNDAwMTMwYzkzODMxMTVmMzg1OGY5Y2E1NDY3NzQyNjU4MyIgOgogICAgY2hlY2tFVk1WTUJyaWRnZWRUb2tlbl8wMGY0Y2U0MDAxMzBjOTM4MzExNWYzODU4ZjljYTU0Njc3NDI2NTgzMHgxZTRhYTBiODdkMTBiMTQxVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjgyZWQxYjljYmE1YmIxYjMuS0FSQVRaS0dHTUwiIDoKICAgIGNoZWNrS0FSQVRaS0dHTUwweDgyZWQxYjljYmE1YmIxYjNWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuMWU0YWEwYjg3ZDEwYjE0MS5FVk1WTUJyaWRnZWRUb2tlbl8xZmViMzJmOTY2ZGNjNGExOTJlZWNkODkxODY1Nzg4NDMxOWY4MGMzIiA6CiAgICBjaGVja0VWTVZNQnJpZGdlZFRva2VuXzFmZWIzMmY5NjZkY2M0YTE5MmVlY2Q4OTE4NjU3ODg0MzE5ZjgwYzMweDFlNGFhMGI4N2QxMGIxNDFWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuM2VlYmUxY2I0YTExMjZiMi5Gb29Ub2tlbiIgOgogICAgY2hlY2tGb29Ub2tlbjB4M2VlYmUxY2I0YTExMjZiMlZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS4zZWViZTFjYjRhMTEyNmIyLkRBT1RFU1QiIDoKICAgIGNoZWNrREFPVEVTVDB4M2VlYmUxY2I0YTExMjZiMlZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS44MmVkMWI5Y2JhNWJiMWIzLkFDQ09fU09MRUlMIiA6CiAgICBjaGVja0FDQ09fU09MRUlMMHg4MmVkMWI5Y2JhNWJiMWIzVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjYxOTNiMTE3MjE0MjY4NWYuTXlGaXJzdFRva2VuIiA6CiAgICBjaGVja015Rmlyc3RUb2tlbjB4NjE5M2IxMTcyMTQyNjg1ZlZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS44MmVkMWI5Y2JhNWJiMWIzLktBUkFUMThSTE9NIiA6CiAgICBjaGVja0tBUkFUMThSTE9NMHg4MmVkMWI5Y2JhNWJiMWIzVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjZiMDBmZjg3NmMyOTljNjEuTU9FVCIgOgogICAgY2hlY2tNT0VUMHg2YjAwZmY4NzZjMjk5YzYxVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLmVkMjIwMmRlODAxOTU0MzguQmFpdENvaW4iIDoKICAgIGNoZWNrQmFpdENvaW4weGVkMjIwMmRlODAxOTU0MzhWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuODJlZDFiOWNiYTViYjFiMy5LQVJBVFpJQ01RMyIgOgogICAgY2hlY2tLQVJBVFpJQ01RMzB4ODJlZDFiOWNiYTViYjFiM1ZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS4yMTVmM2FjNzZjYjQ5NjU2LkpQWTI0IiA6CiAgICBjaGVja0pQWTI0MHgyMTVmM2FjNzZjYjQ5NjU2VmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjIxNWYzYWM3NmNiNDk2NTYuUE9JTlQyNCIgOgogICAgY2hlY2tQT0lOVDI0MHgyMTVmM2FjNzZjYjQ5NjU2VmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLmZjYjA2YTVhZTViMjFhMmQuQmx0VXNkdFN3YXBQYWlyIiA6CiAgICBjaGVja0JsdFVzZHRTd2FwUGFpcjB4ZmNiMDZhNWFlNWIyMWEyZFZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS44MmVkMWI5Y2JhNWJiMWIzLktBUkFUWjFEWUlWRSIgOgogICAgY2hlY2tLQVJBVFoxRFlJVkUweDgyZWQxYjljYmE1YmIxYjNWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuMWU0YWEwYjg3ZDEwYjE0MS5FVk1WTUJyaWRnZWRUb2tlbl83MTdkYWUyYmFmNzY1NmJlOWE5YjAxZGVlMzFkNTcxYTlkNGM5NTc5IiA6CiAgICBjaGVja0VWTVZNQnJpZGdlZFRva2VuXzcxN2RhZTJiYWY3NjU2YmU5YTliMDFkZWUzMWQ1NzFhOWQ0Yzk1NzkweDFlNGFhMGI4N2QxMGIxNDFWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuNWUyODRmYjdjZmYyM2EzZi5SZXZ2Rmxvd1N3YXBQYWlyIiA6CiAgICBjaGVja1JldnZGbG93U3dhcFBhaXIweDVlMjg0ZmI3Y2ZmMjNhM2ZWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuMWU0YWEwYjg3ZDEwYjE0MS5FVk1WTUJyaWRnZWRUb2tlbl9jNTJlODIwZDJkNjIwN2QxODY2N2E5N2UyYzZhYzIyZWIyNmU4MDNjIiA6CiAgICBjaGVja0VWTVZNQnJpZGdlZFRva2VuX2M1MmU4MjBkMmQ2MjA3ZDE4NjY3YTk3ZTJjNmFjMjJlYjI2ZTgwM2MweDFlNGFhMGI4N2QxMGIxNDFWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuMWU0YWEwYjg3ZDEwYjE0MS5FVk1WTUJyaWRnZWRUb2tlbl85OWFmM2VlYTg1NjU1NjY0NmM5OGM4YjliMjU0OGZlODE1MjQwNzUwIiA6CiAgICBjaGVja0VWTVZNQnJpZGdlZFRva2VuXzk5YWYzZWVhODU2NTU2NjQ2Yzk4YzhiOWIyNTQ4ZmU4MTUyNDA3NTAweDFlNGFhMGI4N2QxMGIxNDFWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuMWU0YWEwYjg3ZDEwYjE0MS5FVk1WTUJyaWRnZWRUb2tlbl9jYmY5YTc3NTNmOWQyZDBlODE0MWViYjM2ZDk5Zjg3YWNlZjk4NTk3IiA6CiAgICBjaGVja0VWTVZNQnJpZGdlZFRva2VuX2NiZjlhNzc1M2Y5ZDJkMGU4MTQxZWJiMzZkOTlmODdhY2VmOTg1OTcweDFlNGFhMGI4N2QxMGIxNDFWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuMWU0YWEwYjg3ZDEwYjE0MS5FVk1WTUJyaWRnZWRUb2tlbl9kMDY5ZDk4OWUyZjQ0YjcwYzY1MzQ3ZDE4NTNjMGM2N2UxMGE5ZjhkIiA6CiAgICBjaGVja0VWTVZNQnJpZGdlZFRva2VuX2QwNjlkOTg5ZTJmNDRiNzBjNjUzNDdkMTg1M2MwYzY3ZTEwYTlmOGQweDFlNGFhMGI4N2QxMGIxNDFWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuODQ1MDljMmEyOGMwZGU0MS5GaXhlc0Z1bmdpYmxlVG9rZW4iIDoKICAgIGNoZWNrRml4ZXNGdW5naWJsZVRva2VuMHg4NDUwOWMyYTI4YzBkZTQxVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgIH0KICAgIH0KICA\u003d", + "isLinkedAccountTokenListEnabled": "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\u003d", + "getTokenListBalance": "
    // Flow Wallet - mainnet Script  getTokenListBalanceStable - v2.78
// <platform_info>


    import FungibleToken from 0xf233dcee88fe0abe


    
    access(all) fun checkFlowToken0x1654653399040a61Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/flowTokenBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkADUToken0xe452a2f5665728f5Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/ADUTokenMetadata) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkaiSportsJuice0x9db94c9564243ba7Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/aiSportsJuiceMetadata) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkBallerzFC0x4ea047c3e73ca460Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/BallerzFCMetadata) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkBeaver0x687e1a7aef17b78bBalance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/BeaverMetadata) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkBloctoToken0x0f9df91c9121c460Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/bloctoTokenBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkbrasil0x7bf07d719dcb8480Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/brasilMetadata) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkceAVAX0x231cc0dbbcffc4b7Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/ceAVAXBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkceBNB0x231cc0dbbcffc4b7Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/ceBNBBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkceBUSD0x231cc0dbbcffc4b7Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/ceBUSDBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkceDAI0x231cc0dbbcffc4b7Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/ceDAIBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkceFTM0x231cc0dbbcffc4b7Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/ceFTMBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkceMATIC0x231cc0dbbcffc4b7Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/ceMATICBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkceUSDT0x231cc0dbbcffc4b7Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/ceUSDTBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkceWBTC0x231cc0dbbcffc4b7Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/ceWBTCBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkceWETH0x231cc0dbbcffc4b7Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/ceWETHBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkDAMO4200x3399d7c6c609b7e5Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/DAMO420Metadata) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkFlovatarDustToken0x921ea449dffec68aBalance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/FlovatarDustTokenBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkFlowBlockchainhitCoin0xd3b62ffbbc632f5aBalance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/FlowBlockchainhitCoinMetadata) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkFUSD0x3c5959b568896393Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/fusdBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkMainledger0xfd1ccaaae39d0e79Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/MainledgerMetadata) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkPetJokicsHorses0x6fd2465f3a22e34cBalance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/PetJokicsHorsesMetadata) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkPokertime0xfd1ccaaae39d0e79Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/PokertimeMetadata) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkREVV0xd01e482eb680ec9fBalance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/revvBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkRLY0x231cc0dbbcffc4b7Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/RLYBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkSloppyStakes0x53f389d96fb4ce5eBalance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/SloppyStakesMetadata) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkStarlyToken0x142fa6570b62fd97Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/starlyTokenBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkstFlowToken0xd6f80565193ad727Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/stFlowTokenBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkTeleportedTetherToken0xcfdd90d4a00f7b5bBalance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/teleportedTetherTokenBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkTheWolfofFlow0x8259c73e487422d7Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/TheWolfofFlowMetadata) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkTopShotBETA0xee09029f1dbcd9d1Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/TopShotBETAMetadata) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkUtahJazzLegendsClub0xcbba4d41aef83fe3Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/UtahJazzLegendsClubMetadata) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkVampire0x67daad91e3782c80Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/VampireMetadata) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkVroomToken0xf887ece39166906eBalance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/VroomTokenBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkDapperUtilityCoin0xead892083b3e2c6cBalance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/dapperUtilityCoinBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkUSDCFlow0xf1ab99c82dee3526Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/usdcFlowMetadata) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkEVMVMBridgedToken_1b97100ea1d7126c4d60027e231ea4cb25314bdb0x1e4aa0b87d10b141Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/EVMVMBridgedToken_1b97100ea1d7126c4d60027e231ea4cb25314bdbVault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkEVMVMBridgedToken_d8ad8ae8375aa31bff541e17dc4b4917014ebdaa0x1e4aa0b87d10b141Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/EVMVMBridgedToken_d8ad8ae8375aa31bff541e17dc4b4917014ebdaaVault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkEVMVMBridgedToken_995258cea49c25595cd94407fad9e99b81406a840x1e4aa0b87d10b141Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/EVMVMBridgedToken_995258cea49c25595cd94407fad9e99b81406a84Vault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkEVMVMBridgedToken_b73bf8e6a4477a952e0338e6cc00cc0ce5ad04ba0x1e4aa0b87d10b141Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/EVMVMBridgedToken_b73bf8e6a4477a952e0338e6cc00cc0ce5ad04baVault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkEVMVMBridgedToken_6a2cd141d75864944318acf272443febc54855a90x1e4aa0b87d10b141Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/EVMVMBridgedToken_6a2cd141d75864944318acf272443febc54855a9Vault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkEVMVMBridgedToken_68eb683a393c8a1c816255b4fc4b89d73c52ad4b0x1e4aa0b87d10b141Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/EVMVMBridgedToken_68eb683a393c8a1c816255b4fc4b89d73c52ad4bVault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkFixesFungibleToken0xb9cd93d3bb31b497Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/FixsStandardFT_0xb9cd93d3bb31b497FIX_Balance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkEVMVMBridgedToken_d3378b419feae4e3a4bb4f3349dba43a1b5117600x1e4aa0b87d10b141Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/EVMVMBridgedToken_d3378b419feae4e3a4bb4f3349dba43a1b511760Vault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkEVMVMBridgedToken_83900c7ffece2a47cac867f87252cdf52bd017a20x1e4aa0b87d10b141Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/EVMVMBridgedToken_83900c7ffece2a47cac867f87252cdf52bd017a2Vault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkEVMVMBridgedToken_f1815bd50389c46847f0bda824ec8da914045d140x1e4aa0b87d10b141Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/EVMVMBridgedToken_f1815bd50389c46847f0bda824ec8da914045d14Vault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkEVMVMBridgedToken_2aabea2058b5ac2d339b163c6ab6f2b6d53aabed0x1e4aa0b87d10b141Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/EVMVMBridgedToken_2aabea2058b5ac2d339b163c6ab6f2b6d53aabedVault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkTSHOT0x05b67ba314000b2dBalance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/TSHOTTokenBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkEVMVMBridgedToken_a0197b2044d28b08be34d98b23c9312158ea9a180x1e4aa0b87d10b141Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/EVMVMBridgedToken_a0197b2044d28b08be34d98b23c9312158ea9a18Vault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkEVMVMBridgedToken_6a64e027e3f6a94acbdcf39cf0cbb4bead5f5ecb0x1e4aa0b87d10b141Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/EVMVMBridgedToken_6a64e027e3f6a94acbdcf39cf0cbb4bead5f5ecbVault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkEVMVMBridgedToken_7296ebca325e835eb6c1b690484cf6fb4c396d2c0x1e4aa0b87d10b141Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/EVMVMBridgedToken_7296ebca325e835eb6c1b690484cf6fb4c396d2cVault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkEVMVMBridgedToken_10448481630fb6d20b597e5b3d7e42dcb1247c8a0x1e4aa0b87d10b141Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/EVMVMBridgedToken_10448481630fb6d20b597e5b3d7e42dcb1247c8aVault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkEVMVMBridgedToken_9b565507858812e8b5ffbfbde9b200a3bc2e8f760x1e4aa0b87d10b141Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/EVMVMBridgedToken_9b565507858812e8b5ffbfbde9b200a3bc2e8f76Vault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkEVMVMBridgedToken_e8b7423b80f9af33480d365171c7ceda3586aa350x1e4aa0b87d10b141Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/EVMVMBridgedToken_e8b7423b80f9af33480d365171c7ceda3586aa35Vault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkEVMVMBridgedToken_f45cbe30bd953590c9917799142edb05be3f293f0x1e4aa0b87d10b141Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/EVMVMBridgedToken_f45cbe30bd953590c9917799142edb05be3f293fVault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkJOSHIN0x82ed1b9cba5bb1b3Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/JOSHIN24KaratBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkTopShotRewardsCommunity0xbb39f0dae1547256Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/TopShotRewardsCommunityMetadata) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkAIICOSMPLG0x82ed1b9cba5bb1b3Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/AIICOSMPLGBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkMEDI0x82ed1b9cba5bb1b3Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/MEDI24KaratBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkREREPO0x82ed1b9cba5bb1b3Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/REREPOBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkFixesFungibleToken0xf5e1e769f8cc612aBalance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/FixsStandardFT_0xf5e1e769f8cc612aROGER_Balance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkFixesFungibleToken0x50a5877cb54ce2fbBalance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/FixsStandardFT_0x50a5877cb54ce2fbWAVE_Balance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkKaratv20x82ed1b9cba5bb1b3Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/karatv2Balance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkSorachi0x82ed1b9cba5bb1b3Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/sorachiBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkFixesFungibleToken0x763991b1118c20e7Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/FixsStandardFT_0x763991b1118c20e7SFF_Balance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkFixesFungibleToken0x1437d34056f6a49dBalance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/FixsStandardFT_0x1437d34056f6a49dTIT_Balance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkFixesFungibleToken0x0169af3078d4efffBalance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/FixsStandardFT_0x0169af3078d4efffRND_Balance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkFixesFungibleToken0x2fc0d080618ee419Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/FixsStandardFT_0x2fc0d080618ee419RUG_Balance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkTS0x82ed1b9cba5bb1b3Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/TSBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkTitToken0x66b60643244a7738Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/TitTokenBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkKARATNVMFD0x82ed1b9cba5bb1b3Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/KARATNVMFDBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkFixesFungibleToken0xef4162279c3dabafBalance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/FixsStandardFT_0xef4162279c3dabafTBH_Balance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkWenPacksDigitaleToken0x93d31c63149d5a67Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/WenPacksDigitaleTokenMetadata) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkFixesFungibleToken0x0ad212f89f63adedBalance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/FixsStandardFT_0x0ad212f89f63adedFFR_Balance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkKarat0x82ed1b9cba5bb1b3Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/karatBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkFoo5Token0x6bafd7adfc749bcfBalance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/foo5TokenMetadata) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkDWLC0x82ed1b9cba5bb1b3Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/DWLCBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkMIGU0x82ed1b9cba5bb1b3Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/MIGUBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkNWayUtilityCoin0x011b6f1425389550Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/NWayUtilityCoinBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkFlowSwapPair0xc6c77b9f5c7a378fBalance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/flowUsdtFspLpBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkStarlyUsdtSwapPair0x6efab66df92c37e4Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/StarlyUsdtSwapLpBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkKARATZHSJR20x82ed1b9cba5bb1b3Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/KARATZHSJR2Balance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkEVMVMBridgedToken_2f6f07cdcf3588944bf4c42ac74ff24bf56e75900x1e4aa0b87d10b141Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/EVMVMBridgedToken_2f6f07cdcf3588944bf4c42ac74ff24bf56e7590Vault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkKARATZ2NPFV40x82ed1b9cba5bb1b3Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/KARATZ2NPFV4Balance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkMARK0x82ed1b9cba5bb1b3Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/MARK24KaratBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkDUNK0x82ed1b9cba5bb1b3Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/DUNKBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkEVMVMBridgedToken_674843c06ff83502ddb4d37c2e09c01cda38cbc80x1e4aa0b87d10b141Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/EVMVMBridgedToken_674843c06ff83502ddb4d37c2e09c01cda38cbc8Vault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkEVMVMBridgedToken_00f4ce400130c9383115f3858f9ca546774265830x1e4aa0b87d10b141Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/EVMVMBridgedToken_00f4ce400130c9383115f3858f9ca54677426583Vault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkKARATZKGGML0x82ed1b9cba5bb1b3Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/KARATZKGGMLBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkEVMVMBridgedToken_1feb32f966dcc4a192eecd8918657884319f80c30x1e4aa0b87d10b141Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/EVMVMBridgedToken_1feb32f966dcc4a192eecd8918657884319f80c3Vault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkFooToken0x3eebe1cb4a1126b2Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/fooTokenVault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkDAOTEST0x3eebe1cb4a1126b2Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/DAOTESTMetadata) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkACCO_SOLEIL0x82ed1b9cba5bb1b3Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/ACCO_SOLEIL24KaratBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkMyFirstToken0x6193b1172142685fBalance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/MyFirstTokenMetadata) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkKARAT18RLOM0x82ed1b9cba5bb1b3Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/KARAT18RLOMBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkMOET0x6b00ff876c299c61Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/moetTokenVault_0x6b00ff876c299c61) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkBaitCoin0xed2202de80195438Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/baitCoinVault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkKARATZICMQ30x82ed1b9cba5bb1b3Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/KARATZICMQ3Balance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkJPY240x215f3ac76cb49656Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/jpy24Balance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkPOINT240x215f3ac76cb49656Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/point24Balance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkBltUsdtSwapPair0xfcb06a5ae5b21a2dBalance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/bltUsdtFspLpBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkKARATZ1DYIVE0x82ed1b9cba5bb1b3Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/KARATZ1DYIVEBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkEVMVMBridgedToken_717dae2baf7656be9a9b01dee31d571a9d4c95790x1e4aa0b87d10b141Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/EVMVMBridgedToken_717dae2baf7656be9a9b01dee31d571a9d4c9579Vault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkRevvFlowSwapPair0x5e284fb7cff23a3fBalance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/revvFlowSwapLpBalance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkEVMVMBridgedToken_c52e820d2d6207d18667a97e2c6ac22eb26e803c0x1e4aa0b87d10b141Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/EVMVMBridgedToken_c52e820d2d6207d18667a97e2c6ac22eb26e803cVault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkEVMVMBridgedToken_99af3eea856556646c98c8b9b2548fe8152407500x1e4aa0b87d10b141Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/EVMVMBridgedToken_99af3eea856556646c98c8b9b2548fe815240750Vault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkEVMVMBridgedToken_cbf9a7753f9d2d0e8141ebb36d99f87acef985970x1e4aa0b87d10b141Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/EVMVMBridgedToken_cbf9a7753f9d2d0e8141ebb36d99f87acef98597Vault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkEVMVMBridgedToken_d069d989e2f44b70c65347d1853c0c67e10a9f8d0x1e4aa0b87d10b141Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/EVMVMBridgedToken_d069d989e2f44b70c65347d1853c0c67e10a9f8dVault) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    

    access(all) fun checkFixesFungibleToken0x84509c2a28c0de41Balance(address: Address) : UFix64 {
      let account = getAccount(address)
      let vaultRef = account
        .capabilities.borrow<&{FungibleToken.Balance}>(/public/FixsStandardFT_0x84509c2a28c0de41RDB_Balance) ?? nil

      if vaultRef != nil {

        return vaultRef!.balance
      }

      return 0.0

    }
    
    access(all) fun main(address: Address) : {String: UFix64} {
      return {
      "A.1654653399040a61.FlowToken" :
    checkFlowToken0x1654653399040a61Balance(address: address)
    ,
      "A.e452a2f5665728f5.ADUToken" :
    checkADUToken0xe452a2f5665728f5Balance(address: address)
    ,
      "A.9db94c9564243ba7.aiSportsJuice" :
    checkaiSportsJuice0x9db94c9564243ba7Balance(address: address)
    ,
      "A.4ea047c3e73ca460.BallerzFC" :
    checkBallerzFC0x4ea047c3e73ca460Balance(address: address)
    ,
      "A.687e1a7aef17b78b.Beaver" :
    checkBeaver0x687e1a7aef17b78bBalance(address: address)
    ,
      "A.0f9df91c9121c460.BloctoToken" :
    checkBloctoToken0x0f9df91c9121c460Balance(address: address)
    ,
      "A.7bf07d719dcb8480.brasil" :
    checkbrasil0x7bf07d719dcb8480Balance(address: address)
    ,
      "A.231cc0dbbcffc4b7.ceAVAX" :
    checkceAVAX0x231cc0dbbcffc4b7Balance(address: address)
    ,
      "A.231cc0dbbcffc4b7.ceBNB" :
    checkceBNB0x231cc0dbbcffc4b7Balance(address: address)
    ,
      "A.231cc0dbbcffc4b7.ceBUSD" :
    checkceBUSD0x231cc0dbbcffc4b7Balance(address: address)
    ,
      "A.231cc0dbbcffc4b7.ceDAI" :
    checkceDAI0x231cc0dbbcffc4b7Balance(address: address)
    ,
      "A.231cc0dbbcffc4b7.ceFTM" :
    checkceFTM0x231cc0dbbcffc4b7Balance(address: address)
    ,
      "A.231cc0dbbcffc4b7.ceMATIC" :
    checkceMATIC0x231cc0dbbcffc4b7Balance(address: address)
    ,
      "A.231cc0dbbcffc4b7.ceUSDT" :
    checkceUSDT0x231cc0dbbcffc4b7Balance(address: address)
    ,
      "A.231cc0dbbcffc4b7.ceWBTC" :
    checkceWBTC0x231cc0dbbcffc4b7Balance(address: address)
    ,
      "A.231cc0dbbcffc4b7.ceWETH" :
    checkceWETH0x231cc0dbbcffc4b7Balance(address: address)
    ,
      "A.3399d7c6c609b7e5.DAMO420" :
    checkDAMO4200x3399d7c6c609b7e5Balance(address: address)
    ,
      "A.921ea449dffec68a.FlovatarDustToken" :
    checkFlovatarDustToken0x921ea449dffec68aBalance(address: address)
    ,
      "A.d3b62ffbbc632f5a.FlowBlockchainhitCoin" :
    checkFlowBlockchainhitCoin0xd3b62ffbbc632f5aBalance(address: address)
    ,
      "A.3c5959b568896393.FUSD" :
    checkFUSD0x3c5959b568896393Balance(address: address)
    ,
      "A.fd1ccaaae39d0e79.Mainledger" :
    checkMainledger0xfd1ccaaae39d0e79Balance(address: address)
    ,
      "A.6fd2465f3a22e34c.PetJokicsHorses" :
    checkPetJokicsHorses0x6fd2465f3a22e34cBalance(address: address)
    ,
      "A.fd1ccaaae39d0e79.Pokertime" :
    checkPokertime0xfd1ccaaae39d0e79Balance(address: address)
    ,
      "A.d01e482eb680ec9f.REVV" :
    checkREVV0xd01e482eb680ec9fBalance(address: address)
    ,
      "A.231cc0dbbcffc4b7.RLY" :
    checkRLY0x231cc0dbbcffc4b7Balance(address: address)
    ,
      "A.53f389d96fb4ce5e.SloppyStakes" :
    checkSloppyStakes0x53f389d96fb4ce5eBalance(address: address)
    ,
      "A.142fa6570b62fd97.StarlyToken" :
    checkStarlyToken0x142fa6570b62fd97Balance(address: address)
    ,
      "A.d6f80565193ad727.stFlowToken" :
    checkstFlowToken0xd6f80565193ad727Balance(address: address)
    ,
      "A.cfdd90d4a00f7b5b.TeleportedTetherToken" :
    checkTeleportedTetherToken0xcfdd90d4a00f7b5bBalance(address: address)
    ,
      "A.8259c73e487422d7.TheWolfofFlow" :
    checkTheWolfofFlow0x8259c73e487422d7Balance(address: address)
    ,
      "A.ee09029f1dbcd9d1.TopShotBETA" :
    checkTopShotBETA0xee09029f1dbcd9d1Balance(address: address)
    ,
      "A.cbba4d41aef83fe3.UtahJazzLegendsClub" :
    checkUtahJazzLegendsClub0xcbba4d41aef83fe3Balance(address: address)
    ,
      "A.67daad91e3782c80.Vampire" :
    checkVampire0x67daad91e3782c80Balance(address: address)
    ,
      "A.f887ece39166906e.VroomToken" :
    checkVroomToken0xf887ece39166906eBalance(address: address)
    ,
      "A.ead892083b3e2c6c.DapperUtilityCoin" :
    checkDapperUtilityCoin0xead892083b3e2c6cBalance(address: address)
    ,
      "A.f1ab99c82dee3526.USDCFlow" :
    checkUSDCFlow0xf1ab99c82dee3526Balance(address: address)
    ,
      "A.1e4aa0b87d10b141.EVMVMBridgedToken_1b97100ea1d7126c4d60027e231ea4cb25314bdb" :
    checkEVMVMBridgedToken_1b97100ea1d7126c4d60027e231ea4cb25314bdb0x1e4aa0b87d10b141Balance(address: address)
    ,
      "A.1e4aa0b87d10b141.EVMVMBridgedToken_d8ad8ae8375aa31bff541e17dc4b4917014ebdaa" :
    checkEVMVMBridgedToken_d8ad8ae8375aa31bff541e17dc4b4917014ebdaa0x1e4aa0b87d10b141Balance(address: address)
    ,
      "A.1e4aa0b87d10b141.EVMVMBridgedToken_995258cea49c25595cd94407fad9e99b81406a84" :
    checkEVMVMBridgedToken_995258cea49c25595cd94407fad9e99b81406a840x1e4aa0b87d10b141Balance(address: address)
    ,
      "A.1e4aa0b87d10b141.EVMVMBridgedToken_b73bf8e6a4477a952e0338e6cc00cc0ce5ad04ba" :
    checkEVMVMBridgedToken_b73bf8e6a4477a952e0338e6cc00cc0ce5ad04ba0x1e4aa0b87d10b141Balance(address: address)
    ,
      "A.1e4aa0b87d10b141.EVMVMBridgedToken_6a2cd141d75864944318acf272443febc54855a9" :
    checkEVMVMBridgedToken_6a2cd141d75864944318acf272443febc54855a90x1e4aa0b87d10b141Balance(address: address)
    ,
      "A.1e4aa0b87d10b141.EVMVMBridgedToken_68eb683a393c8a1c816255b4fc4b89d73c52ad4b" :
    checkEVMVMBridgedToken_68eb683a393c8a1c816255b4fc4b89d73c52ad4b0x1e4aa0b87d10b141Balance(address: address)
    ,
      "A.b9cd93d3bb31b497.FixesFungibleToken" :
    checkFixesFungibleToken0xb9cd93d3bb31b497Balance(address: address)
    ,
      "A.1e4aa0b87d10b141.EVMVMBridgedToken_d3378b419feae4e3a4bb4f3349dba43a1b511760" :
    checkEVMVMBridgedToken_d3378b419feae4e3a4bb4f3349dba43a1b5117600x1e4aa0b87d10b141Balance(address: address)
    ,
      "A.1e4aa0b87d10b141.EVMVMBridgedToken_83900c7ffece2a47cac867f87252cdf52bd017a2" :
    checkEVMVMBridgedToken_83900c7ffece2a47cac867f87252cdf52bd017a20x1e4aa0b87d10b141Balance(address: address)
    ,
      "A.1e4aa0b87d10b141.EVMVMBridgedToken_f1815bd50389c46847f0bda824ec8da914045d14" :
    checkEVMVMBridgedToken_f1815bd50389c46847f0bda824ec8da914045d140x1e4aa0b87d10b141Balance(address: address)
    ,
      "A.1e4aa0b87d10b141.EVMVMBridgedToken_2aabea2058b5ac2d339b163c6ab6f2b6d53aabed" :
    checkEVMVMBridgedToken_2aabea2058b5ac2d339b163c6ab6f2b6d53aabed0x1e4aa0b87d10b141Balance(address: address)
    ,
      "A.05b67ba314000b2d.TSHOT" :
    checkTSHOT0x05b67ba314000b2dBalance(address: address)
    ,
      "A.1e4aa0b87d10b141.EVMVMBridgedToken_a0197b2044d28b08be34d98b23c9312158ea9a18" :
    checkEVMVMBridgedToken_a0197b2044d28b08be34d98b23c9312158ea9a180x1e4aa0b87d10b141Balance(address: address)
    ,
      "A.1e4aa0b87d10b141.EVMVMBridgedToken_6a64e027e3f6a94acbdcf39cf0cbb4bead5f5ecb" :
    checkEVMVMBridgedToken_6a64e027e3f6a94acbdcf39cf0cbb4bead5f5ecb0x1e4aa0b87d10b141Balance(address: address)
    ,
      "A.1e4aa0b87d10b141.EVMVMBridgedToken_7296ebca325e835eb6c1b690484cf6fb4c396d2c" :
    checkEVMVMBridgedToken_7296ebca325e835eb6c1b690484cf6fb4c396d2c0x1e4aa0b87d10b141Balance(address: address)
    ,
      "A.1e4aa0b87d10b141.EVMVMBridgedToken_10448481630fb6d20b597e5b3d7e42dcb1247c8a" :
    checkEVMVMBridgedToken_10448481630fb6d20b597e5b3d7e42dcb1247c8a0x1e4aa0b87d10b141Balance(address: address)
    ,
      "A.1e4aa0b87d10b141.EVMVMBridgedToken_9b565507858812e8b5ffbfbde9b200a3bc2e8f76" :
    checkEVMVMBridgedToken_9b565507858812e8b5ffbfbde9b200a3bc2e8f760x1e4aa0b87d10b141Balance(address: address)
    ,
      "A.1e4aa0b87d10b141.EVMVMBridgedToken_e8b7423b80f9af33480d365171c7ceda3586aa35" :
    checkEVMVMBridgedToken_e8b7423b80f9af33480d365171c7ceda3586aa350x1e4aa0b87d10b141Balance(address: address)
    ,
      "A.1e4aa0b87d10b141.EVMVMBridgedToken_f45cbe30bd953590c9917799142edb05be3f293f" :
    checkEVMVMBridgedToken_f45cbe30bd953590c9917799142edb05be3f293f0x1e4aa0b87d10b141Balance(address: address)
    ,
      "A.82ed1b9cba5bb1b3.JOSHIN" :
    checkJOSHIN0x82ed1b9cba5bb1b3Balance(address: address)
    ,
      "A.bb39f0dae1547256.TopShotRewardsCommunity" :
    checkTopShotRewardsCommunity0xbb39f0dae1547256Balance(address: address)
    ,
      "A.82ed1b9cba5bb1b3.AIICOSMPLG" :
    checkAIICOSMPLG0x82ed1b9cba5bb1b3Balance(address: address)
    ,
      "A.82ed1b9cba5bb1b3.MEDI" :
    checkMEDI0x82ed1b9cba5bb1b3Balance(address: address)
    ,
      "A.82ed1b9cba5bb1b3.REREPO" :
    checkREREPO0x82ed1b9cba5bb1b3Balance(address: address)
    ,
      "A.f5e1e769f8cc612a.FixesFungibleToken" :
    checkFixesFungibleToken0xf5e1e769f8cc612aBalance(address: address)
    ,
      "A.50a5877cb54ce2fb.FixesFungibleToken" :
    checkFixesFungibleToken0x50a5877cb54ce2fbBalance(address: address)
    ,
      "A.82ed1b9cba5bb1b3.Karatv2" :
    checkKaratv20x82ed1b9cba5bb1b3Balance(address: address)
    ,
      "A.82ed1b9cba5bb1b3.Sorachi" :
    checkSorachi0x82ed1b9cba5bb1b3Balance(address: address)
    ,
      "A.763991b1118c20e7.FixesFungibleToken" :
    checkFixesFungibleToken0x763991b1118c20e7Balance(address: address)
    ,
      "A.1437d34056f6a49d.FixesFungibleToken" :
    checkFixesFungibleToken0x1437d34056f6a49dBalance(address: address)
    ,
      "A.0169af3078d4efff.FixesFungibleToken" :
    checkFixesFungibleToken0x0169af3078d4efffBalance(address: address)
    ,
      "A.2fc0d080618ee419.FixesFungibleToken" :
    checkFixesFungibleToken0x2fc0d080618ee419Balance(address: address)
    ,
      "A.82ed1b9cba5bb1b3.TS" :
    checkTS0x82ed1b9cba5bb1b3Balance(address: address)
    ,
      "A.66b60643244a7738.TitToken" :
    checkTitToken0x66b60643244a7738Balance(address: address)
    ,
      "A.82ed1b9cba5bb1b3.KARATNVMFD" :
    checkKARATNVMFD0x82ed1b9cba5bb1b3Balance(address: address)
    ,
      "A.ef4162279c3dabaf.FixesFungibleToken" :
    checkFixesFungibleToken0xef4162279c3dabafBalance(address: address)
    ,
      "A.93d31c63149d5a67.WenPacksDigitaleToken" :
    checkWenPacksDigitaleToken0x93d31c63149d5a67Balance(address: address)
    ,
      "A.0ad212f89f63aded.FixesFungibleToken" :
    checkFixesFungibleToken0x0ad212f89f63adedBalance(address: address)
    ,
      "A.82ed1b9cba5bb1b3.Karat" :
    checkKarat0x82ed1b9cba5bb1b3Balance(address: address)
    ,
      "A.6bafd7adfc749bcf.Foo5Token" :
    checkFoo5Token0x6bafd7adfc749bcfBalance(address: address)
    ,
      "A.82ed1b9cba5bb1b3.DWLC" :
    checkDWLC0x82ed1b9cba5bb1b3Balance(address: address)
    ,
      "A.82ed1b9cba5bb1b3.MIGU" :
    checkMIGU0x82ed1b9cba5bb1b3Balance(address: address)
    ,
      "A.011b6f1425389550.NWayUtilityCoin" :
    checkNWayUtilityCoin0x011b6f1425389550Balance(address: address)
    ,
      "A.c6c77b9f5c7a378f.FlowSwapPair" :
    checkFlowSwapPair0xc6c77b9f5c7a378fBalance(address: address)
    ,
      "A.6efab66df92c37e4.StarlyUsdtSwapPair" :
    checkStarlyUsdtSwapPair0x6efab66df92c37e4Balance(address: address)
    ,
      "A.82ed1b9cba5bb1b3.KARATZHSJR2" :
    checkKARATZHSJR20x82ed1b9cba5bb1b3Balance(address: address)
    ,
      "A.1e4aa0b87d10b141.EVMVMBridgedToken_2f6f07cdcf3588944bf4c42ac74ff24bf56e7590" :
    checkEVMVMBridgedToken_2f6f07cdcf3588944bf4c42ac74ff24bf56e75900x1e4aa0b87d10b141Balance(address: address)
    ,
      "A.82ed1b9cba5bb1b3.KARATZ2NPFV4" :
    checkKARATZ2NPFV40x82ed1b9cba5bb1b3Balance(address: address)
    ,
      "A.82ed1b9cba5bb1b3.MARK" :
    checkMARK0x82ed1b9cba5bb1b3Balance(address: address)
    ,
      "A.82ed1b9cba5bb1b3.DUNK" :
    checkDUNK0x82ed1b9cba5bb1b3Balance(address: address)
    ,
      "A.1e4aa0b87d10b141.EVMVMBridgedToken_674843c06ff83502ddb4d37c2e09c01cda38cbc8" :
    checkEVMVMBridgedToken_674843c06ff83502ddb4d37c2e09c01cda38cbc80x1e4aa0b87d10b141Balance(address: address)
    ,
      "A.1e4aa0b87d10b141.EVMVMBridgedToken_00f4ce400130c9383115f3858f9ca54677426583" :
    checkEVMVMBridgedToken_00f4ce400130c9383115f3858f9ca546774265830x1e4aa0b87d10b141Balance(address: address)
    ,
      "A.82ed1b9cba5bb1b3.KARATZKGGML" :
    checkKARATZKGGML0x82ed1b9cba5bb1b3Balance(address: address)
    ,
      "A.1e4aa0b87d10b141.EVMVMBridgedToken_1feb32f966dcc4a192eecd8918657884319f80c3" :
    checkEVMVMBridgedToken_1feb32f966dcc4a192eecd8918657884319f80c30x1e4aa0b87d10b141Balance(address: address)
    ,
      "A.3eebe1cb4a1126b2.FooToken" :
    checkFooToken0x3eebe1cb4a1126b2Balance(address: address)
    ,
      "A.3eebe1cb4a1126b2.DAOTEST" :
    checkDAOTEST0x3eebe1cb4a1126b2Balance(address: address)
    ,
      "A.82ed1b9cba5bb1b3.ACCO_SOLEIL" :
    checkACCO_SOLEIL0x82ed1b9cba5bb1b3Balance(address: address)
    ,
      "A.6193b1172142685f.MyFirstToken" :
    checkMyFirstToken0x6193b1172142685fBalance(address: address)
    ,
      "A.82ed1b9cba5bb1b3.KARAT18RLOM" :
    checkKARAT18RLOM0x82ed1b9cba5bb1b3Balance(address: address)
    ,
      "A.6b00ff876c299c61.MOET" :
    checkMOET0x6b00ff876c299c61Balance(address: address)
    ,
      "A.ed2202de80195438.BaitCoin" :
    checkBaitCoin0xed2202de80195438Balance(address: address)
    ,
      "A.82ed1b9cba5bb1b3.KARATZICMQ3" :
    checkKARATZICMQ30x82ed1b9cba5bb1b3Balance(address: address)
    ,
      "A.215f3ac76cb49656.JPY24" :
    checkJPY240x215f3ac76cb49656Balance(address: address)
    ,
      "A.215f3ac76cb49656.POINT24" :
    checkPOINT240x215f3ac76cb49656Balance(address: address)
    ,
      "A.fcb06a5ae5b21a2d.BltUsdtSwapPair" :
    checkBltUsdtSwapPair0xfcb06a5ae5b21a2dBalance(address: address)
    ,
      "A.82ed1b9cba5bb1b3.KARATZ1DYIVE" :
    checkKARATZ1DYIVE0x82ed1b9cba5bb1b3Balance(address: address)
    ,
      "A.1e4aa0b87d10b141.EVMVMBridgedToken_717dae2baf7656be9a9b01dee31d571a9d4c9579" :
    checkEVMVMBridgedToken_717dae2baf7656be9a9b01dee31d571a9d4c95790x1e4aa0b87d10b141Balance(address: address)
    ,
      "A.5e284fb7cff23a3f.RevvFlowSwapPair" :
    checkRevvFlowSwapPair0x5e284fb7cff23a3fBalance(address: address)
    ,
      "A.1e4aa0b87d10b141.EVMVMBridgedToken_c52e820d2d6207d18667a97e2c6ac22eb26e803c" :
    checkEVMVMBridgedToken_c52e820d2d6207d18667a97e2c6ac22eb26e803c0x1e4aa0b87d10b141Balance(address: address)
    ,
      "A.1e4aa0b87d10b141.EVMVMBridgedToken_99af3eea856556646c98c8b9b2548fe815240750" :
    checkEVMVMBridgedToken_99af3eea856556646c98c8b9b2548fe8152407500x1e4aa0b87d10b141Balance(address: address)
    ,
      "A.1e4aa0b87d10b141.EVMVMBridgedToken_cbf9a7753f9d2d0e8141ebb36d99f87acef98597" :
    checkEVMVMBridgedToken_cbf9a7753f9d2d0e8141ebb36d99f87acef985970x1e4aa0b87d10b141Balance(address: address)
    ,
      "A.1e4aa0b87d10b141.EVMVMBridgedToken_d069d989e2f44b70c65347d1853c0c67e10a9f8d" :
    checkEVMVMBridgedToken_d069d989e2f44b70c65347d1853c0c67e10a9f8d0x1e4aa0b87d10b141Balance(address: address)
    ,
      "A.84509c2a28c0de41.FixesFungibleToken" :
    checkFixesFungibleToken0x84509c2a28c0de41Balance(address: address)
    }
    }
  ", + "addToken": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYWRkVG9rZW4gLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgppbXBvcnQgPFRva2VuPiBmcm9tIDxUb2tlbkFkZHJlc3M+Cgp0cmFuc2FjdGlvbiB7CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSwgQ2FwYWJpbGl0aWVzKSAmQWNjb3VudCkgewoKICAgICAgICBpZiBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8JjxUb2tlbj4uVmF1bHQ+KGZyb206IDxUb2tlblN0b3JhZ2VQYXRoPiApID09IG5pbCB7CiAgICAgICAgICAgIHNpZ25lci5zdG9yYWdlLnNhdmUoPC0gPFRva2VuPi5jcmVhdGVFbXB0eVZhdWx0KHZhdWx0VHlwZTogVHlwZTxAPFRva2VuPi5WYXVsdD4oKSksIHRvOiA8VG9rZW5TdG9yYWdlUGF0aD4pCiAgICAgICAgfQoKICAgICAgICBpZiBzaWduZXIuY2FwYWJpbGl0aWVzLmV4aXN0cyg8VG9rZW5SZWNlaXZlclBhdGg+KSA9PSBmYWxzZSB7CiAgICAgICAgICAgIGxldCByZWNlaXZlckNhcGFiaWxpdHkgPSBzaWduZXIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8JjxUb2tlbj4uVmF1bHQ+KDxUb2tlblN0b3JhZ2VQYXRoPikKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5wdWJsaXNoKHJlY2VpdmVyQ2FwYWJpbGl0eSwgYXQ6IDxUb2tlblJlY2VpdmVyUGF0aD4pCiAgICAgICAgCiAgICAgICAgfQogICAgICAgCiAgICAgICAgaWYgc2lnbmVyLmNhcGFiaWxpdGllcy5leGlzdHMoPFRva2VuQmFsYW5jZVBhdGg+KSA9PSBmYWxzZSB7CiAgICAgICAgICAgIGxldCBiYWxhbmNlQ2FwYWJpbGl0eSA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTwmPFRva2VuPi5WYXVsdD4oPFRva2VuU3RvcmFnZVBhdGg+KQogICAgICAgICAgICBzaWduZXIuY2FwYWJpbGl0aWVzLnB1Ymxpc2goYmFsYW5jZUNhcGFiaWxpdHksIGF0OiA8VG9rZW5CYWxhbmNlUGF0aD4pCiAgICAgICAgfQogICAgCiAgICB9Cn0\u003d", + "enableTokenStorage": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZW5hYmxlVG9rZW5TdG9yYWdlIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKaW1wb3J0IDxUb2tlbj4gZnJvbSA8VG9rZW5BZGRyZXNzPgoKdHJhbnNhY3Rpb24gewoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIENhcGFiaWxpdGllcykgJkFjY291bnQpIHsKCiAgICAgICAgaWYgc2lnbmVyLnN0b3JhZ2UuYm9ycm93PCY8VG9rZW4+LlZhdWx0Pihmcm9tOiA8VG9rZW5TdG9yYWdlUGF0aD4gKSA9PSBuaWwgewogICAgICAgICAgICBzaWduZXIuc3RvcmFnZS5zYXZlKDwtIDxUb2tlbj4uY3JlYXRlRW1wdHlWYXVsdCh2YXVsdFR5cGU6IFR5cGU8QDxUb2tlbj4uVmF1bHQ+KCkpLCB0bzogPFRva2VuU3RvcmFnZVBhdGg+KQogICAgICAgIH0KCiAgICAgICAgaWYgc2lnbmVyLmNhcGFiaWxpdGllcy5leGlzdHMoPFRva2VuUmVjZWl2ZXJQYXRoPikgPT0gZmFsc2UgewogICAgICAgICAgICBsZXQgcmVjZWl2ZXJDYXBhYmlsaXR5ID0gc2lnbmVyLmNhcGFiaWxpdGllcy5zdG9yYWdlLmlzc3VlPCY8VG9rZW4+LlZhdWx0Pig8VG9rZW5TdG9yYWdlUGF0aD4pCiAgICAgICAgICAgIHNpZ25lci5jYXBhYmlsaXRpZXMucHVibGlzaChyZWNlaXZlckNhcGFiaWxpdHksIGF0OiA8VG9rZW5SZWNlaXZlclBhdGg+KQogICAgICAgIAogICAgICAgIH0KICAgICAgIAogICAgICAgIGlmIHNpZ25lci5jYXBhYmlsaXRpZXMuZXhpc3RzKDxUb2tlbkJhbGFuY2VQYXRoPikgPT0gZmFsc2UgewogICAgICAgICAgICBsZXQgYmFsYW5jZUNhcGFiaWxpdHkgPSBzaWduZXIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8JjxUb2tlbj4uVmF1bHQ+KDxUb2tlblN0b3JhZ2VQYXRoPikKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5wdWJsaXNoKGJhbGFuY2VDYXBhYmlsaXR5LCBhdDogPFRva2VuQmFsYW5jZVBhdGg+KQogICAgICAgIH0KICAgIAogICAgfQp9", + "enableTokenStorageV2": "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", + "getTokenBalanceStorage": "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\u003d\u003d", + "transferEvmTokens": "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\u003d", + "transferTokens": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgdHJhbnNmZXJUb2tlbnMgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgppbXBvcnQgPFRva2VuPiBmcm9tIDxUb2tlbkFkZHJlc3M+CgoKdHJhbnNhY3Rpb24oYW1vdW50OiBVRml4NjQsIHJlY2lwaWVudDogQWRkcmVzcykgewoKICAgIC8vIFRoZSBWYXVsdCByZXNvdXJjZSB0aGF0IGhvbGRzIHRoZSB0b2tlbnMgdGhhdCBhcmUgYmVpbmcgdHJhbnNmZXJlZAogICAgbGV0IHNlbnRWYXVsdDogQHtGdW5naWJsZVRva2VuLlZhdWx0fQoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgICAvLyBHZXQgYSByZWZlcmVuY2UgdG8gdGhlIHNpZ25lcidzIHN0b3JlZCB2YXVsdAogICAgICAgIGxldCB2YXVsdFJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICY8VG9rZW4+LlZhdWx0Pihmcm9tOiA8VG9rZW5TdG9yYWdlUGF0aD4pCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IHJlZmVyZW5jZSB0byB0aGUgb3duZXIncyBWYXVsdCEiKQoKICAgICAgICAvLyBXaXRoZHJhdyB0b2tlbnMgZnJvbSB0aGUgc2lnbmVyJ3Mgc3RvcmVkIHZhdWx0CiAgICAgICAgc2VsZi5zZW50VmF1bHQgPC0gdmF1bHRSZWYud2l0aGRyYXcoYW1vdW50OiBhbW91bnQpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgLy8gR2V0IHRoZSByZWNpcGllbnQncyBwdWJsaWMgYWNjb3VudCBvYmplY3QKICAgICAgICBsZXQgcmVjaXBpZW50QWNjb3VudCA9IGdldEFjY291bnQocmVjaXBpZW50KQoKICAgICAgICAvLyBHZXQgYSByZWZlcmVuY2UgdG8gdGhlIHJlY2lwaWVudCdzIFJlY2VpdmVyCiAgICAgICAgbGV0IHJlY2VpdmVyUmVmID0gcmVjaXBpZW50QWNjb3VudC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5WYXVsdH0+KDxUb2tlblJlY2VpdmVyUGF0aD4pIQogICAgICAgICAgICAKICAgICAgICAvLyBEZXBvc2l0IHRoZSB3aXRoZHJhd24gdG9rZW5zIGluIHRoZSByZWNpcGllbnQncyByZWNlaXZlcgogICAgICAgIHJlY2VpdmVyUmVmLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKCiAgICB9Cn0\u003d", + "transferTokensV3": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgdHJhbnNmZXJUb2tlbnNWMyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKCmltcG9ydCBTdG9yYWdlUmVudCBmcm9tIDB4NzA3YWRiYWQxNDI4YzYyNAoKaW1wb3J0IDxUb2tlbj4gZnJvbSA8VG9rZW5BZGRyZXNzPgoKCnRyYW5zYWN0aW9uKGFtb3VudDogVUZpeDY0LCByZWNpcGllbnQ6IEFkZHJlc3MpIHsKCiAgICAvLyBUaGUgVmF1bHQgcmVzb3VyY2UgdGhhdCBob2xkcyB0aGUgdG9rZW5zIHRoYXQgYXJlIGJlaW5nIHRyYW5zZmVyZWQKICAgIGxldCBzZW50VmF1bHQ6IEB7RnVuZ2libGVUb2tlbi5WYXVsdH0KCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChTdG9yYWdlLCBCb3Jyb3dWYWx1ZSkgJkFjY291bnQpIHsKICAgICAgICAgLy8gR2V0IGEgcmVmZXJlbmNlIHRvIHRoZSBzaWduZXIncyBzdG9yZWQgdmF1bHQKICAgICAgICBsZXQgdmF1bHRSZWYgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAmPFRva2VuPi5WYXVsdD4oZnJvbTogPFRva2VuU3RvcmFnZVBhdGg+KQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIG93bmVyJ3MgVmF1bHQhIikKCiAgICAgICAgLy8gV2l0aGRyYXcgdG9rZW5zIGZyb20gdGhlIHNpZ25lcidzIHN0b3JlZCB2YXVsdAogICAgICAgIHNlbGYuc2VudFZhdWx0IDwtIHZhdWx0UmVmLndpdGhkcmF3KGFtb3VudDogYW1vdW50KQogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIC8vIEdldCB0aGUgcmVjaXBpZW50J3MgcHVibGljIGFjY291bnQgb2JqZWN0CiAgICAgICAgbGV0IHJlY2lwaWVudEFjY291bnQgPSBnZXRBY2NvdW50KHJlY2lwaWVudCkKCiAgICAgICAgLy8gR2V0IGEgcmVmZXJlbmNlIHRvIHRoZSByZWNpcGllbnQncyBSZWNlaXZlcgogICAgICAgIGxldCByZWNlaXZlclJlZiA9IHJlY2lwaWVudEFjY291bnQuY2FwYWJpbGl0aWVzLmJvcnJvdzwme0Z1bmdpYmxlVG9rZW4uVmF1bHR9Pig8VG9rZW5SZWNlaXZlclBhdGg+KSEKICAgICAgICAgICAgCiAgICAgICAgLy8gRGVwb3NpdCB0aGUgd2l0aGRyYXduIHRva2VucyBpbiB0aGUgcmVjaXBpZW50J3MgcmVjZWl2ZXIKICAgICAgICByZWNlaXZlclJlZi5kZXBvc2l0KGZyb206IDwtc2VsZi5zZW50VmF1bHQpCiAgICAgICAgU3RvcmFnZVJlbnQudHJ5UmVmaWxsKHJlY2lwaWVudCkKCiAgICB9Cn0\u003d" + }, + "hybridCustody": { + "addNFTCollectionToDelegator": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYWRkTkZUQ29sbGVjdGlvblRvRGVsZWdhdG9yIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgSHlicmlkQ3VzdG9keSBmcm9tIDB4ZDhhN2UwNWE3YWM2NzBjMAoKCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4MWQ3ZTU3YWE1NTgxNzQ0OAoKaW1wb3J0IDxUb2tlbj4gZnJvbSA8VG9rZW5BZGRyZXNzPgoKdHJhbnNhY3Rpb24ocGFyZW50OiBBZGRyZXNzLCBpc1B1YmxpYzogQm9vbCkgewogICAgcHJlcGFyZShhY2N0OiBhdXRoKFN0b3JhZ2UsIENhcGFiaWxpdGllcykgJkFjY291bnQpIHsKICAgICAgICBsZXQgbyA9IGFjY3Quc3RvcmFnZS5ib3Jyb3c8YXV0aChIeWJyaWRDdXN0b2R5Lk93bmVyKSAmSHlicmlkQ3VzdG9keS5Pd25lZEFjY291bnQ+KGZyb206IEh5YnJpZEN1c3RvZHkuT3duZWRBY2NvdW50U3RvcmFnZVBhdGgpCiAgICAgICAgICAgID8/IHBhbmljKCJvd25lZCBhY2NvdW50IG5vdCBmb3VuZCIpCiAgICAgICAgbGV0IGNoaWxkOiAmSHlicmlkQ3VzdG9keS5DaGlsZEFjY291bnQgPSBvLmJvcnJvd0NoaWxkQWNjb3VudChwYXJlbnQ6IHBhcmVudCkKICAgICAgICAgICAgPz8gcGFuaWMoImNoaWxkIGFjY291bnQgbm90IGZvdW5kIikKCiAgICAgICAgbGV0IGNhcCA9IGFjY3QuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8JkV4YW1wbGVORlQuQ29sbGVjdGlvbj4oRXhhbXBsZU5GVC5Db2xsZWN0aW9uU3RvcmFnZVBhdGgpCiAgICAgICAgby5hZGRDYXBhYmlsaXR5VG9EZWxlZ2F0b3IocGFyZW50OiBwYXJlbnQsIGNhcDogY2FwLCBpc1B1YmxpYzogaXNQdWJsaWMpCiAgICB9Cn0\u003d", + "batchBridgeChildNFTFromEvm": "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\u003d", + "batchBridgeChildNFTToEvm": "// Flow Wallet - mainnet Script  batchBridgeChildNFTToEvm - v2.78
// <platform_info>

import MetadataViews from 0x1d7e57aa55817448

import ViewResolver from 0x1d7e57aa55817448

import NonFungibleToken from 0x1d7e57aa55817448

import FungibleToken from 0xf233dcee88fe0abe

import FlowToken from 0x1654653399040a61

import FungibleTokenMetadataViews from 0xf233dcee88fe0abe

import ScopedFTProviders from 0x1e4aa0b87d10b141

import EVM from 0xe467b9dd11fa00df

import FlowEVMBridgeUtils from 0x1e4aa0b87d10b141

import FlowEVMBridge from 0x1e4aa0b87d10b141

import FlowEVMBridgeConfig from 0x1e4aa0b87d10b141

import HybridCustody from 0xd8a7e05a7ac670c0

import CapabilityFilter from 0xd8a7e05a7ac670c0

import CrossVMMetadataViews from 0x1d7e57aa55817448


transaction(nftIdentifier: String, child: Address, ids: [UInt64]) {
    prepare(signer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, Capabilities, SaveValue) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        let coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        let m = signer.storage.borrow<auth(HybridCustody.Manage) &HybridCustody.Manager>(from: HybridCustody.ManagerStoragePath)
            ?? panic("manager does not exist")
        let childAcct = m.borrowAccount(addr: child) ?? panic("child account not found")

         // Construct the NFT type from the provided identifier
        let nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Retrieve the NFT --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        let viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = viewResolver.resolveContractView(
                resourceType: nil,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        var collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            )

        // Create collection if it doesn't exist
        if collection == nil {
            signer.storage.save(<- collectionData.createEmptyCollection(), to: collectionData.storagePath)
            signer.capabilities.unpublish(collectionData.publicPath)
            signer.capabilities.publish(
                signer.capabilities.storage.issue<&{NonFungibleToken.Collection}>(collectionData.storagePath),
                at: collectionData.publicPath
            )

            // Borrow authorized withdraw reference to the signer's collection
            collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            )!
        }

        let capType = Type<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider}>()
        let controllerID = childAcct.getControllerIDForType(type: capType, forPath: collectionData.storagePath)
            ?? panic("no controller found for capType")

        let cap = childAcct.getCapability(controllerID: controllerID, type: capType) ?? panic("no cap found")
        let providerCap = cap as! Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider}>
        assert(providerCap.check(), message: "invalid provider capability")

        let id = ids[0]
        // Get a reference to the child's stored vault
        let collectionRef = providerCap.borrow()!
        let childNft <- collectionRef.withdraw(withdrawID: id)
        collection!.deposit(token: <-childNft)
        // // Withdraw tokens from the signer's stored vault
        let currentStorageUsage = signer.storage.used
        let nft <- collection!.withdraw(withdrawID: id)
        let withdrawnStorageUsage = signer.storage.used
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(
                bytes: 400_000
            ) + (FlowEVMBridgeConfig.baseFee * UFix64(ids.length))

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        let scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )

        // Execute the bridge
        coa.depositNFT(
            nft: <- nft,
            feeProvider: &scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        var idx = 0
        for nftId in ids {
            if idx == 0 {
                idx = idx + 1
                continue
            }

            let nft <- collectionRef.withdraw(withdrawID: nftId)
            coa.depositNFT(
                nft: <- nft,
                feeProvider: &scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
            idx = idx + 1
        }
        // Destroy the ScopedFTProvider
        destroy scopedProvider

        // Wrap NFTs if applicable
        wrapAndTransferNFTsIfApplicable(coa,
            nftIDs: ids,
            nftType: nftType,
            viewResolver: viewResolver,
            recipientIfNotCoa: nil
        )
    }
}

/// Wraps and transfers bridged NFTs into a project's custom ERC721 wrapper contract on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
/// @param recipientIfNotCoa: The EVM address to transfer the wrapped NFTs to, nil if the NFTs should stay in signer's COA
///
access(all) fun wrapAndTransferNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt64],
    nftType: Type,
    viewResolver: &{ViewResolver},
    recipientIfNotCoa: EVM.EVMAddress?
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            // Wrap NFTs if underlying ERC721 address matches bridge's associated address for NFT type
            if underlyingAddress.equals(FlowEVMBridgeConfig.getEVMAddressAssociated(with: nftType)!) {
                // Approve contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, true]
                )

                // Wrap NFTs with provided IDs, and check if the call was successful
                let res = mustCall(coa, crossVMPointer.evmContractAddress,
                    functionSig: "depositFor(address,uint256[])",
                    args: [coa.address(), nftIDs]
                )
                let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                assert(decodedRes.length == 1, message: "Invalid response length")
                assert(decodedRes[0] as! Bool, message: "Failed to wrap NFTs")

                // Transfer NFTs to recipient if provided
                if let to = recipientIfNotCoa {
                    mustTransferNFTs(coa, crossVMPointer.evmContractAddress, nftIDs: nftIDs, to: to)
                }

                // Revoke approval for contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, false]
                )
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is owned by the provided EVM address
///
access(all) fun isOwner(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    _ nftID: UInt64,
    _ ownerToCheck: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: erc721Address,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )
    assert(res.status == EVM.Status.successful, message: "Call to ERC721.ownerOf(uint256) failed")
    let decodedRes = EVM.decodeABI(types: [Type<EVM.EVMAddress>()], data: res.data)
    if decodedRes.length == 1 {
        let actualOwner = decodedRes[0] as! EVM.EVMAddress
        return actualOwner.equals(ownerToCheck)
    }
    return false
}

/// Transfers NFTs from the provided COA to the provided EVM address
///
access(all) fun mustTransferNFTs(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    nftIDs: [UInt64],
    to: EVM.EVMAddress
) {
    for id in nftIDs {
        assert(isOwner(coa, erc721Address, id, coa.address()), message: "NFT not owned by signer's COA")
        mustCall(coa, erc721Address,
            functionSig: "safeTransferFrom(address,address,uint256)",
            args: [coa.address(), to, id]
        )
        assert(isOwner(coa, erc721Address, id, to), message: "NFT not transferred to recipient")
    }
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", + "batchBridgeChildNFTToEvmAddress": "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\u003d\u003d", + "batchSendChildNFT": "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\u003d", + "batchSendChildNFTToChild": "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\u003d\u003d", + "batchTransferChildNFT": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYmF0Y2hUcmFuc2ZlckNoaWxkTkZUIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgSHlicmlkQ3VzdG9keSBmcm9tIDB4ZDhhN2UwNWE3YWM2NzBjMAoKaW1wb3J0IENhcGFiaWxpdHlGaWx0ZXIgZnJvbSAweGQ4YTdlMDVhN2FjNjcwYzAKCmltcG9ydCBOb25GdW5naWJsZVRva2VuIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgTWV0YWRhdGFWaWV3cyBmcm9tIDB4MWQ3ZTU3YWE1NTgxNzQ0OAoKaW1wb3J0IDxORlQ+IGZyb20gPE5GVEFkZHJlc3M+CgovLy8gVHJhbnNmZXIgbXVsdGlwbGUgTkZUcyBmcm9tIHByb3ZpZGVkIGNoaWxkIGFjY291bnQgYWRkcmVzcyB0byBwYXJlbnQgYWNjb3VudCAoc2lnbmVyKQovLy8KdHJhbnNhY3Rpb24oYWRkcmVzczogQWRkcmVzcywgcGF0aDogU3RyaW5nLCBpZHM6IFtVSW50NjRdKSB7CgogIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIENhcGFiaWxpdGllcykgJkFjY291bnQpIHsKICAgIC8vIEdldCB0aGUgbWFuYWdlciByZXNvdXJjZSBhbmQgYm9ycm93IGNoaWxkQWNjb3VudAogICAgbGV0IG0gPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChIeWJyaWRDdXN0b2R5Lk1hbmFnZSkgJkh5YnJpZEN1c3RvZHkuTWFuYWdlcj4oZnJvbTogSHlicmlkQ3VzdG9keS5NYW5hZ2VyU3RvcmFnZVBhdGgpCiAgICAgICAgPz8gcGFuaWMoIm1hbmFnZXIgZG9lcyBub3QgZXhpc3QiKQogICAgbGV0IGNoaWxkQWNjdCA9IG0uYm9ycm93QWNjb3VudChhZGRyOiBhZGRyZXNzKSA/PyBwYW5pYygiY2hpbGQgYWNjb3VudCBub3QgZm91bmQiKQoKICAgIC8vIEdldCB0aGUgY29sbGVjdGlvbiBkYXRhIHZpZXcgZm9yIHRoZSBORlQKICAgIGxldCBjb2xsZWN0aW9uRGF0YSA9IDxORlQ+LnJlc29sdmVDb250cmFjdFZpZXcocmVzb3VyY2VUeXBlOiBuaWwsIHZpZXdUeXBlOiBUeXBlPE1ldGFkYXRhVmlld3MuTkZUQ29sbGVjdGlvbkRhdGE+KCkpIGFzISBNZXRhZGF0YVZpZXdzLk5GVENvbGxlY3Rpb25EYXRhPwogICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgZ2V0IHRoZSB2YXVsdCBkYXRhIHZpZXcgZm9yIDxORlQ+ICIpCgogICAgLy8gUmV0cmlldmUgYSBwcm92aWRlciBjYXBhYmlsaXR5IGZyb20gdGhlIGNoaWxkIGFjY291bnQgYW5kIGJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgY2hpbGQncyBjb2xsZWN0aW9uCiAgICBsZXQgY2FwVHlwZSA9IFR5cGU8YXV0aChOb25GdW5naWJsZVRva2VuLldpdGhkcmF3KSAme05vbkZ1bmdpYmxlVG9rZW4uUHJvdmlkZXJ9PigpCiAgICBsZXQgY29udHJvbGxlcklEID0gY2hpbGRBY2N0LmdldENvbnRyb2xsZXJJREZvclR5cGUodHlwZTogY2FwVHlwZSwgZm9yUGF0aDogY29sbGVjdGlvbkRhdGEuc3RvcmFnZVBhdGgpCiAgICAgICAgPz8gcGFuaWMoIm5vIGNvbnRyb2xsZXIgZm91bmQgZm9yIGNhcFR5cGUiKQoKICAgIGxldCBjYXAgPSBjaGlsZEFjY3QuZ2V0Q2FwYWJpbGl0eShjb250cm9sbGVySUQ6IGNvbnRyb2xsZXJJRCwgdHlwZTogY2FwVHlwZSkgPz8gcGFuaWMoIm5vIGNhcCBmb3VuZCIpCiAgICBsZXQgcHJvdmlkZXJDYXAgPSBjYXAgYXMhIENhcGFiaWxpdHk8YXV0aChOb25GdW5naWJsZVRva2VuLldpdGhkcmF3KSAme05vbkZ1bmdpYmxlVG9rZW4uUHJvdmlkZXJ9PgogICAgYXNzZXJ0KHByb3ZpZGVyQ2FwLmNoZWNrKCksIG1lc3NhZ2U6ICJpbnZhbGlkIHByb3ZpZGVyIGNhcGFiaWxpdHkiKQogICAgbGV0IGNoaWxkQ29sbGVjdGlvblJlZiA9IHByb3ZpZGVyQ2FwLmJvcnJvdygpIQoKICAgIC8vIEJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgc2lnbmVyJ3MgY29sbGVjdGlvbiBvciBjcmVhdGUgYSBjb2xsZWN0aW9uIGlmIGl0IGRvZXNuJ3QgZXhpc3QKICAgIHZhciByZWNlaXZlclJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzwme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0+KGZyb206IGNvbGxlY3Rpb25EYXRhLnN0b3JhZ2VQYXRoKQogICAgaWYgcmVjZWl2ZXJSZWYgPT0gbmlsIHsKICAgICAgc2lnbmVyLnN0b3JhZ2Uuc2F2ZSg8LSA8TkZUPi5jcmVhdGVFbXB0eUNvbGxlY3Rpb24obmZ0VHlwZTogVHlwZTxAPE5GVD4uTkZUPigpKSwgdG86IGNvbGxlY3Rpb25EYXRhLnN0b3JhZ2VQYXRoKQogICAgICBzaWduZXIuY2FwYWJpbGl0aWVzLnVucHVibGlzaChjb2xsZWN0aW9uRGF0YS5wdWJsaWNQYXRoKQogICAgICBsZXQgY29sbGVjdGlvbkNhcCA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTwmPE5GVD4uQ29sbGVjdGlvbj4oY29sbGVjdGlvbkRhdGEuc3RvcmFnZVBhdGgpCiAgICAgIHNpZ25lci5jYXBhYmlsaXRpZXMucHVibGlzaChjb2xsZWN0aW9uQ2FwLCBhdDogY29sbGVjdGlvbkRhdGEucHVibGljUGF0aCkKICAgICAgcmVjZWl2ZXJSZWYgPSBjb2xsZWN0aW9uQ2FwLmJvcnJvdygpIQogICAgfQoKICAgIC8vIFRyYW5zZmVyIE5GVHMgZnJvbSBjaGlsZCBhY2NvdW50J3MgY29sbGVjdGlvbiB0byBzaWduZXIncyBjb2xsZWN0aW9uCiAgICBmb3IgaWQgaW4gaWRzIHsKICAgICAgICByZWNlaXZlclJlZiEuZGVwb3NpdCh0b2tlbjogPC0gY2hpbGRDb2xsZWN0aW9uUmVmLndpdGhkcmF3KHdpdGhkcmF3SUQ6IGlkKSkKICAgIH0KICB9Cn0K", + "batchTransferNFTToChild": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYmF0Y2hUcmFuc2Zlck5GVFRvQ2hpbGQgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBIeWJyaWRDdXN0b2R5IGZyb20gMHhkOGE3ZTA1YTdhYzY3MGMwCgppbXBvcnQgQ2FwYWJpbGl0eUZpbHRlciBmcm9tIDB4ZDhhN2UwNWE3YWM2NzBjMAoKaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgPE5GVD4gZnJvbSA8TkZUQWRkcmVzcz4KCnRyYW5zYWN0aW9uKGNoaWxkQWRkcjogQWRkcmVzcywgaWRlbnRpZmllcjogU3RyaW5nLCBpZHM6IFtVSW50NjRdKSB7CiAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSkgJkFjY291bnQpIHsKICAgIC8vIHNpZ25lciBpcyB0aGUgcGFyZW50IGFjY291bnQKICAgIC8vIGdldCB0aGUgbWFuYWdlciByZXNvdXJjZSBhbmQgYm9ycm93IGNoaWxkQWNjb3VudAogICAgbGV0IG0gPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChIeWJyaWRDdXN0b2R5Lk1hbmFnZSkgJkh5YnJpZEN1c3RvZHkuTWFuYWdlcj4oZnJvbTogSHlicmlkQ3VzdG9keS5NYW5hZ2VyU3RvcmFnZVBhdGgpCiAgICAgICAgPz8gcGFuaWMoIm1hbmFnZXIgZG9lcyBub3QgZXhpc3QiKQogICAgbGV0IGNoaWxkQWNjdCA9IG0uYm9ycm93QWNjb3VudChhZGRyOiBjaGlsZEFkZHIpID8/IHBhbmljKCJjaGlsZCBhY2NvdW50IG5vdCBmb3VuZCIpCiAgICAKICAgIGxldCBjb2xsZWN0aW9uRGF0YSA9IDxORlQ+LnJlc29sdmVDb250cmFjdFZpZXcocmVzb3VyY2VUeXBlOiBuaWwsIHZpZXdUeXBlOiBUeXBlPE1ldGFkYXRhVmlld3MuTkZUQ29sbGVjdGlvbkRhdGE+KCkpIGFzISBNZXRhZGF0YVZpZXdzLk5GVENvbGxlY3Rpb25EYXRhPwogICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgZ2V0IHRoZSB2YXVsdCBkYXRhIHZpZXcgZm9yIDxORlQ+ICIpCgogICAgLy9nZXQgRnQgY2FwIGZyb20gY2hpbGQgYWNjb3VudAogICAgbGV0IGNhcFR5cGUgPSBUeXBlPGF1dGgoTm9uRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntOb25GdW5naWJsZVRva2VuLlByb3ZpZGVyfT4oKQogICAgbGV0IGNvbnRyb2xsZXJJRCA9IGNoaWxkQWNjdC5nZXRDb250cm9sbGVySURGb3JUeXBlKHR5cGU6IGNhcFR5cGUsIGZvclBhdGg6IGNvbGxlY3Rpb25EYXRhLnN0b3JhZ2VQYXRoKQogICAgICAgID8/IHBhbmljKCJubyBjb250cm9sbGVyIGZvdW5kIGZvciBjYXBUeXBlIikKICAgIAogICAgbGV0IGNhcCA9IGNoaWxkQWNjdC5nZXRDYXBhYmlsaXR5KGNvbnRyb2xsZXJJRDogY29udHJvbGxlcklELCB0eXBlOiBjYXBUeXBlKSA/PyBwYW5pYygibm8gY2FwIGZvdW5kIikKICAgIGxldCBjaGlsZENhcCA9IGNhcCBhcyEgQ2FwYWJpbGl0eTwme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvblB1YmxpY30+CiAgICBhc3NlcnQoY2hpbGRDYXAuY2hlY2soKSwgbWVzc2FnZTogImludmFsaWQgcHJvdmlkZXIgY2FwYWJpbGl0eSIpCiAgICAKICAgIGxldCBwYXJlbnRSZWYgPSAgc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoTm9uRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntOb25GdW5naWJsZVRva2VuLlByb3ZpZGVyfT4oZnJvbSA6IGNvbGxlY3Rpb25EYXRhLnN0b3JhZ2VQYXRoKSEKICAgIGxldCBjaGlsZFJlZiA9IGNoaWxkQ2FwLmJvcnJvdygpIQoKICAgIGZvciBpZCBpbiBpZHMgeyAgICAgCiAgICAgICAgLy8gV2l0aGRyYXcgdG9rZW5zIGZyb20gdGhlIHNpZ25lcidzIHN0b3JlZCB2YXVsdAogICAgICAgIGxldCBuZnQgPC0gcGFyZW50UmVmIS53aXRoZHJhdyh3aXRoZHJhd0lEOiBpZCkhCiAgICAgICAgY2hpbGRSZWYuZGVwb3NpdCh0b2tlbjogPC0gbmZ0KQogICAgfQogIH0KfQ\u003d\u003d", + "bridgeChildFTFromEvm": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYnJpZGdlQ2hpbGRGVEZyb21Fdm0gLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgVmlld1Jlc29sdmVyIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4MWQ3ZTU3YWE1NTgxNzQ0OAoKCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHgxNjU0NjUzMzk5MDQwYTYxCgppbXBvcnQgRnVuZ2libGVUb2tlbk1ldGFkYXRhVmlld3MgZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKCgppbXBvcnQgU2NvcGVkRlRQcm92aWRlcnMgZnJvbSAweDFlNGFhMGI4N2QxMGIxNDEKCgppbXBvcnQgRVZNIGZyb20gMHhlNDY3YjlkZDExZmEwMGRmCgoKaW1wb3J0IEZsb3dFVk1CcmlkZ2VVdGlscyBmcm9tIDB4MWU0YWEwYjg3ZDEwYjE0MQoKaW1wb3J0IEZsb3dFVk1CcmlkZ2UgZnJvbSAweDFlNGFhMGI4N2QxMGIxNDEKCmltcG9ydCBGbG93RVZNQnJpZGdlQ29uZmlnIGZyb20gMHgxZTRhYTBiODdkMTBiMTQxCgoKCmltcG9ydCBIeWJyaWRDdXN0b2R5IGZyb20gMHhkOGE3ZTA1YTdhYzY3MGMwCgppbXBvcnQgQ2FwYWJpbGl0eUZpbHRlciBmcm9tIDB4ZDhhN2UwNWE3YWM2NzBjMAoKCnRyYW5zYWN0aW9uKHZhdWx0SWRlbnRpZmllcjogU3RyaW5nLCBjaGlsZDogQWRkcmVzcywgYW1vdW50OiBVSW50MjU2KSB7CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChCb3Jyb3dWYWx1ZSwgQ29weVZhbHVlLCBJc3N1ZVN0b3JhZ2VDYXBhYmlsaXR5Q29udHJvbGxlciwgUHVibGlzaENhcGFiaWxpdHksIFNhdmVWYWx1ZSwgVW5wdWJsaXNoQ2FwYWJpbGl0eSkgJkFjY291bnQpIHsKICAgICAgICAvLyBCb3Jyb3cgYSByZWZlcmVuY2UgdG8gdGhlIHNpZ25lcidzIENPQQogICAgICAgIGxldCBjb2EgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChFVk0uQnJpZGdlKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KGZyb206IC9zdG9yYWdlL2V2bSkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgQ09BIGZyb20gcHJvdmlkZWQgZ2F0ZXdheSBhZGRyZXNzIikKICAgICAgICBsZXQgdmF1bHRUeXBlID0gQ29tcG9zaXRlVHlwZSh2YXVsdElkZW50aWZpZXIpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgY29uc3RydWN0IFZhdWx0IHR5cGUgZnJvbSBpZGVudGlmaWVyOiAiLmNvbmNhdCh2YXVsdElkZW50aWZpZXIpKQogICAgICAgIC8vIFBhcnNlIHRoZSBWYXVsdCBpZGVudGlmaWVyIGludG8gaXRzIGNvbXBvbmVudHMKICAgICAgICBsZXQgdG9rZW5Db250cmFjdEFkZHJlc3MgPSBGbG93RVZNQnJpZGdlVXRpbHMuZ2V0Q29udHJhY3RBZGRyZXNzKGZyb21UeXBlOiB2YXVsdFR5cGUpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgZ2V0IGNvbnRyYWN0IGFkZHJlc3MgZnJvbSBpZGVudGlmaWVyOiAiLmNvbmNhdCh2YXVsdElkZW50aWZpZXIpKQogICAgICAgIGxldCB0b2tlbkNvbnRyYWN0TmFtZSA9IEZsb3dFVk1CcmlkZ2VVdGlscy5nZXRDb250cmFjdE5hbWUoZnJvbVR5cGU6IHZhdWx0VHlwZSkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBnZXQgY29udHJhY3QgbmFtZSBmcm9tIGlkZW50aWZpZXI6ICIuY29uY2F0KHZhdWx0SWRlbnRpZmllcikpCgogICAgICAgIC8qIC0tLSBSZXRyaWV2ZSB0aGUgZnVuZHMgLS0tICovCiAgICAgICAgLy8KICAgICAgICAvLyBCb3Jyb3cgYSByZWZlcmVuY2UgdG8gdGhlIEZ1bmdpYmxlVG9rZW4gVmF1bHQKICAgICAgICBsZXQgdmlld1Jlc29sdmVyID0gZ2V0QWNjb3VudCh0b2tlbkNvbnRyYWN0QWRkcmVzcykuY29udHJhY3RzLmJvcnJvdzwme1ZpZXdSZXNvbHZlcn0+KG5hbWU6IHRva2VuQ29udHJhY3ROYW1lKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBWaWV3UmVzb2x2ZXIgZnJvbSBGdW5naWJsZVRva2VuIGNvbnRyYWN0IikKICAgICAgICBsZXQgdmF1bHREYXRhID0gdmlld1Jlc29sdmVyLnJlc29sdmVDb250cmFjdFZpZXcoCiAgICAgICAgICAgICAgICByZXNvdXJjZVR5cGU6IG5pbCwKICAgICAgICAgICAgICAgIHZpZXdUeXBlOiBUeXBlPEZ1bmdpYmxlVG9rZW5NZXRhZGF0YVZpZXdzLkZUVmF1bHREYXRhPigpCiAgICAgICAgICAgICkgYXMhIEZ1bmdpYmxlVG9rZW5NZXRhZGF0YVZpZXdzLkZUVmF1bHREYXRhPyA/PyBwYW5pYygiQ291bGQgbm90IHJlc29sdmUgRlRWYXVsdERhdGEgdmlldyIpCgogICAgICAgIC8vIHNpZ25lciBpcyB0aGUgcGFyZW50IGFjY291bnQKICAgICAgICAvLyBnZXQgdGhlIG1hbmFnZXIgcmVzb3VyY2UgYW5kIGJvcnJvdyBjaGlsZEFjY291bnQKICAgICAgICBsZXQgbSA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEh5YnJpZEN1c3RvZHkuTWFuYWdlKSAmSHlicmlkQ3VzdG9keS5NYW5hZ2VyPihmcm9tOiBIeWJyaWRDdXN0b2R5Lk1hbmFnZXJTdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIm1hbmFnZXIgZG9lcyBub3QgZXhpc3QiKQogICAgICAgIGxldCBjaGlsZEFjY3QgPSBtLmJvcnJvd0FjY291bnQoYWRkcjogY2hpbGQpID8/IHBhbmljKCJjaGlsZCBhY2NvdW50IG5vdCBmb3VuZCIpCiAgICAgICAgCiAgICAgCiAgICAgICAgLy9nZXQgRnQgY2FwIGZyb20gY2hpbGQgYWNjb3VudAogICAgICAgIGxldCBjYXBUeXBlID0gVHlwZTwme0Z1bmdpYmxlVG9rZW4uUmVjZWl2ZXJ9PigpCiAgICAgICAgbGV0IGNvbnRyb2xsZXJJRCA9IGNoaWxkQWNjdC5nZXRDb250cm9sbGVySURGb3JUeXBlKHR5cGU6IGNhcFR5cGUsIGZvclBhdGg6IHZhdWx0RGF0YS5zdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIm5vIGNvbnRyb2xsZXIgZm91bmQgZm9yIGNhcFR5cGUiKQogICAgICAgIAogICAgICAgIGxldCBjYXAgPSBjaGlsZEFjY3QuZ2V0Q2FwYWJpbGl0eShjb250cm9sbGVySUQ6IGNvbnRyb2xsZXJJRCwgdHlwZTogY2FwVHlwZSkgPz8gcGFuaWMoIm5vIGNhcCBmb3VuZCIpCiAgICAgICAgbGV0IHByb3ZpZGVyQ2FwID0gY2FwIGFzISBDYXBhYmlsaXR5PCZ7RnVuZ2libGVUb2tlbi5SZWNlaXZlcn0+CiAgICAgICAgYXNzZXJ0KHByb3ZpZGVyQ2FwLmNoZWNrKCksIG1lc3NhZ2U6ICJpbnZhbGlkIHByb3ZpZGVyIGNhcGFiaWxpdHkiKQogICAgICAgIAogICAgICAgIC8vIEdldCBhIHJlZmVyZW5jZSB0byB0aGUgY2hpbGQncyBzdG9yZWQgdmF1bHQKICAgICAgICBsZXQgdmF1bHRSZWYgPSBwcm92aWRlckNhcC5ib3Jyb3coKSEKCiAgICAgIAogICAgICAgIGxldCBhcHByb3hGZWUgPSBGbG93RVZNQnJpZGdlVXRpbHMuY2FsY3VsYXRlQnJpZGdlRmVlKGJ5dGVzOiA0MDBfMDAwKQogICAgICAgIC8qIC0tLSBDb25maWd1cmUgYSBTY29wZWRGVFByb3ZpZGVyIC0tLSAqLwogICAgICAgIC8vCiAgICAgICAgLy8gSXNzdWUgYW5kIHN0b3JlIGJyaWRnZS1kZWRpY2F0ZWQgUHJvdmlkZXIgQ2FwYWJpbGl0eSBpbiBzdG9yYWdlIGlmIG5lY2Vzc2FyeQogICAgICAgIGlmIHNpZ25lci5zdG9yYWdlLnR5cGUoYXQ6IEZsb3dFVk1CcmlkZ2VDb25maWcucHJvdmlkZXJDYXBhYmlsaXR5U3RvcmFnZVBhdGgpID09IG5pbCB7CiAgICAgICAgICAgIGxldCBwcm92aWRlckNhcCA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+KAogICAgICAgICAgICAgICAgL3N0b3JhZ2UvZmxvd1Rva2VuVmF1bHQKICAgICAgICAgICAgKQogICAgICAgICAgICBzaWduZXIuc3RvcmFnZS5zYXZlKHByb3ZpZGVyQ2FwLCB0bzogRmxvd0VWTUJyaWRnZUNvbmZpZy5wcm92aWRlckNhcGFiaWxpdHlTdG9yYWdlUGF0aCkKICAgICAgICB9CiAgICAgICAgLy8gQ29weSB0aGUgc3RvcmVkIFByb3ZpZGVyIGNhcGFiaWxpdHkgYW5kIGNyZWF0ZSBhIFNjb3BlZEZUUHJvdmlkZXIKICAgICAgICBsZXQgcHJvdmlkZXJDYXBDb3B5ID0gc2lnbmVyLnN0b3JhZ2UuY29weTxDYXBhYmlsaXR5PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntGdW5naWJsZVRva2VuLlByb3ZpZGVyfT4+KAogICAgICAgICAgICAgICAgZnJvbTogRmxvd0VWTUJyaWRnZUNvbmZpZy5wcm92aWRlckNhcGFiaWxpdHlTdG9yYWdlUGF0aAogICAgICAgICAgICApID8/IHBhbmljKCJJbnZhbGlkIFByb3ZpZGVyIENhcGFiaWxpdHkgZm91bmQgaW4gc3RvcmFnZS4iKQogICAgICAgIGxldCBwcm92aWRlckZpbHRlciA9IFNjb3BlZEZUUHJvdmlkZXJzLkFsbG93YW5jZUZpbHRlcihhcHByb3hGZWUpCiAgICAgICAgbGV0IHNjb3BlZFByb3ZpZGVyIDwtIFNjb3BlZEZUUHJvdmlkZXJzLmNyZWF0ZVNjb3BlZEZUUHJvdmlkZXIoCiAgICAgICAgICAgIHByb3ZpZGVyOiBwcm92aWRlckNhcENvcHksCiAgICAgICAgICAgIGZpbHRlcnM6IFsgcHJvdmlkZXJGaWx0ZXIgXSwKICAgICAgICAgICAgZXhwaXJhdGlvbjogZ2V0Q3VycmVudEJsb2NrKCkudGltZXN0YW1wICsgMS4wCiAgICAgICAgKQoKICAgICAgICBsZXQgdmF1bHQ6IEB7RnVuZ2libGVUb2tlbi5WYXVsdH0gPC0gY29hLndpdGhkcmF3VG9rZW5zKAogICAgICAgICAgICB0eXBlOiB2YXVsdFR5cGUsCiAgICAgICAgICAgIGFtb3VudDogYW1vdW50LAogICAgICAgICAgICBmZWVQcm92aWRlcjogJnNjb3BlZFByb3ZpZGVyIGFzIGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntGdW5naWJsZVRva2VuLlByb3ZpZGVyfQogICAgICAgICkKCiAgICAgICAgdmF1bHRSZWYuZGVwb3NpdChmcm9tOiA8LSB2YXVsdCkKICAgICAgICBkZXN0cm95IHNjb3BlZFByb3ZpZGVyCiAgICB9Cgp9CiA\u003d", + "bridgeChildFTToEvm": "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\u003d\u003d", + "bridgeChildFTToEvmAddress": "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\u003d", + "bridgeChildNFTFromEvm": "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\u003d", + "bridgeChildNFTToEvm": "// Flow Wallet - mainnet Script  bridgeChildNFTToEvm - v2.78
// <platform_info>

import MetadataViews from 0x1d7e57aa55817448

import ViewResolver from 0x1d7e57aa55817448

import NonFungibleToken from 0x1d7e57aa55817448

import FungibleToken from 0xf233dcee88fe0abe

import FlowToken from 0x1654653399040a61

import FungibleTokenMetadataViews from 0xf233dcee88fe0abe

import ScopedFTProviders from 0x1e4aa0b87d10b141

import EVM from 0xe467b9dd11fa00df

import FlowEVMBridgeUtils from 0x1e4aa0b87d10b141

import FlowEVMBridge from 0x1e4aa0b87d10b141

import FlowEVMBridgeConfig from 0x1e4aa0b87d10b141

import HybridCustody from 0xd8a7e05a7ac670c0

import CapabilityFilter from 0xd8a7e05a7ac670c0

import CrossVMMetadataViews from 0x1d7e57aa55817448


transaction(nftIdentifier: String, id: UInt64, child: Address) {

    let nft: @{NonFungibleToken.NFT}
    let coa: auth(EVM.Bridge, EVM.Call) &EVM.CadenceOwnedAccount
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let nftType: Type
    let viewResolver: &{ViewResolver}
    prepare(signer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, Capabilities, SaveValue) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        let m = signer.storage.borrow<auth(HybridCustody.Manage) &HybridCustody.Manager>(from: HybridCustody.ManagerStoragePath)
            ?? panic("manager does not exist")
        let childAcct = m.borrowAccount(addr: child) ?? panic("child account not found")

         // Construct the NFT type from the provided identifier
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: self.nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Retrieve the NFT --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: nil,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        var collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            )

        // Create collection if it doesn't exist
        if collection == nil {
            signer.storage.save(<- collectionData.createEmptyCollection(), to: collectionData.storagePath)
            signer.capabilities.unpublish(collectionData.publicPath)
            signer.capabilities.publish(
                signer.capabilities.storage.issue<&{NonFungibleToken.Collection}>(collectionData.storagePath),
                at: collectionData.publicPath
            )

            // Borrow authorized withdraw reference to the signer's collection
            collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            )!
        }

        let capType = Type<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider}>()
        let controllerID = childAcct.getControllerIDForType(type: capType, forPath: collectionData.storagePath)
            ?? panic("no controller found for capType")

        let cap = childAcct.getCapability(controllerID: controllerID, type: capType) ?? panic("no cap found")
        let providerCap = cap as! Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider}>
        assert(providerCap.check(), message: "invalid provider capability")

        // Get a reference to the child's stored vault
        let collectionRef = providerCap.borrow()!
        let childNft <- collectionRef.withdraw(withdrawID: id)
        collection!.deposit(token: <-childNft)
        // // Withdraw tokens from the signer's stored vault
        let currentStorageUsage = signer.storage.used
        self.nft <- collection!.withdraw(withdrawID: id)
        let withdrawnStorageUsage = signer.storage.used
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(
                bytes: 400_000
            )

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    execute {
        // Execute the bridge
        self.coa.depositNFT(
            nft: <-self.nft,
            feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        // Destroy the ScopedFTProvider
        destroy self.scopedProvider

        // Wrap NFTs if applicable
        wrapAndTransferNFTsIfApplicable(
            self.coa,
            nftIDs: [id],
            nftType: self.nftType,
            viewResolver: self.viewResolver,
            recipientIfNotCoa: nil
        )
    }
}

/// Wraps and transfers bridged NFTs into a project's custom ERC721 wrapper contract on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
/// @param recipientIfNotCoa: The EVM address to transfer the wrapped NFTs to, nil if the NFTs should stay in signer's COA
///
access(all) fun wrapAndTransferNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt64],
    nftType: Type,
    viewResolver: &{ViewResolver},
    recipientIfNotCoa: EVM.EVMAddress?
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            // Wrap NFTs if underlying ERC721 address matches bridge's associated address for NFT type
            if underlyingAddress.equals(FlowEVMBridgeConfig.getEVMAddressAssociated(with: nftType)!) {
                // Approve contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, true]
                )

                // Wrap NFTs with provided IDs, and check if the call was successful
                let res = mustCall(coa, crossVMPointer.evmContractAddress,
                    functionSig: "depositFor(address,uint256[])",
                    args: [coa.address(), nftIDs]
                )
                let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                assert(decodedRes.length == 1, message: "Invalid response length")
                assert(decodedRes[0] as! Bool, message: "Failed to wrap NFTs")

                // Transfer NFTs to recipient if provided
                if let to = recipientIfNotCoa {
                    mustTransferNFTs(coa, crossVMPointer.evmContractAddress, nftIDs: nftIDs, to: to)
                }

                // Revoke approval for contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, false]
                )
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is owned by the provided EVM address
///
access(all) fun isOwner(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    _ nftID: UInt64,
    _ ownerToCheck: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: erc721Address,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )
    assert(res.status == EVM.Status.successful, message: "Call to ERC721.ownerOf(uint256) failed")
    let decodedRes = EVM.decodeABI(types: [Type<EVM.EVMAddress>()], data: res.data)
    if decodedRes.length == 1 {
        let actualOwner = decodedRes[0] as! EVM.EVMAddress
        return actualOwner.equals(ownerToCheck)
    }
    return false
}

/// Transfers NFTs from the provided COA to the provided EVM address
///
access(all) fun mustTransferNFTs(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    nftIDs: [UInt64],
    to: EVM.EVMAddress
) {
    for id in nftIDs {
        assert(isOwner(coa, erc721Address, id, coa.address()), message: "NFT not owned by signer's COA")
        mustCall(coa, erc721Address,
            functionSig: "safeTransferFrom(address,address,uint256)",
            args: [coa.address(), to, id]
        )
        assert(isOwner(coa, erc721Address, id, to), message: "NFT not transferred to recipient")
    }
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", + "bridgeChildNFTToEvmAddress": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYnJpZGdlQ2hpbGRORlRUb0V2bUFkZHJlc3MgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgVmlld1Jlc29sdmVyIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4MWQ3ZTU3YWE1NTgxNzQ0OAoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDE2NTQ2NTMzOTkwNDBhNjEKCmltcG9ydCBGdW5naWJsZVRva2VuTWV0YWRhdGFWaWV3cyBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKaW1wb3J0IFNjb3BlZEZUUHJvdmlkZXJzIGZyb20gMHgxZTRhYTBiODdkMTBiMTQxCgppbXBvcnQgRVZNIGZyb20gMHhlNDY3YjlkZDExZmEwMGRmCgppbXBvcnQgRmxvd0VWTUJyaWRnZVV0aWxzIGZyb20gMHgxZTRhYTBiODdkMTBiMTQxCgppbXBvcnQgRmxvd0VWTUJyaWRnZSBmcm9tIDB4MWU0YWEwYjg3ZDEwYjE0MQoKaW1wb3J0IEZsb3dFVk1CcmlkZ2VDb25maWcgZnJvbSAweDFlNGFhMGI4N2QxMGIxNDEKCmltcG9ydCBIeWJyaWRDdXN0b2R5IGZyb20gMHhkOGE3ZTA1YTdhYzY3MGMwCgppbXBvcnQgQ2FwYWJpbGl0eUZpbHRlciBmcm9tIDB4ZDhhN2UwNWE3YWM2NzBjMAoKaW1wb3J0IENyb3NzVk1NZXRhZGF0YVZpZXdzIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgoKdHJhbnNhY3Rpb24obmZ0SWRlbnRpZmllcjogU3RyaW5nLCBjaGlsZDogQWRkcmVzcywgaWQ6IFVJbnQ2NCwgcmVjaXBpZW50OlN0cmluZykgewoKICAgIGxldCBuZnQ6IEB7Tm9uRnVuZ2libGVUb2tlbi5ORlR9CiAgICBsZXQgY29hOiBhdXRoKEVWTS5DYWxsKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQKICAgIGxldCBzY29wZWRQcm92aWRlcjogQFNjb3BlZEZUUHJvdmlkZXJzLlNjb3BlZEZUUHJvdmlkZXIKICAgIGxldCBuZnRUeXBlOiBUeXBlCiAgICBsZXQgdmlld1Jlc29sdmVyOiAme1ZpZXdSZXNvbHZlcn0KCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChDb3B5VmFsdWUsIEJvcnJvd1ZhbHVlLCBJc3N1ZVN0b3JhZ2VDYXBhYmlsaXR5Q29udHJvbGxlciwgQ2FwYWJpbGl0aWVzLCBTYXZlVmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgLy8gUmV0cmlldmUgb3IgY3JlYXRlIENPQQogICAgICAgIGlmIGxldCBjb2EgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChFVk0uQ2FsbCkgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50Pihmcm9tOiAvc3RvcmFnZS9ldm0pIHsKICAgICAgICAgICAgc2VsZi5jb2EgPSBjb2EKICAgICAgICB9IGVsc2UgewogICAgICAgICAgICBzaWduZXIuc3RvcmFnZS5zYXZlPEBFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oPC0gRVZNLmNyZWF0ZUNhZGVuY2VPd25lZEFjY291bnQoKSwgdG86IC9zdG9yYWdlL2V2bSkKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5wdWJsaXNoKAogICAgICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5zdG9yYWdlLmlzc3VlPCZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oL3N0b3JhZ2UvZXZtKSwKICAgICAgICAgICAgICAgIGF0OiAvcHVibGljL2V2bQogICAgICAgICAgICApCiAgICAgICAgICAgIHNlbGYuY29hID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoRVZNLkNhbGwpICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oZnJvbTogL3N0b3JhZ2UvZXZtKSEKICAgICAgICB9CgogICAgICAgIC8vIFJldHJpZXZlIG9yIGNyZWF0ZSBjaGlsZCBhY2NvdW50CiAgICAgICAgbGV0IG0gPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChIeWJyaWRDdXN0b2R5Lk1hbmFnZSkgJkh5YnJpZEN1c3RvZHkuTWFuYWdlcj4oZnJvbTogSHlicmlkQ3VzdG9keS5NYW5hZ2VyU3RvcmFnZVBhdGgpCiAgICAgICAgICAgID8/IHBhbmljKCJtYW5hZ2VyIGRvZXMgbm90IGV4aXN0IikKICAgICAgICBsZXQgY2hpbGRBY2N0ID0gbS5ib3Jyb3dBY2NvdW50KGFkZHI6IGNoaWxkKSA/PyBwYW5pYygiY2hpbGQgYWNjb3VudCBub3QgZm91bmQiKQoKICAgICAgICAgLy8gQ29uc3RydWN0IHRoZSBORlQgdHlwZSBmcm9tIHRoZSBwcm92aWRlZCBpZGVudGlmaWVyCiAgICAgICAgc2VsZi5uZnRUeXBlID0gQ29tcG9zaXRlVHlwZShuZnRJZGVudGlmaWVyKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGNvbnN0cnVjdCBORlQgdHlwZSBmcm9tIGlkZW50aWZpZXI6ICIuY29uY2F0KG5mdElkZW50aWZpZXIpKQogICAgICAgIGxldCBuZnRDb250cmFjdEFkZHJlc3MgPSBGbG93RVZNQnJpZGdlVXRpbHMuZ2V0Q29udHJhY3RBZGRyZXNzKGZyb21UeXBlOiBzZWxmLm5mdFR5cGUpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgZ2V0IGNvbnRyYWN0IGFkZHJlc3MgZnJvbSBpZGVudGlmaWVyOiAiLmNvbmNhdChuZnRJZGVudGlmaWVyKSkKICAgICAgICBsZXQgbmZ0Q29udHJhY3ROYW1lID0gRmxvd0VWTUJyaWRnZVV0aWxzLmdldENvbnRyYWN0TmFtZShmcm9tVHlwZTogc2VsZi5uZnRUeXBlKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGdldCBjb250cmFjdCBuYW1lIGZyb20gaWRlbnRpZmllcjogIi5jb25jYXQobmZ0SWRlbnRpZmllcikpCgogICAgICAgIC8qIC0tLSBSZXRyaWV2ZSB0aGUgTkZUIC0tLSAqLwogICAgICAgIC8vCiAgICAgICAgLy8gQm9ycm93IGEgcmVmZXJlbmNlIHRvIHRoZSBORlQgY29sbGVjdGlvbiwgY29uZmlndXJpbmcgaWYgbmVjZXNzYXJ5CiAgICAgICAgc2VsZi52aWV3UmVzb2x2ZXIgPSBnZXRBY2NvdW50KG5mdENvbnRyYWN0QWRkcmVzcykuY29udHJhY3RzLmJvcnJvdzwme1ZpZXdSZXNvbHZlcn0+KG5hbWU6IG5mdENvbnRyYWN0TmFtZSkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgVmlld1Jlc29sdmVyIGZyb20gTkZUIGNvbnRyYWN0IikKICAgICAgICBsZXQgY29sbGVjdGlvbkRhdGEgPSBzZWxmLnZpZXdSZXNvbHZlci5yZXNvbHZlQ29udHJhY3RWaWV3KAogICAgICAgICAgICAgICAgcmVzb3VyY2VUeXBlOiBuaWwsCiAgICAgICAgICAgICAgICB2aWV3VHlwZTogVHlwZTxNZXRhZGF0YVZpZXdzLk5GVENvbGxlY3Rpb25EYXRhPigpCiAgICAgICAgICAgICkgYXMhIE1ldGFkYXRhVmlld3MuTkZUQ29sbGVjdGlvbkRhdGE/ID8/IHBhbmljKCJDb3VsZCBub3QgcmVzb2x2ZSBORlRDb2xsZWN0aW9uRGF0YSB2aWV3IikKICAgICAgICB2YXIgY29sbGVjdGlvbiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKE5vbkZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7Tm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9ufT4oCiAgICAgICAgICAgICAgICBmcm9tOiBjb2xsZWN0aW9uRGF0YS5zdG9yYWdlUGF0aAogICAgICAgICAgICApCgogICAgICAgIC8vIENyZWF0ZSBjb2xsZWN0aW9uIGlmIGl0IGRvZXNuJ3QgZXhpc3QKICAgICAgICBpZiBjb2xsZWN0aW9uID09IG5pbCB7CiAgICAgICAgICAgIHNpZ25lci5zdG9yYWdlLnNhdmUoPC0gY29sbGVjdGlvbkRhdGEuY3JlYXRlRW1wdHlDb2xsZWN0aW9uKCksIHRvOiBjb2xsZWN0aW9uRGF0YS5zdG9yYWdlUGF0aCkKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy51bnB1Ymxpc2goY29sbGVjdGlvbkRhdGEucHVibGljUGF0aCkKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5wdWJsaXNoKAogICAgICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5zdG9yYWdlLmlzc3VlPCZ7Tm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9ufT4oY29sbGVjdGlvbkRhdGEuc3RvcmFnZVBhdGgpLAogICAgICAgICAgICAgICAgYXQ6IGNvbGxlY3Rpb25EYXRhLnB1YmxpY1BhdGgKICAgICAgICAgICAgKQoKICAgICAgICAgICAgLy8gQm9ycm93IGF1dGhvcml6ZWQgd2l0aGRyYXcgcmVmZXJlbmNlIHRvIHRoZSBzaWduZXIncyBjb2xsZWN0aW9uCiAgICAgICAgICAgIGNvbGxlY3Rpb24gPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChOb25GdW5naWJsZVRva2VuLldpdGhkcmF3KSAme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0+KAogICAgICAgICAgICAgICAgZnJvbTogY29sbGVjdGlvbkRhdGEuc3RvcmFnZVBhdGgKICAgICAgICAgICAgKSEKICAgICAgICB9CgoKICAgICAgICBsZXQgY2FwVHlwZSA9IFR5cGU8YXV0aChOb25GdW5naWJsZVRva2VuLldpdGhkcmF3KSAme05vbkZ1bmdpYmxlVG9rZW4uUHJvdmlkZXJ9PigpCiAgICAgICAgbGV0IGNvbnRyb2xsZXJJRCA9IGNoaWxkQWNjdC5nZXRDb250cm9sbGVySURGb3JUeXBlKHR5cGU6IGNhcFR5cGUsIGZvclBhdGg6IGNvbGxlY3Rpb25EYXRhLnN0b3JhZ2VQYXRoKQogICAgICAgICAgICA/PyBwYW5pYygibm8gY29udHJvbGxlciBmb3VuZCBmb3IgY2FwVHlwZSIpCgogICAgICAgIGxldCBjYXAgPSBjaGlsZEFjY3QuZ2V0Q2FwYWJpbGl0eShjb250cm9sbGVySUQ6IGNvbnRyb2xsZXJJRCwgdHlwZTogY2FwVHlwZSkgPz8gcGFuaWMoIm5vIGNhcCBmb3VuZCIpCiAgICAgICAgbGV0IHByb3ZpZGVyQ2FwID0gY2FwIGFzISBDYXBhYmlsaXR5PGF1dGgoTm9uRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntOb25GdW5naWJsZVRva2VuLlByb3ZpZGVyfT4KICAgICAgICBhc3NlcnQocHJvdmlkZXJDYXAuY2hlY2soKSwgbWVzc2FnZTogImludmFsaWQgcHJvdmlkZXIgY2FwYWJpbGl0eSIpCgogICAgICAgIC8vIEdldCBhIHJlZmVyZW5jZSB0byB0aGUgY2hpbGQncyBzdG9yZWQgdmF1bHQKICAgICAgICBsZXQgY29sbGVjdGlvblJlZiA9IHByb3ZpZGVyQ2FwLmJvcnJvdygpIQogICAgICAgIGxldCBjaGlsZE5mdCA8LSBjb2xsZWN0aW9uUmVmLndpdGhkcmF3KHdpdGhkcmF3SUQ6IGlkKQogICAgICAgIGNvbGxlY3Rpb24hLmRlcG9zaXQodG9rZW46IDwtY2hpbGROZnQpCiAgICAgICAgLy8gLy8gV2l0aGRyYXcgdG9rZW5zIGZyb20gdGhlIHNpZ25lcidzIHN0b3JlZCB2YXVsdAogICAgICAgIGxldCBjdXJyZW50U3RvcmFnZVVzYWdlID0gc2lnbmVyLnN0b3JhZ2UudXNlZAogICAgICAgIHNlbGYubmZ0IDwtIGNvbGxlY3Rpb24hLndpdGhkcmF3KHdpdGhkcmF3SUQ6IGlkKQogICAgICAgIGxldCB3aXRoZHJhd25TdG9yYWdlVXNhZ2UgPSBzaWduZXIuc3RvcmFnZS51c2VkCiAgICAgICAgbGV0IGFwcHJveEZlZSA9IEZsb3dFVk1CcmlkZ2VVdGlscy5jYWxjdWxhdGVCcmlkZ2VGZWUoCiAgICAgICAgICAgICAgICBieXRlczogNDAwXzAwMAogICAgICAgICAgICApCgogICAgICAgIC8qIC0tLSBDb25maWd1cmUgYSBTY29wZWRGVFByb3ZpZGVyIC0tLSAqLwogICAgICAgIC8vCiAgICAgICAgLy8gSXNzdWUgYW5kIHN0b3JlIGJyaWRnZS1kZWRpY2F0ZWQgUHJvdmlkZXIgQ2FwYWJpbGl0eSBpbiBzdG9yYWdlIGlmIG5lY2Vzc2FyeQogICAgICAgIGlmIHNpZ25lci5zdG9yYWdlLnR5cGUoYXQ6IEZsb3dFVk1CcmlkZ2VDb25maWcucHJvdmlkZXJDYXBhYmlsaXR5U3RvcmFnZVBhdGgpID09IG5pbCB7CiAgICAgICAgICAgIGxldCBwcm92aWRlckNhcCA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+KAogICAgICAgICAgICAgICAgL3N0b3JhZ2UvZmxvd1Rva2VuVmF1bHQKICAgICAgICAgICAgKQogICAgICAgICAgICBzaWduZXIuc3RvcmFnZS5zYXZlKHByb3ZpZGVyQ2FwLCB0bzogRmxvd0VWTUJyaWRnZUNvbmZpZy5wcm92aWRlckNhcGFiaWxpdHlTdG9yYWdlUGF0aCkKICAgICAgICB9CgogICAgICAgIC8vIENvcHkgdGhlIHN0b3JlZCBQcm92aWRlciBjYXBhYmlsaXR5IGFuZCBjcmVhdGUgYSBTY29wZWRGVFByb3ZpZGVyCiAgICAgICAgbGV0IHByb3ZpZGVyQ2FwQ29weSA9IHNpZ25lci5zdG9yYWdlLmNvcHk8Q2FwYWJpbGl0eTxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+PigKICAgICAgICAgICAgICAgIGZyb206IEZsb3dFVk1CcmlkZ2VDb25maWcucHJvdmlkZXJDYXBhYmlsaXR5U3RvcmFnZVBhdGgKICAgICAgICAgICAgKSA/PyBwYW5pYygiSW52YWxpZCBQcm92aWRlciBDYXBhYmlsaXR5IGZvdW5kIGluIHN0b3JhZ2UuIikKICAgICAgICBsZXQgcHJvdmlkZXJGaWx0ZXIgPSBTY29wZWRGVFByb3ZpZGVycy5BbGxvd2FuY2VGaWx0ZXIoYXBwcm94RmVlKQogICAgICAgIHNlbGYuc2NvcGVkUHJvdmlkZXIgPC0gU2NvcGVkRlRQcm92aWRlcnMuY3JlYXRlU2NvcGVkRlRQcm92aWRlcigKICAgICAgICAgICAgICAgIHByb3ZpZGVyOiBwcm92aWRlckNhcENvcHksCiAgICAgICAgICAgICAgICBmaWx0ZXJzOiBbIHByb3ZpZGVyRmlsdGVyIF0sCiAgICAgICAgICAgICAgICBleHBpcmF0aW9uOiBnZXRDdXJyZW50QmxvY2soKS50aW1lc3RhbXAgKyAxLjAKICAgICAgICAgICAgKQogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIC8vIEV4ZWN1dGUgdGhlIGJyaWRnZQogICAgICAgIHNlbGYuY29hLmRlcG9zaXRORlQoCiAgICAgICAgICAgIG5mdDogPC0gc2VsZi5uZnQsCiAgICAgICAgICAgIGZlZVByb3ZpZGVyOiAmc2VsZi5zY29wZWRQcm92aWRlciBhcyBhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0KICAgICAgICApCgogICAgICAgIC8vIERlc3Ryb3kgdGhlIFNjb3BlZEZUUHJvdmlkZXIKICAgICAgICBkZXN0cm95IHNlbGYuc2NvcGVkUHJvdmlkZXIKCiAgICAgICAgLy8gV3JhcCBhbmQgdHJhbnNmZXIgTkZUcyBpZiBhcHBsaWNhYmxlCiAgICAgICAgd3JhcEFuZFRyYW5zZmVyTkZUc0lmQXBwbGljYWJsZShzZWxmLmNvYSwKICAgICAgICAgICAgbmZ0SURzOiBbaWRdLAogICAgICAgICAgICBuZnRUeXBlOiBzZWxmLm5mdFR5cGUsCiAgICAgICAgICAgIHZpZXdSZXNvbHZlcjogc2VsZi52aWV3UmVzb2x2ZXIsCiAgICAgICAgICAgIHJlY2lwaWVudElmTm90Q29hOiBFVk0uYWRkcmVzc0Zyb21TdHJpbmcocmVjaXBpZW50KQogICAgICAgICkKICAgIH0KfQoKLy8vIFdyYXBzIGFuZCB0cmFuc2ZlcnMgYnJpZGdlZCBORlRzIGludG8gYSBwcm9qZWN0J3MgY3VzdG9tIEVSQzcyMSB3cmFwcGVyIGNvbnRyYWN0IG9uIEVWTSwgaWYgYXBwbGljYWJsZS4KLy8vIEVuYWJsZXMgcHJvamVjdHMgdG8gdXNlIHRoZWlyIG93biBFUkM3MjEgY29udHJhY3Qgd2hpbGUgbGV2ZXJhZ2luZyB0aGUgYnJpZGdlJ3MgdW5kZXJseWluZyBjb250cmFjdCwKLy8vIHVudGlsIGRpcmVjdCBjdXN0b20gY29udHJhY3Qgc3VwcG9ydCBpcyBhZGRlZCB0byB0aGUgYnJpZGdlLgovLy8KLy8vIEBwYXJhbSBjb2E6IFRoZSBDT0Egb2YgdGhlIHNpZ25lcgovLy8gQHBhcmFtIG5mdElEczogVGhlIElEcyBvZiB0aGUgTkZUcyB0byB3cmFwCi8vLyBAcGFyYW0gbmZ0VHlwZTogVGhlIHR5cGUgb2YgdGhlIE5GVHMgdG8gd3JhcAovLy8gQHBhcmFtIHZpZXdSZXNvbHZlcjogVGhlIFZpZXdSZXNvbHZlciBvZiB0aGUgTkZUIGNvbnRyYWN0Ci8vLyBAcGFyYW0gcmVjaXBpZW50SWZOb3RDb2E6IFRoZSBFVk0gYWRkcmVzcyB0byB0cmFuc2ZlciB0aGUgd3JhcHBlZCBORlRzIHRvLCBuaWwgaWYgdGhlIE5GVHMgc2hvdWxkIHN0YXkgaW4gc2lnbmVyJ3MgQ09BCi8vLwphY2Nlc3MoYWxsKSBmdW4gd3JhcEFuZFRyYW5zZmVyTkZUc0lmQXBwbGljYWJsZSgKICAgIF8gY29hOiBhdXRoKEVWTS5DYWxsKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQsCiAgICBuZnRJRHM6IFtVSW50NjRdLAogICAgbmZ0VHlwZTogVHlwZSwKICAgIHZpZXdSZXNvbHZlcjogJntWaWV3UmVzb2x2ZXJ9LAogICAgcmVjaXBpZW50SWZOb3RDb2E6IEVWTS5FVk1BZGRyZXNzPwopIHsKICAgIC8vIEdldCB0aGUgcHJvamVjdC1kZWZpbmVkIEVSQzcyMSBhZGRyZXNzIGlmIGl0IGV4aXN0cwogICAgaWYgbGV0IGNyb3NzVk1Qb2ludGVyID0gdmlld1Jlc29sdmVyLnJlc29sdmVDb250cmFjdFZpZXcoCiAgICAgICAgICAgIHJlc291cmNlVHlwZTogbmZ0VHlwZSwKICAgICAgICAgICAgdmlld1R5cGU6IFR5cGU8Q3Jvc3NWTU1ldGFkYXRhVmlld3MuRVZNUG9pbnRlcj4oKQogICAgKSBhcyEgQ3Jvc3NWTU1ldGFkYXRhVmlld3MuRVZNUG9pbnRlcj8gewogICAgICAgIC8vIEdldCB0aGUgdW5kZXJseWluZyBFUkM3MjEgYWRkcmVzcyBpZiBpdCBleGlzdHMKICAgICAgICBpZiBsZXQgdW5kZXJseWluZ0FkZHJlc3MgPSBnZXRVbmRlcmx5aW5nRVJDNzIxQWRkcmVzcyhjb2EsIGNyb3NzVk1Qb2ludGVyLmV2bUNvbnRyYWN0QWRkcmVzcykgewogICAgICAgICAgICAvLyBXcmFwIE5GVHMgaWYgdW5kZXJseWluZyBFUkM3MjEgYWRkcmVzcyBtYXRjaGVzIGJyaWRnZSdzIGFzc29jaWF0ZWQgYWRkcmVzcyBmb3IgTkZUIHR5cGUKICAgICAgICAgICAgaWYgdW5kZXJseWluZ0FkZHJlc3MuZXF1YWxzKEZsb3dFVk1CcmlkZ2VDb25maWcuZ2V0RVZNQWRkcmVzc0Fzc29jaWF0ZWQod2l0aDogbmZ0VHlwZSkhKSB7CiAgICAgICAgICAgICAgICAvLyBBcHByb3ZlIGNvbnRyYWN0IHRvIHdpdGhkcmF3IHVuZGVybHlpbmcgTkZUcyBmcm9tIHNpZ25lcidzIGNvYQogICAgICAgICAgICAgICAgbXVzdENhbGwoY29hLCB1bmRlcmx5aW5nQWRkcmVzcywKICAgICAgICAgICAgICAgICAgICBmdW5jdGlvblNpZzogInNldEFwcHJvdmFsRm9yQWxsKGFkZHJlc3MsYm9vbCkiLAogICAgICAgICAgICAgICAgICAgIGFyZ3M6IFtjcm9zc1ZNUG9pbnRlci5ldm1Db250cmFjdEFkZHJlc3MsIHRydWVdCiAgICAgICAgICAgICAgICApCgogICAgICAgICAgICAgICAgLy8gV3JhcCBORlRzIHdpdGggcHJvdmlkZWQgSURzLCBhbmQgY2hlY2sgaWYgdGhlIGNhbGwgd2FzIHN1Y2Nlc3NmdWwKICAgICAgICAgICAgICAgIGxldCByZXMgPSBtdXN0Q2FsbChjb2EsIGNyb3NzVk1Qb2ludGVyLmV2bUNvbnRyYWN0QWRkcmVzcywKICAgICAgICAgICAgICAgICAgICBmdW5jdGlvblNpZzogImRlcG9zaXRGb3IoYWRkcmVzcyx1aW50MjU2W10pIiwKICAgICAgICAgICAgICAgICAgICBhcmdzOiBbY29hLmFkZHJlc3MoKSwgbmZ0SURzXQogICAgICAgICAgICAgICAgKQogICAgICAgICAgICAgICAgbGV0IGRlY29kZWRSZXMgPSBFVk0uZGVjb2RlQUJJKHR5cGVzOiBbVHlwZTxCb29sPigpXSwgZGF0YTogcmVzLmRhdGEpCiAgICAgICAgICAgICAgICBhc3NlcnQoZGVjb2RlZFJlcy5sZW5ndGggPT0gMSwgbWVzc2FnZTogIkludmFsaWQgcmVzcG9uc2UgbGVuZ3RoIikKICAgICAgICAgICAgICAgIGFzc2VydChkZWNvZGVkUmVzWzBdIGFzISBCb29sLCBtZXNzYWdlOiAiRmFpbGVkIHRvIHdyYXAgTkZUcyIpCgogICAgICAgICAgICAgICAgLy8gVHJhbnNmZXIgTkZUcyB0byByZWNpcGllbnQgaWYgcHJvdmlkZWQKICAgICAgICAgICAgICAgIGlmIGxldCB0byA9IHJlY2lwaWVudElmTm90Q29hIHsKICAgICAgICAgICAgICAgICAgICBtdXN0VHJhbnNmZXJORlRzKGNvYSwgY3Jvc3NWTVBvaW50ZXIuZXZtQ29udHJhY3RBZGRyZXNzLCBuZnRJRHM6IG5mdElEcywgdG86IHRvKQogICAgICAgICAgICAgICAgfQoKICAgICAgICAgICAgICAgIC8vIFJldm9rZSBhcHByb3ZhbCBmb3IgY29udHJhY3QgdG8gd2l0aGRyYXcgdW5kZXJseWluZyBORlRzIGZyb20gc2lnbmVyJ3MgY29hCiAgICAgICAgICAgICAgICBtdXN0Q2FsbChjb2EsIHVuZGVybHlpbmdBZGRyZXNzLAogICAgICAgICAgICAgICAgICAgIGZ1bmN0aW9uU2lnOiAic2V0QXBwcm92YWxGb3JBbGwoYWRkcmVzcyxib29sKSIsCiAgICAgICAgICAgICAgICAgICAgYXJnczogW2Nyb3NzVk1Qb2ludGVyLmV2bUNvbnRyYWN0QWRkcmVzcywgZmFsc2VdCiAgICAgICAgICAgICAgICApCiAgICAgICAgICAgIH0KICAgICAgICB9CiAgICB9Cn0KCi8vLyBHZXRzIHRoZSB1bmRlcmx5aW5nIEVSQzcyMSBhZGRyZXNzIGlmIGl0IGV4aXN0cyAoaS5lLiBpZiB0aGUgRVJDNzIxIGlzIGEgd3JhcHBlcikKLy8vCmFjY2VzcyhhbGwpIGZ1biBnZXRVbmRlcmx5aW5nRVJDNzIxQWRkcmVzcygKICAgIF8gY29hOiBhdXRoKEVWTS5DYWxsKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQsCiAgICBfIHdyYXBwZXJBZGRyZXNzOiBFVk0uRVZNQWRkcmVzcwopOiBFVk0uRVZNQWRkcmVzcz8gewogICAgbGV0IHJlcyA9IGNvYS5jYWxsKAogICAgICAgIHRvOiB3cmFwcGVyQWRkcmVzcywKICAgICAgICBkYXRhOiBFVk0uZW5jb2RlQUJJV2l0aFNpZ25hdHVyZSgidW5kZXJseWluZygpIiwgW10pLAogICAgICAgIGdhc0xpbWl0OiAxMDBfMDAwLAogICAgICAgIHZhbHVlOiBFVk0uQmFsYW5jZShhdHRvZmxvdzogMCkKICAgICkKCiAgICAvLyBJZiB0aGUgY2FsbCBmYWlscywgcmV0dXJuIG5pbAogICAgaWYgcmVzLnN0YXR1cyAhPSBFVk0uU3RhdHVzLnN1Y2Nlc3NmdWwgfHwgcmVzLmRhdGEubGVuZ3RoID09IDAgewogICAgICAgIHJldHVybiBuaWwKICAgIH0KCiAgICAvLyBEZWNvZGUgYW5kIHJldHVybiB0aGUgdW5kZXJseWluZyBFUkM3MjEgYWRkcmVzcwogICAgbGV0IGRlY29kZWRSZXN1bHQgPSBFVk0uZGVjb2RlQUJJKAogICAgICAgIHR5cGVzOiBbVHlwZTxFVk0uRVZNQWRkcmVzcz4oKV0sCiAgICAgICAgZGF0YTogcmVzLmRhdGEKICAgICkKICAgIGFzc2VydChkZWNvZGVkUmVzdWx0Lmxlbmd0aCA9PSAxLCBtZXNzYWdlOiAiSW52YWxpZCByZXNwb25zZSBsZW5ndGgiKQogICAgcmV0dXJuIGRlY29kZWRSZXN1bHRbMF0gYXMhIEVWTS5FVk1BZGRyZXNzCn0KCi8vLyBDaGVja3MgaWYgdGhlIHByb3ZpZGVkIE5GVCBpcyBvd25lZCBieSB0aGUgcHJvdmlkZWQgRVZNIGFkZHJlc3MKLy8vCmFjY2VzcyhhbGwpIGZ1biBpc093bmVyKAogICAgXyBjb2E6IGF1dGgoRVZNLkNhbGwpICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudCwKICAgIF8gZXJjNzIxQWRkcmVzczogRVZNLkVWTUFkZHJlc3MsCiAgICBfIG5mdElEOiBVSW50NjQsCiAgICBfIG93bmVyVG9DaGVjazogRVZNLkVWTUFkZHJlc3MKKTogQm9vbCB7CiAgICBsZXQgcmVzID0gY29hLmNhbGwoCiAgICAgICAgdG86IGVyYzcyMUFkZHJlc3MsCiAgICAgICAgZGF0YTogRVZNLmVuY29kZUFCSVdpdGhTaWduYXR1cmUoIm93bmVyT2YodWludDI1NikiLCBbbmZ0SURdKSwKICAgICAgICBnYXNMaW1pdDogMTAwXzAwMCwKICAgICAgICB2YWx1ZTogRVZNLkJhbGFuY2UoYXR0b2Zsb3c6IDApCiAgICApCiAgICBhc3NlcnQocmVzLnN0YXR1cyA9PSBFVk0uU3RhdHVzLnN1Y2Nlc3NmdWwsIG1lc3NhZ2U6ICJDYWxsIHRvIEVSQzcyMS5vd25lck9mKHVpbnQyNTYpIGZhaWxlZCIpCiAgICBsZXQgZGVjb2RlZFJlcyA9IEVWTS5kZWNvZGVBQkkodHlwZXM6IFtUeXBlPEVWTS5FVk1BZGRyZXNzPigpXSwgZGF0YTogcmVzLmRhdGEpCiAgICBpZiBkZWNvZGVkUmVzLmxlbmd0aCA9PSAxIHsKICAgICAgICBsZXQgYWN0dWFsT3duZXIgPSBkZWNvZGVkUmVzWzBdIGFzISBFVk0uRVZNQWRkcmVzcwogICAgICAgIHJldHVybiBhY3R1YWxPd25lci5lcXVhbHMob3duZXJUb0NoZWNrKQogICAgfQogICAgcmV0dXJuIGZhbHNlCn0KCi8vLyBUcmFuc2ZlcnMgTkZUcyBmcm9tIHRoZSBwcm92aWRlZCBDT0EgdG8gdGhlIHByb3ZpZGVkIEVWTSBhZGRyZXNzCi8vLwphY2Nlc3MoYWxsKSBmdW4gbXVzdFRyYW5zZmVyTkZUcygKICAgIF8gY29hOiBhdXRoKEVWTS5DYWxsKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQsCiAgICBfIGVyYzcyMUFkZHJlc3M6IEVWTS5FVk1BZGRyZXNzLAogICAgbmZ0SURzOiBbVUludDY0XSwKICAgIHRvOiBFVk0uRVZNQWRkcmVzcwopIHsKICAgIGZvciBpZCBpbiBuZnRJRHMgewogICAgICAgIGFzc2VydChpc093bmVyKGNvYSwgZXJjNzIxQWRkcmVzcywgaWQsIGNvYS5hZGRyZXNzKCkpLCBtZXNzYWdlOiAiTkZUIG5vdCBvd25lZCBieSBzaWduZXIncyBDT0EiKQogICAgICAgIG11c3RDYWxsKGNvYSwgZXJjNzIxQWRkcmVzcywKICAgICAgICAgICAgZnVuY3Rpb25TaWc6ICJzYWZlVHJhbnNmZXJGcm9tKGFkZHJlc3MsYWRkcmVzcyx1aW50MjU2KSIsCiAgICAgICAgICAgIGFyZ3M6IFtjb2EuYWRkcmVzcygpLCB0bywgaWRdCiAgICAgICAgKQogICAgICAgIGFzc2VydChpc093bmVyKGNvYSwgZXJjNzIxQWRkcmVzcywgaWQsIHRvKSwgbWVzc2FnZTogIk5GVCBub3QgdHJhbnNmZXJyZWQgdG8gcmVjaXBpZW50IikKICAgIH0KfQoKLy8vIENhbGxzIGEgZnVuY3Rpb24gb24gYW4gRVZNIGNvbnRyYWN0IGZyb20gcHJvdmlkZWQgY29hCi8vLwphY2Nlc3MoYWxsKSBmdW4gbXVzdENhbGwoCiAgICBfIGNvYTogYXV0aChFVk0uQ2FsbCkgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50LAogICAgXyBjb250cmFjdEFkZHI6IEVWTS5FVk1BZGRyZXNzLAogICAgZnVuY3Rpb25TaWc6IFN0cmluZywKICAgIGFyZ3M6IFtBbnlTdHJ1Y3RdCik6IEVWTS5SZXN1bHQgewogICAgbGV0IHJlcyA9IGNvYS5jYWxsKAogICAgICAgIHRvOiBjb250cmFjdEFkZHIsCiAgICAgICAgZGF0YTogRVZNLmVuY29kZUFCSVdpdGhTaWduYXR1cmUoZnVuY3Rpb25TaWcsIGFyZ3MpLAogICAgICAgIGdhc0xpbWl0OiA0XzAwMF8wMDAsCiAgICAgICAgdmFsdWU6IEVWTS5CYWxhbmNlKGF0dG9mbG93OiAwKQogICAgKQoKICAgIGFzc2VydChyZXMuc3RhdHVzID09IEVWTS5TdGF0dXMuc3VjY2Vzc2Z1bCwKICAgICAgICBtZXNzYWdlOiAiRmFpbGVkIHRvIGNhbGwgJyIuY29uY2F0KGZ1bmN0aW9uU2lnKQogICAgICAgICAgICAuY29uY2F0KCJcblx0IGVycm9yIGNvZGU6ICIpLmNvbmNhdChyZXMuZXJyb3JDb2RlLnRvU3RyaW5nKCkpCiAgICAgICAgICAgIC5jb25jYXQoIlxuXHQgZXJyb3IgbWVzc2FnZTogIikuY29uY2F0KHJlcy5lcnJvck1lc3NhZ2UpCiAgICAgICAgICAgIC5jb25jYXQoIlxuXHQgZ2FzIHVzZWQ6ICIpLmNvbmNhdChyZXMuZ2FzVXNlZC50b1N0cmluZygpKQogICAgICAgICAgICAuY29uY2F0KCJcblx0IGNhbGxlciBhZGRyZXNzOiAweCIpLmNvbmNhdChjb2EuYWRkcmVzcygpLnRvU3RyaW5nKCkpCiAgICAgICAgICAgIC5jb25jYXQoIlxuXHQgY29udHJhY3QgYWRkcmVzczogMHgiKS5jb25jYXQoY29udHJhY3RBZGRyLnRvU3RyaW5nKCkpCiAgICApCgogICAgcmV0dXJuIHJlcwp9Cg\u003d\u003d", + "checkChildLinkedCollections": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY2hlY2tDaGlsZExpbmtlZENvbGxlY3Rpb25zIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgSHlicmlkQ3VzdG9keSBmcm9tIDB4ZDhhN2UwNWE3YWM2NzBjMAoKaW1wb3J0IENhcGFiaWxpdHlGaWx0ZXIgZnJvbSAweGQ4YTdlMDVhN2FjNjcwYzAKCmltcG9ydCBOb25GdW5naWJsZVRva2VuIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgoKYWNjZXNzKGFsbCkgZnVuIG1haW4ocGFyZW50OiBBZGRyZXNzLCBjaGlsZDogQWRkcmVzcywgaWRlbnRpZmllcjogU3RyaW5nKTogQm9vbCB7CiAgICBsZXQgbWdyID0gZ2V0QXV0aEFjY291bnQocGFyZW50KS5ib3Jyb3c8Jkh5YnJpZEN1c3RvZHkuTWFuYWdlcj4oZnJvbTogSHlicmlkQ3VzdG9keS5NYW5hZ2VyU3RvcmFnZVBhdGgpCiAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgbWFuYWdlciBmcm9tIHBhcmVudCIpCiAgICBsZXQgY2hpbGQgPSBtZ3IuYm9ycm93QWNjb3VudChhZGRyOiBjaGlsZCkgPz8gcGFuaWMoIkNoaWxkIGFjY291bnQgbm90IGZvdW5kIikKCiAgICBsZXQgY2FwID0gY2hpbGQuZ2V0Q2FwYWJpbGl0eSgKICAgICAgICAgICAgcGF0aDogUHJpdmF0ZVBhdGgoaWRlbnRpZmllcjogaWRlbnRpZmllcikhIGFzIENhcGFiaWxpdHlQYXRoLAogICAgICAgICAgICB0eXBlOiBUeXBlPCZ7Tm9uRnVuZ2libGVUb2tlbi5Qcm92aWRlciwgTm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9uUHVibGljfT4oKQogICAgICAgICkgYXMhIENhcGFiaWxpdHk8JntOb25GdW5naWJsZVRva2VuLlByb3ZpZGVyLCBOb25GdW5naWJsZVRva2VuLkNvbGxlY3Rpb25QdWJsaWN9Pj8KCiAgICAKICAgIHJldHVybiBjYXAgIT0gbmlsCn0gICAKICAgIA\u003d\u003d", + "checkChildLinkedVaults": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY2hlY2tDaGlsZExpbmtlZFZhdWx0cyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEh5YnJpZEN1c3RvZHkgZnJvbSAweGQ4YTdlMDVhN2FjNjcwYzAKCmltcG9ydCBDYXBhYmlsaXR5RmlsdGVyIGZyb20gMHhkOGE3ZTA1YTdhYzY3MGMwCgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKHBhcmVudDogQWRkcmVzcywgY2hpbGQ6IEFkZHJlc3MsIHBhdGg6IFN0cmluZyk6IEJvb2wgewogIGxldCBhY2NvdW50ID0gZ2V0QXV0aEFjY291bnQ8YXV0aChTdG9yYWdlKSAmQWNjb3VudD4ocGFyZW50KQogIGxldCBtYW5hZ2VyID0gZ2V0QXV0aEFjY291bnQ8YXV0aChTdG9yYWdlKSAmQWNjb3VudD4ocGFyZW50KS5zdG9yYWdlLmJvcnJvdzxhdXRoKEh5YnJpZEN1c3RvZHkuTWFuYWdlKSAmSHlicmlkQ3VzdG9keS5NYW5hZ2VyPihmcm9tOiBIeWJyaWRDdXN0b2R5Lk1hbmFnZXJTdG9yYWdlUGF0aCkgPz8gcGFuaWMgKCJtYW5hZ2VyIGRvZXMgbm90IGV4aXN0IikKICAKICBsZXQgcHJvdmlkZXJUeXBlID0gVHlwZTxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+KCkKCiAgbGV0IGFkZHIgPSBnZXRBdXRoQWNjb3VudDxhdXRoKFN0b3JhZ2UsIENhcGFiaWxpdGllcykgJkFjY291bnQ+KGNoaWxkKQogIAogIGxldCBjaGlsZEFjY3QgPSBtYW5hZ2VyLmJvcnJvd0FjY291bnQoYWRkcjogY2hpbGQpID8/IHBhbmljKCJjaGlsZCBhY2NvdW50IG5vdCBmb3VuZCIpCgogIGxldCBjb250cm9sbGVycyA9IGFkZHIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuZ2V0Q29udHJvbGxlcnMoZm9yUGF0aDogU3RvcmFnZVBhdGgoaWRlbnRpZmllcjogcGF0aCkhKQogIHZhciBmbGFnID0gZmFsc2UKCiAgZm9yIGMgaW4gY29udHJvbGxlcnMgewogICAgaWYgIWMuYm9ycm93VHlwZS5pc1N1YnR5cGUob2Y6IHByb3ZpZGVyVHlwZSkgewogICAgICBjb250aW51ZQogICAgfQoKICAgIGlmIGxldCBjYXAgPSBjaGlsZEFjY3QuZ2V0Q2FwYWJpbGl0eShjb250cm9sbGVySUQ6IGMuY2FwYWJpbGl0eUlELCB0eXBlOiBwcm92aWRlclR5cGUpIHsKICAgICAgbGV0IHByb3ZpZGVyQ2FwID0gY2FwIGFzISBDYXBhYmlsaXR5PCZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+IAoKICAgICAgaWYgIXByb3ZpZGVyQ2FwLmNoZWNrKCl7CiAgICAgICAgY29udGludWUKICAgICAgfQoKICAgICAgZmxhZyA9IHRydWUKICAgICAgYnJlYWsKICAgIH0KICB9CgogIHJldHVybiBmbGFnCn0gCiAgICA\u003d", + "checkChildRecieveVaults": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY2hlY2tDaGlsZFJlY2lldmVWYXVsdHMgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBIeWJyaWRDdXN0b2R5IGZyb20gMHhkOGE3ZTA1YTdhYzY3MGMwCgppbXBvcnQgQ2FwYWJpbGl0eUZpbHRlciBmcm9tIDB4ZDhhN2UwNWE3YWM2NzBjMAoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihwYXJlbnQ6IEFkZHJlc3MsIGNoaWxkOiBBZGRyZXNzLCBwYXRoOiBTdHJpbmcpOiBCb29sIHsKICBsZXQgYWNjb3VudCA9IGdldEF1dGhBY2NvdW50PGF1dGgoU3RvcmFnZSkgJkFjY291bnQ+KHBhcmVudCkKICBsZXQgbWFuYWdlciA9IGdldEF1dGhBY2NvdW50PGF1dGgoU3RvcmFnZSkgJkFjY291bnQ+KHBhcmVudCkuc3RvcmFnZS5ib3Jyb3c8YXV0aChIeWJyaWRDdXN0b2R5Lk1hbmFnZSkgJkh5YnJpZEN1c3RvZHkuTWFuYWdlcj4oZnJvbTogSHlicmlkQ3VzdG9keS5NYW5hZ2VyU3RvcmFnZVBhdGgpID8/IHBhbmljICgibWFuYWdlciBkb2VzIG5vdCBleGlzdCIpCiAgCiAgbGV0IHJlY2VpdmVyVHlwZSA9IFR5cGU8JntGdW5naWJsZVRva2VuLlJlY2VpdmVyfT4oKQoKICBsZXQgYWRkciA9IGdldEF1dGhBY2NvdW50PGF1dGgoU3RvcmFnZSwgQ2FwYWJpbGl0aWVzKSAmQWNjb3VudD4oY2hpbGQpCiAgCiAgbGV0IGNoaWxkQWNjdCA9IG1hbmFnZXIuYm9ycm93QWNjb3VudChhZGRyOiBjaGlsZCkgPz8gcGFuaWMoImNoaWxkIGFjY291bnQgbm90IGZvdW5kIikKCiAgbGV0IGNvbnRyb2xsZXJzID0gYWRkci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5nZXRDb250cm9sbGVycyhmb3JQYXRoOiBTdG9yYWdlUGF0aChpZGVudGlmaWVyOiBwYXRoKSEpCiAgdmFyIGZsYWcgPSBmYWxzZQoKICBmb3IgYyBpbiBjb250cm9sbGVycyB7CiAgICBpZiAhYy5ib3Jyb3dUeXBlLmlzU3VidHlwZShvZjogcmVjZWl2ZXJUeXBlKSB7CiAgICAgIGNvbnRpbnVlCiAgICB9CgogICAgaWYgbGV0IGNhcCA9IGNoaWxkQWNjdC5nZXRDYXBhYmlsaXR5KGNvbnRyb2xsZXJJRDogYy5jYXBhYmlsaXR5SUQsIHR5cGU6IHJlY2VpdmVyVHlwZSkgewogICAgICBsZXQgcHJvdmlkZXJDYXAgPSBjYXAgYXMhIENhcGFiaWxpdHk8JntGdW5naWJsZVRva2VuLlJlY2VpdmVyfT4gCgogICAgICBpZiAhcHJvdmlkZXJDYXAuY2hlY2soKXsKICAgICAgICBjb250aW51ZQogICAgICB9CgogICAgICBmbGFnID0gdHJ1ZQogICAgICBicmVhawogICAgfQogIH0KCiAgcmV0dXJuIGZsYWcKfSAKICAgIA\u003d\u003d", + "editChildAccount": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZWRpdENoaWxkQWNjb3VudCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEh5YnJpZEN1c3RvZHkgZnJvbSAweGQ4YTdlMDVhN2FjNjcwYzAKCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgoKdHJhbnNhY3Rpb24oY2hpbGRBZGRyZXNzOiBBZGRyZXNzLCBuYW1lOiBTdHJpbmcsIGRlc2NyaXB0aW9uOiBTdHJpbmcsIHRodW1ibmFpbDogU3RyaW5nKSB7CiAgICBwcmVwYXJlKGFjY3Q6IEF1dGhBY2NvdW50KSB7CiAgICAgICAgbGV0IG0gPSBhY2N0LmJvcnJvdzwmSHlicmlkQ3VzdG9keS5NYW5hZ2VyPihmcm9tOiBIeWJyaWRDdXN0b2R5Lk1hbmFnZXJTdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIm1hbmFnZXIgbm90IGZvdW5kIikKICAgICAgICAKICAgICAgICBsZXQgZCA9IE1ldGFkYXRhVmlld3MuRGlzcGxheSgKICAgICAgICAgICAgbmFtZTogbmFtZSwKICAgICAgICAgICAgZGVzY3JpcHRpb246IGRlc2NyaXB0aW9uLAogICAgICAgICAgICB0aHVtYm5haWw6IE1ldGFkYXRhVmlld3MuSFRUUEZpbGUodXJsOiB0aHVtYm5haWwpCiAgICAgICAgKQoKICAgICAgICBtLnNldENoaWxkQWNjb3VudERpc3BsYXkoYWRkcmVzczogY2hpbGRBZGRyZXNzLCBkKQogICAgfQp9", + "getAccessibleChildAccountNFTs": "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\u003d", + "getAccessibleCoinInfo": "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", + "getAccessibleCollectionAndIdsDisplay": "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\u003d\u003d", + "getChildAccountAllowTypes": "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\u003d\u003d", + "getChildAccountFTCapabilities": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Q2hpbGRBY2NvdW50RlRDYXBhYmlsaXRpZXMgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBIeWJyaWRDdXN0b2R5IGZyb20gMHhkOGE3ZTA1YTdhYzY3MGMwCgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKCi8vIFRoaXMgc2NyaXB0IGl0ZXJhdGVzIHRocm91Z2ggYSBwYXJlbnQncyBjaGlsZCBhY2NvdW50cywgCi8vIGlkZW50aWZpZXMgcHJpdmF0ZSBwYXRocyB3aXRoIGFuIGFjY2Vzc2libGUgRnVuZ2libGVUb2tlbi5Qcm92aWRlciwgYW5kIHJldHVybnMgdGhlIGNvcnJlc3BvbmRpbmcgdHlwZUlkcwphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyOiBBZGRyZXNzKTpBbnlTdHJ1Y3QgewogIGxldCBhY2NvdW50ID0gZ2V0QXV0aEFjY291bnQ8YXV0aChTdG9yYWdlKSAmQWNjb3VudD4oYWRkcikKICBsZXQgbWFuYWdlciA9IGdldEF1dGhBY2NvdW50PGF1dGgoU3RvcmFnZSkgJkFjY291bnQ+KGFkZHIpLnN0b3JhZ2UuYm9ycm93PGF1dGgoSHlicmlkQ3VzdG9keS5NYW5hZ2UpICZIeWJyaWRDdXN0b2R5Lk1hbmFnZXI+KGZyb206IEh5YnJpZEN1c3RvZHkuTWFuYWdlclN0b3JhZ2VQYXRoKQogICAgPz8gcGFuaWMgKCJtYW5hZ2VyIGRvZXMgbm90IGV4aXN0IikKCiAgdmFyIHR5cGVJZHNXaXRoUHJvdmlkZXI6IHtBZGRyZXNzOiBbU3RyaW5nXX0gPSB7fQogIAogIGxldCBwcm92aWRlclR5cGUgPSBUeXBlPGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntGdW5naWJsZVRva2VuLlByb3ZpZGVyfT4oKQoKICAvLyBJdGVyYXRlIHRocm91Z2ggY2hpbGQgYWNjb3VudHMKICBmb3IgYWRkcmVzcyBpbiBtYW5hZ2VyLmdldENoaWxkQWRkcmVzc2VzKCkgewogICAgbGV0IGFkZHIgPSBnZXRBdXRoQWNjb3VudDxhdXRoKFN0b3JhZ2UsIENhcGFiaWxpdGllcykgJkFjY291bnQ+KGFkZHJlc3MpCiAgICBsZXQgZm91bmRUeXBlczogW1N0cmluZ10gPSBbXQogICAgbGV0IGNoaWxkQWNjdCA9IG1hbmFnZXIuYm9ycm93QWNjb3VudChhZGRyOiBhZGRyZXNzKSA/PyBwYW5pYygiY2hpbGQgYWNjb3VudCBub3QgZm91bmQiKQogICAgLy8gZ2V0IGFsbCBwcml2YXRlIHBhdGhzCgogICAgZm9yIHMgaW4gYWRkci5zdG9yYWdlLnN0b3JhZ2VQYXRocyB7CiAgICAgIGZvciBjIGluIGFkZHIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuZ2V0Q29udHJvbGxlcnMoZm9yUGF0aDogcykgewogICAgICAgIGlmICFjLmJvcnJvd1R5cGUuaXNTdWJ0eXBlKG9mOiBwcm92aWRlclR5cGUpewogICAgICAgICAgY29udGludWUKICAgICAgICB9CgogICAgICAgIGlmIGxldCBjYXAgPSBjaGlsZEFjY3QuZ2V0Q2FwYWJpbGl0eShjb250cm9sbGVySUQ6IGMuY2FwYWJpbGl0eUlELCB0eXBlOiBwcm92aWRlclR5cGUpIHsKICAgICAgICAgIGxldCBwcm92aWRlckNhcCA9IGNhcCBhcyEgQ2FwYWJpbGl0eTwme0Z1bmdpYmxlVG9rZW4uUHJvdmlkZXJ9PiAKCiAgICAgICAgICBpZiAhcHJvdmlkZXJDYXAuY2hlY2soKXsKICAgICAgICAgICAgY29udGludWUKICAgICAgICAgIH0KCiAgICAgICAgICBmb3VuZFR5cGVzLmFwcGVuZChjYXAuYm9ycm93PCZBbnlSZXNvdXJjZT4oKSEuZ2V0VHlwZSgpLmlkZW50aWZpZXIpCiAgICAgICAgICB0eXBlSWRzV2l0aFByb3ZpZGVyW2FkZHJlc3NdID0gZm91bmRUeXBlcwogICAgICAgICAgYnJlYWsKICAgICAgICB9CiAgICAgIH0KICAgIH0gICAgICAKICB9CgogIHJldHVybiB0eXBlSWRzV2l0aFByb3ZpZGVyCn0KIA\u003d\u003d", + "getChildAccountMeta": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Q2hpbGRBY2NvdW50TWV0YSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEh5YnJpZEN1c3RvZHkgZnJvbSAweGQ4YTdlMDVhN2FjNjcwYzAKCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgoKYWNjZXNzKGFsbCkgZnVuIG1haW4ocGFyZW50OiBBZGRyZXNzKToge0FkZHJlc3M6IEFueVN0cnVjdH0gewogICAgbGV0IGFjY3QgPSBnZXRBdXRoQWNjb3VudDxhdXRoKFN0b3JhZ2UpICZBY2NvdW50PihwYXJlbnQpCiAgICBsZXQgbSA9IGFjY3Quc3RvcmFnZS5ib3Jyb3c8Jkh5YnJpZEN1c3RvZHkuTWFuYWdlcj4oZnJvbTogSHlicmlkQ3VzdG9keS5NYW5hZ2VyU3RvcmFnZVBhdGgpCgogICAgaWYgbSA9PSBuaWwgewogICAgICAgIHJldHVybiB7fQogICAgfSBlbHNlIHsKICAgICAgICB2YXIgZGF0YToge0FkZHJlc3M6IEFueVN0cnVjdH0gPSB7fQogICAgICAgIGZvciBhZGRyZXNzIGluIG0/LmdldENoaWxkQWRkcmVzc2VzKCkhIHsKICAgICAgICAgICAgbGV0IGMgPSBtPy5nZXRDaGlsZEFjY291bnREaXNwbGF5KGFkZHJlc3M6IGFkZHJlc3MpIAogICAgICAgICAgICBkYXRhLmluc2VydChrZXk6IGFkZHJlc3MsIGMpCiAgICAgICAgfQogICAgICAgIHJldHVybiBkYXRhCiAgICB9Cn0\u003d", + "getChildAddresses": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Q2hpbGRBZGRyZXNzZXMgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBIeWJyaWRDdXN0b2R5IGZyb20gMHhkOGE3ZTA1YTdhYzY3MGMwCgoKYWNjZXNzKGFsbCkgZnVuIG1haW4ocGFyZW50OiBBZGRyZXNzKTogW0FkZHJlc3NdIHsKICAgIGxldCBhY2N0ID0gZ2V0QXV0aEFjY291bnQ8YXV0aChTdG9yYWdlKSAmQWNjb3VudD4ocGFyZW50KQogICAgbGV0IG1hbmFnZXIgPSBhY2N0LnN0b3JhZ2UuYm9ycm93PCZIeWJyaWRDdXN0b2R5Lk1hbmFnZXI+KGZyb206IEh5YnJpZEN1c3RvZHkuTWFuYWdlclN0b3JhZ2VQYXRoKQogICAgICAgID8/IHBhbmljKCJtYW5hZ2VyIG5vdCBmb3VuZCIpCiAgICByZXR1cm4gIG1hbmFnZXIuZ2V0Q2hpbGRBZGRyZXNzZXMoKQp9", + "getExamplenftCollectionFromDelegator": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0RXhhbXBsZW5mdENvbGxlY3Rpb25Gcm9tRGVsZWdhdG9yIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgSHlicmlkQ3VzdG9keSBmcm9tIDB4ZDhhN2UwNWE3YWM2NzBjMAoKCmltcG9ydCBOb25GdW5naWJsZVRva2VuIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgPFRva2VuPiBmcm9tIDxUb2tlbkFkZHJlc3M+CgphY2Nlc3MoYWxsKSBmdW4gbWFpbihwYXJlbnQ6IEFkZHJlc3MsIGNoaWxkOiBBZGRyZXNzLCBpc1B1YmxpYzogQm9vbCkgewogICAgbGV0IG0gPSBnZXRBdXRoQWNjb3VudDxhdXRoKFN0b3JhZ2UpICZBY2NvdW50PihwYXJlbnQpLnN0b3JhZ2UuYm9ycm93PGF1dGgoSHlicmlkQ3VzdG9keS5NYW5hZ2UpICZIeWJyaWRDdXN0b2R5Lk1hbmFnZXI+KGZyb206IEh5YnJpZEN1c3RvZHkuTWFuYWdlclN0b3JhZ2VQYXRoKQogICAgICAgID8/IHBhbmljKCJtYW5hZ2VyIG5vdCBmb3VuZCIpCiAgICBsZXQgYWNjdCA9IG0uYm9ycm93QWNjb3VudChhZGRyOiBjaGlsZCkKICAgICAgICA/PyBwYW5pYygiY2hpbGQgYWNjb3VudCBub3QgZm91bmQgaW4gbWFuYWdlciIpCgogICAgbGV0IHQgPSBUeXBlPENhcGFiaWxpdHk8JkV4YW1wbGVORlQuQ29sbGVjdGlvbj4+KCkKCiAgICBsZXQgY2FwID0gKGlzUHVibGljID8gYWNjdC5nZXRQdWJsaWNDYXBGcm9tRGVsZWdhdG9yKHR5cGU6IHQpIDogYWNjdC5nZXRQcml2YXRlQ2FwRnJvbURlbGVnYXRvcih0eXBlOiB0KSkKICAgICAgICA/PyBwYW5pYygiY2FwYWJpbGl0eSBub3QgZm91bmQiKQogICAgCiAgICBhc3NlcnQoY2FwLmdldFR5cGUoKSA9PSB0LCBtZXNzYWdlOiAibWlzbWF0Y2hlZCBjYXBhYmlsaXR5IHR5cGVzIikKfQ\u003d\u003d", + "publishToParent": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcHVibGlzaFRvUGFyZW50IC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgojYWxsb3dBY2NvdW50TGlua2luZwoKaW1wb3J0IEh5YnJpZEN1c3RvZHkgZnJvbSAweGQ4YTdlMDVhN2FjNjcwYzAKCmltcG9ydCBDYXBhYmlsaXR5RmFjdG9yeSBmcm9tIDB4ZDhhN2UwNWE3YWM2NzBjMAoKaW1wb3J0IENhcGFiaWxpdHlGaWx0ZXIgZnJvbSAweGQ4YTdlMDVhN2FjNjcwYzAKCmltcG9ydCBDYXBhYmlsaXR5RGVsZWdhdG9yIGZyb20gMHhkOGE3ZTA1YTdhYzY3MGMwCgoKdHJhbnNhY3Rpb24ocGFyZW50OiBBZGRyZXNzLCBmYWN0b3J5QWRkcmVzczogQWRkcmVzcywgZmlsdGVyQWRkcmVzczogQWRkcmVzcykgewogICAgcHJlcGFyZShhY2N0OiBhdXRoKFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IG93bmVkID0gYWNjdC5zdG9yYWdlLmJvcnJvdzxhdXRoKEh5YnJpZEN1c3RvZHkuT3duZXIpICZIeWJyaWRDdXN0b2R5Lk93bmVkQWNjb3VudD4oZnJvbTogSHlicmlkQ3VzdG9keS5Pd25lZEFjY291bnRTdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIm93bmVkIGFjY291bnQgbm90IGZvdW5kIikKCiAgICAgICAgbGV0IGZhY3RvcnkgPSBnZXRBY2NvdW50KGZhY3RvcnlBZGRyZXNzKS5jYXBhYmlsaXRpZXMuZ2V0PCZDYXBhYmlsaXR5RmFjdG9yeS5NYW5hZ2VyPihDYXBhYmlsaXR5RmFjdG9yeS5QdWJsaWNQYXRoKQogICAgICAgIGFzc2VydChmYWN0b3J5LmNoZWNrKCksIG1lc3NhZ2U6ICJmYWN0b3J5IGFkZHJlc3MgaXMgbm90IGNvbmZpZ3VyZWQgcHJvcGVybHkiKQoKICAgICAgICBsZXQgZmlsdGVyID0gZ2V0QWNjb3VudChmaWx0ZXJBZGRyZXNzKS5jYXBhYmlsaXRpZXMuZ2V0PCZ7Q2FwYWJpbGl0eUZpbHRlci5GaWx0ZXJ9PihDYXBhYmlsaXR5RmlsdGVyLlB1YmxpY1BhdGgpCiAgICAgICAgYXNzZXJ0KGZpbHRlci5jaGVjaygpLCBtZXNzYWdlOiAiY2FwYWJpbGl0eSBmaWx0ZXIgaXMgbm90IGNvbmZpZ3VyZWQgcHJvcGVybHkiKQoKICAgICAgICBvd25lZC5wdWJsaXNoVG9QYXJlbnQocGFyZW50QWRkcmVzczogcGFyZW50LCBmYWN0b3J5OiBmYWN0b3J5LCBmaWx0ZXI6IGZpbHRlcikKICAgIH0KfQ\u003d\u003d", + "redeemAccount": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcmVkZWVtQWNjb3VudCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IE1ldGFkYXRhVmlld3MgZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCmltcG9ydCBWaWV3UmVzb2x2ZXIgZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCgppbXBvcnQgSHlicmlkQ3VzdG9keSBmcm9tIDB4ZDhhN2UwNWE3YWM2NzBjMAoKaW1wb3J0IENhcGFiaWxpdHlGaWx0ZXIgZnJvbSAweGQ4YTdlMDVhN2FjNjcwYzAKCgp0cmFuc2FjdGlvbihjaGlsZEFkZHJlc3M6IEFkZHJlc3MsIGZpbHRlckFkZHJlc3M6IEFkZHJlc3M/LCBmaWx0ZXJQYXRoOiBQdWJsaWNQYXRoPykgewogICAgcHJlcGFyZShhY2N0OiBhdXRoKFN0b3JhZ2UsIENhcGFiaWxpdGllcywgSW5ib3gpICZBY2NvdW50KSB7CiAgICAgICAgdmFyIGZpbHRlcjogQ2FwYWJpbGl0eTwme0NhcGFiaWxpdHlGaWx0ZXIuRmlsdGVyfT4/ID0gbmlsCiAgICAgICAgaWYgZmlsdGVyQWRkcmVzcyAhPSBuaWwgJiYgZmlsdGVyUGF0aCAhPSBuaWwgewogICAgICAgICAgICBmaWx0ZXIgPSBnZXRBY2NvdW50KGZpbHRlckFkZHJlc3MhKS5jYXBhYmlsaXRpZXMuZ2V0PCZ7Q2FwYWJpbGl0eUZpbHRlci5GaWx0ZXJ9PihmaWx0ZXJQYXRoISkKICAgICAgICB9CgogICAgICAgIGlmIGFjY3Quc3RvcmFnZS5ib3Jyb3c8Jkh5YnJpZEN1c3RvZHkuTWFuYWdlcj4oZnJvbTogSHlicmlkQ3VzdG9keS5NYW5hZ2VyU3RvcmFnZVBhdGgpID09IG5pbCB7CiAgICAgICAgICAgIGxldCBtIDwtIEh5YnJpZEN1c3RvZHkuY3JlYXRlTWFuYWdlcihmaWx0ZXI6IGZpbHRlcikKICAgICAgICAgICAgYWNjdC5zdG9yYWdlLnNhdmUoPC0gbSwgdG86IEh5YnJpZEN1c3RvZHkuTWFuYWdlclN0b3JhZ2VQYXRoKQoKICAgICAgICAgICAgZm9yIGMgaW4gYWNjdC5jYXBhYmlsaXRpZXMuc3RvcmFnZS5nZXRDb250cm9sbGVycyhmb3JQYXRoOiBIeWJyaWRDdXN0b2R5Lk1hbmFnZXJTdG9yYWdlUGF0aCkgewogICAgICAgICAgICAgICAgYy5kZWxldGUoKQogICAgICAgICAgICB9CgogICAgICAgICAgICBhY2N0LmNhcGFiaWxpdGllcy51bnB1Ymxpc2goSHlicmlkQ3VzdG9keS5NYW5hZ2VyUHVibGljUGF0aCkKCiAgICAgICAgICAgIGFjY3QuY2FwYWJpbGl0aWVzLnB1Ymxpc2goCiAgICAgICAgICAgICAgICBhY2N0LmNhcGFiaWxpdGllcy5zdG9yYWdlLmlzc3VlPCZ7SHlicmlkQ3VzdG9keS5NYW5hZ2VyUHVibGljfT4oSHlicmlkQ3VzdG9keS5NYW5hZ2VyU3RvcmFnZVBhdGgpLAogICAgICAgICAgICAgICAgYXQ6IEh5YnJpZEN1c3RvZHkuTWFuYWdlclB1YmxpY1BhdGgKICAgICAgICAgICAgKQoKICAgICAgICAgICAgYWNjdC5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTxhdXRoKEh5YnJpZEN1c3RvZHkuTWFuYWdlKSAme0h5YnJpZEN1c3RvZHkuTWFuYWdlclByaXZhdGUsIEh5YnJpZEN1c3RvZHkuTWFuYWdlclB1YmxpY30+KEh5YnJpZEN1c3RvZHkuTWFuYWdlclN0b3JhZ2VQYXRoKQogICAgICAgIH0KCiAgICAgICAgbGV0IGluYm94TmFtZSA9IEh5YnJpZEN1c3RvZHkuZ2V0Q2hpbGRBY2NvdW50SWRlbnRpZmllcihhY2N0LmFkZHJlc3MpCiAgICAgICAgbGV0IGNhcCA9IGFjY3QuaW5ib3guY2xhaW08YXV0aChIeWJyaWRDdXN0b2R5LkNoaWxkKSAme0h5YnJpZEN1c3RvZHkuQWNjb3VudFByaXZhdGUsIEh5YnJpZEN1c3RvZHkuQWNjb3VudFB1YmxpYywgVmlld1Jlc29sdmVyLlJlc29sdmVyfT4oaW5ib3hOYW1lLCBwcm92aWRlcjogY2hpbGRBZGRyZXNzKQogICAgICAgICAgICA/PyBwYW5pYygiY2hpbGQgYWNjb3VudCBjYXAgbm90IGZvdW5kIikKCiAgICAgICAgbGV0IG1hbmFnZXIgPSBhY2N0LnN0b3JhZ2UuYm9ycm93PGF1dGgoSHlicmlkQ3VzdG9keS5NYW5hZ2UpICZIeWJyaWRDdXN0b2R5Lk1hbmFnZXI+KGZyb206IEh5YnJpZEN1c3RvZHkuTWFuYWdlclN0b3JhZ2VQYXRoKQogICAgICAgICAgICA/PyBwYW5pYygibWFuYWdlciBubyBmb3VuZCIpCgogICAgICAgIG1hbmFnZXIuYWRkQWNjb3VudChjYXA6IGNhcCkKICAgIH0KfQ\u003d\u003d", + "sendChildFT": "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\u003d", + "sendChildFTToChild": "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", + "sendChildFTWithParent": "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\u003d", + "sendChildNFT": "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", + "sendChildNFTToChild": "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", + "setupOwnedAccount": "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", + "setupOwnedAccountAndPublishToParent": "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", + "transferChildFT": "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\u003d\u003d", + "transferChildNFT": "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\u003d\u003d", + "transferNFTToChild": "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", + "unlinkChildAccount": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgdW5saW5rQ2hpbGRBY2NvdW50IC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgSHlicmlkQ3VzdG9keSBmcm9tIDB4ZDhhN2UwNWE3YWM2NzBjMAoKCnRyYW5zYWN0aW9uKGNoaWxkOiBBZGRyZXNzKSB7CiAgICBwcmVwYXJlIChhY2N0OiBhdXRoKFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IG1hbmFnZXIgPSBhY2N0LnN0b3JhZ2UuYm9ycm93PGF1dGgoSHlicmlkQ3VzdG9keS5NYW5hZ2UpICZIeWJyaWRDdXN0b2R5Lk1hbmFnZXI+KGZyb206IEh5YnJpZEN1c3RvZHkuTWFuYWdlclN0b3JhZ2VQYXRoKQogICAgICAgICAgICA/PyBwYW5pYygibWFuYWdlciBub3QgZm91bmQiKQogICAgICAgIG1hbmFnZXIucmVtb3ZlQ2hpbGQoYWRkcjogY2hpbGQpCiAgICB9Cn0\u003d" + }, + "lostAndFound": { + "batchQueryUnclaimedNumber": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYmF0Y2hRdWVyeVVuY2xhaW1lZE51bWJlciAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IExvc3RBbmRGb3VuZCBmcm9tIDB4NDczZDZhMmMzN2VhYjViZQoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJzOiBbQWRkcmVzc10pOiBJbnQgewogICAgbGV0IHNoZWxmTWFuYWdlciA9IExvc3RBbmRGb3VuZC5ib3Jyb3dTaGVsZk1hbmFnZXIoKQogICAgdmFyIHVuY2xhaW1lZE51bWJlciA9IDAKICAgIGZvciBhZGRyIGluIGFkZHJzIHsKICAgICAgICBsZXQgc2hlbGYgPSBzaGVsZk1hbmFnZXIuYm9ycm93U2hlbGYocmVkZWVtZXI6IGFkZHIpCiAgICAgICAgaWYgc2hlbGYgPT0gbmlsIHsKICAgICAgICAgICAgY29udGludWUKICAgICAgICB9IGVsc2UgewogICAgICAgICAgICB1bmNsYWltZWROdW1iZXIgPSB1bmNsYWltZWROdW1iZXIgKyBzaGVsZiEuZ2V0UmVkZWVtYWJsZVR5cGVzKCkubGVuZ3RoCiAgICAgICAgfQogICAgfQogICAgcmV0dXJuIHVuY2xhaW1lZE51bWJlcgp9", + "claimFT": "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\u003d\u003d", + "claimNFT": "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\u003d", + "queryUnclaimedFTs": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcXVlcnlVbmNsYWltZWRGVHMgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBMb3N0QW5kRm91bmQgZnJvbSAweDQ3M2Q2YTJjMzdlYWI1YmUKCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHI6IEFkZHJlc3MpOiBbQW55U3RydWN0P10gewogICAgbGV0IHRpY2tldHMgPSBMb3N0QW5kRm91bmQuYm9ycm93QWxsVGlja2V0cyhhZGRyOiBhZGRyKQogICAgCiAgICBsZXQgZGlzcGxheUFycjogW0FueVN0cnVjdD9dICA9IFtdCiAgICBmb3IgdGlja2V0IGluIHRpY2tldHMgewogICAgICAgIGlmIHRpY2tldC50eXBlLmlzU3VidHlwZShvZjogVHlwZTxAe0Z1bmdpYmxlVG9rZW4uVmF1bHR9PigpKSB7IAogICAgICAgICAgICBkaXNwbGF5QXJyLmFwcGVuZCh7ImRpc3BsYXkiOiB0aWNrZXQuZGlzcGxheSwgImJhbGFuY2UiOiB0aWNrZXQuZ2V0RnVuZ2libGVUb2tlbkJhbGFuY2UoKX0pCiAgICAgICAgfQogICAgfQogICAgcmV0dXJuIGRpc3BsYXlBcnIKfQ\u003d\u003d", + "queryUnclaimedNFTs": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcXVlcnlVbmNsYWltZWRORlRzIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTG9zdEFuZEZvdW5kIGZyb20gMHg0NzNkNmEyYzM3ZWFiNWJlCgppbXBvcnQgTWV0YWRhdGFWaWV3cyBmcm9tIDB4MWQ3ZTU3YWE1NTgxNzQ0OAoKaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyOiBBZGRyZXNzKTogWyZNZXRhZGF0YVZpZXdzLkRpc3BsYXk/XSB7CiAgICBsZXQgdGlja2V0cyA9IExvc3RBbmRGb3VuZC5ib3Jyb3dBbGxUaWNrZXRzKGFkZHI6IGFkZHIpCiAgICAKICAgIGxldCBkaXNwbGF5QXJyOiBbJk1ldGFkYXRhVmlld3MuRGlzcGxheT9dICA9IFtdCiAgICBmb3IgdGlja2V0IGluIHRpY2tldHMgewogICAgICAgIGlmIHRpY2tldC50eXBlLmlzU3VidHlwZShvZjogVHlwZTxAe05vbkZ1bmdpYmxlVG9rZW4uTkZUfT4oKSkgeyAKICAgICAgICAgICAgZGlzcGxheUFyci5hcHBlbmQodGlja2V0LmRpc3BsYXkpCiAgICAgICAgfQogICAgfQogICAgCiAgICByZXR1cm4gZGlzcGxheUFycgp9", + "queryUnclaimedNumber": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcXVlcnlVbmNsYWltZWROdW1iZXIgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBMb3N0QW5kRm91bmQgZnJvbSAweDQ3M2Q2YTJjMzdlYWI1YmUKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyOiBBZGRyZXNzKTogSW50IHsKICAgIGxldCBzaGVsZk1hbmFnZXIgPSBMb3N0QW5kRm91bmQuYm9ycm93U2hlbGZNYW5hZ2VyKCkKICAgIGxldCBzaGVsZiA9IHNoZWxmTWFuYWdlci5ib3Jyb3dTaGVsZihyZWRlZW1lcjogYWRkcikKICAgIGlmIHNoZWxmID09IG5pbCB7CiAgICAgICAgcmV0dXJuIDAKICAgIH0KICAgIAogICAgcmV0dXJuIHNoZWxmIS5nZXRSZWRlZW1hYmxlVHlwZXMoKS5sZW5ndGgKfQ\u003d\u003d", + "sendFT": "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\u003d\u003d", + "sendNFT": "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\u003d" }, "nft": { - "checkNFTListEnabled": "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\u003d\u003d" + "checkNFTListEnabled": "
    // Flow Wallet - mainnet Script  checkNFTListEnabled - v2.78
// <platform_info>


    import NonFungibleToken from 0x1d7e57aa55817448


    
    access(all) fun checkAeraNFT0x30cf5dcf6ea8d379Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/aeraNFTs)
      return vaultRef
    }
    

    access(all) fun checkArt0xd796ff17107bbff6Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/versusArtCollection)
      return vaultRef
    }
    

    access(all) fun checkBl0x0x7620acf6d7f2468aVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/bl0xNFTs)
      return vaultRef
    }
    

    access(all) fun checkBobblz_NFT0xd45e2bd9a3d5003bVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/Bobblz_NFTCollection)
      return vaultRef
    }
    

    access(all) fun checkBreakingT_NFT0x329feb3ab062d289Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/BreakingT_NFTCollection)
      return vaultRef
    }
    

    access(all) fun checkBWAYX_NFT0xf02b15e11eb3715bVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/BWAYX_NFTCollection)
      return vaultRef
    }
    

    access(all) fun checkCanes_Vault_NFT0x329feb3ab062d289Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/Canes_Vault_NFTCollection)
      return vaultRef
    }
    

    access(all) fun checkCar0xf887ece39166906eVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/CarCollection)
      return vaultRef
    }
    

    access(all) fun checkCarClub0xf887ece39166906eVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/CarClubCollection)
      return vaultRef
    }
    

    access(all) fun checkCharityNFT0x097bafa4e0b48eefVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/findCharityCollection)
      return vaultRef
    }
    

    access(all) fun checkCryptoPiggoV20xd3df824bf81910a4Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/CryptoPiggoV2Collection)
      return vaultRef
    }
    

    access(all) fun checkDGD_NFT0x329feb3ab062d289Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/DGD_NFTCollection)
      return vaultRef
    }
    

    access(all) fun checkDoodles0xe81193c424cfd3fbVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/doodles)
      return vaultRef
    }
    

    access(all) fun checkDriverzNFT0xa039bd7d55a96c0cVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/DriverzNFTCollection)
      return vaultRef
    }
    

    access(all) fun checkEVMVMBridgedNFT_d112634f06902a977db1d596c77715d72f8da8a90x1e4aa0b87d10b141Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/EVMVMBridgedNFT_d112634f06902a977db1d596c77715d72f8da8a9Collection)
      return vaultRef
    }
    

    access(all) fun checkFLOAT0x2d4c3caffbeab845Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FLOATCollectionPublicPath)
      return vaultRef
    }
    

    access(all) fun checkFlobot0x921ea449dffec68aVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlobotCollection)
      return vaultRef
    }
    

    access(all) fun checkFlovatar0x921ea449dffec68aVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlovatarCollection)
      return vaultRef
    }
    

    access(all) fun checkFlovatarComponent0x921ea449dffec68aVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlovatarComponentCollection)
      return vaultRef
    }
    

    access(all) fun checkFlowRewards0xa45ead1cf1ca9edaVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/flowRewardsCollectionPublic)
      return vaultRef
    }
    

    access(all) fun checkFlowversePass0x9212a87501a8a6a2Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlowversePassCollection)
      return vaultRef
    }
    

    access(all) fun checkFlowverseSocks0xce4c02539d1fabe8Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/MatrixMarketFlowverseSocksCollection)
      return vaultRef
    }
    

    access(all) fun checkFlowverseTreasures0x9212a87501a8a6a2Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlowverseTreasuresCollection)
      return vaultRef
    }
    

    access(all) fun checkFRC20SemiNFT0xd2abb5dbf5e08666Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FRC20SemiNFT_0xd2abb5dbf5e08666collection)
      return vaultRef
    }
    

    access(all) fun checkFuchibola_NFT0xf3ee684cd0259fedVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/Fuchibola_NFTCollection)
      return vaultRef
    }
    

    access(all) fun checkGooberXContract0x34f2bf4a80bb0f69Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/GooberzPartyFolksCollectionPublic)
      return vaultRef
    }
    

    access(all) fun checkHelmet0xf887ece39166906eVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/HelmetCollection)
      return vaultRef
    }
    

    access(all) fun checkIconoGraphika0xa6ee47da88e6cbdeVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/IconoGraphikaNFT)
      return vaultRef
    }
    

    access(all) fun checkJollyJokers0x699bf284101a76f1Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/JollyJokersCollection)
      return vaultRef
    }
    

    access(all) fun checkMagnetiq0x5257f1455ed366feVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/MagnetiqTokensCollection)
      return vaultRef
    }
    

    access(all) fun checkMetaverseMarket0xd756450f386fb4acVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/NftMetaverseMarketCollectionVersionTwo)
      return vaultRef
    }
    

    access(all) fun checkMFLClub0x8ebcbfd516b1da27Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/MFLClubCollection)
      return vaultRef
    }
    

    access(all) fun checkMFLPlayer0x8ebcbfd516b1da27Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/MFLPlayerCollection)
      return vaultRef
    }
    

    access(all) fun checkMIKOSEANFT0x0b80e42aaab305f0Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/MikoSeaCollection)
      return vaultRef
    }
    

    access(all) fun checkNFGv30x123cb666996b8432Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/nfgNFTCollection)
      return vaultRef
    }
    

    access(all) fun checkOneShots0x4f7ff543c936072bVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/TiblesOneShotsCollection)
      return vaultRef
    }
    

    access(all) fun checkPackNFT0xe4cf4bdc1751c65dVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/PackNFTCollectionPub)
      return vaultRef
    }
    

    access(all) fun checkPartyMansionDrinksContract0x34f2bf4a80bb0f69Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/PartyMansionDrinkCollectionPublic)
      return vaultRef
    }
    

    access(all) fun checkPiece0xfdc436fd7db22e01Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/Piece_Collection0xfdc436fd7db22e01)
      return vaultRef
    }
    

    access(all) fun checkPuffPalz0xa3eb9784ae7dc9c8Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/PuffPalzCollection)
      return vaultRef
    }
    

    access(all) fun checkRaceDay_NFT0x329feb3ab062d289Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/RaceDay_NFTCollection)
      return vaultRef
    }
    

    access(all) fun checkRedeemables0xe81193c424cfd3fbVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/redeemables)
      return vaultRef
    }
    

    access(all) fun checkRogueBunnies_NFT0x396646f110afb2e6Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/RogueBunnies_NFTCollection)
      return vaultRef
    }
    

    access(all) fun checkSportbit0xca5c31c0c03e11beVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/SportbitCollection)
      return vaultRef
    }
    

    access(all) fun checkSportvatar0xca5c31c0c03e11beVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/SportvatarCollection)
      return vaultRef
    }
    

    access(all) fun checkTopShot0x0b2a3299cc857e29Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/MomentCollection)
      return vaultRef
    }
    

    access(all) fun checkUFC_NFT0x329feb3ab062d289Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/UFC_NFTCollection)
      return vaultRef
    }
    

    access(all) fun checkWearables0xe81193c424cfd3fbVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/wearables)
      return vaultRef
    }
    

    access(all) fun checkWheel0xf887ece39166906eVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/WheelCollection)
      return vaultRef
    }
    

    access(all) fun checkZeedzINO0x62b3063fbe672fc8Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/ZeedzINOCollection)
      return vaultRef
    }
    

    access(all) fun checkAeraRewards0x30cf5dcf6ea8d379Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/aeraRewardsNFT)
      return vaultRef
    }
    

    access(all) fun checkaiSportsMinter0xabe5a2bf47ce5bf3Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/aiSportsMinterCollection)
      return vaultRef
    }
    

    access(all) fun checkAllDay0xe4cf4bdc1751c65dVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/AllDayNFTCollection)
      return vaultRef
    }
    

    access(all) fun checkBlovizeNFT0xee4567ab7f63abf2Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/blovizeNFTCollection)
      return vaultRef
    }
    

    access(all) fun checkBoneyard0x7a9442be0b3c178aVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/BoneyardCollection)
      return vaultRef
    }
    

    access(all) fun checkCimelio_NFT0x2c9de937c319468dVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/Cimelio_NFTCollection)
      return vaultRef
    }
    

    access(all) fun checkCryptoPiggo0xd3df824bf81910a4Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/CryptoPiggoCollection)
      return vaultRef
    }
    

    access(all) fun checkCryptoPiggoPotion0xd3df824bf81910a4Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/CryptoPiggoPotionCollection)
      return vaultRef
    }
    

    access(all) fun checkDimensionX0xe3ad6030cbaff1c2Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/dmxCollection)
      return vaultRef
    }
    

    access(all) fun checkDomains0x233eb012d34b0070Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/fnsDomainCollection)
      return vaultRef
    }
    

    access(all) fun checkFantastecNFT0x4bbff461fa8f6192Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FantastecNFTCollection)
      return vaultRef
    }
    

    access(all) fun checkFlovatarDustCollectible0x921ea449dffec68aVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlovatarDustCollectibleCollection)
      return vaultRef
    }
    

    access(all) fun checkFlowtyWrapped0x592eb32b47d8b85fVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlowtyWrapped_0x592eb32b47d8b85f)
      return vaultRef
    }
    

    access(all) fun checkFlowverseShirt0x9212a87501a8a6a2Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlowverseShirtCollection)
      return vaultRef
    }
    

    access(all) fun checkGaia0x8b148183c28ff88fVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/GaiaCollection001)
      return vaultRef
    }
    

    access(all) fun checkGolazos0x87ca73a41bb50ad5Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/GolazosNFTCollection)
      return vaultRef
    }
    

    access(all) fun checkHeroesOfTheFlow0x1dc37ab51a54d83fVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/HeroesOfTheFlowCollection)
      return vaultRef
    }
    

    access(all) fun checkHWGarageCard0xd0bcefdf1e67ea85Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/HWGarageCardCollection)
      return vaultRef
    }
    

    access(all) fun checkKaratNFT0x82ed1b9cba5bb1b3Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/KaratNFTCollection)
      return vaultRef
    }
    

    access(all) fun checkKeeprItems0x5eb12ad3d5a99945Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/KeeprItemsCollectionV10)
      return vaultRef
    }
    

    access(all) fun checkMatrixWorldVoucher0x0d77ec47bbad8ef6Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/MatrixWorldVoucherCollection)
      return vaultRef
    }
    

    access(all) fun checkMFLPack0x8ebcbfd516b1da27Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/MFLPackCollection)
      return vaultRef
    }
    

    access(all) fun checkOrdinal0x9212a87501a8a6a2Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/OrdinalCollection)
      return vaultRef
    }
    

    access(all) fun checkSeussibles0x321d8fcde05f6e8cVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/TiblesSeussiblesCollection)
      return vaultRef
    }
    

    access(all) fun checkSk8tibles0x0a2fbb92a8ae5c6dVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/TiblesSk8tiblesCollection)
      return vaultRef
    }
    

    access(all) fun checkStarlyCard0x5b82f21c0edf76e3Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/starlyCardCollection)
      return vaultRef
    }
    

    access(all) fun checkSturdyItems0x427ceada271aa0b1Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/SturdyItemsCollection)
      return vaultRef
    }
    

    access(all) fun checkSemesterZeroV30xce9dd43888d99574Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/SemesterZeroV3Collection)
      return vaultRef
    }
    
    access(all) fun main(address: Address) : {String: Bool} {
      return {
    "A.30cf5dcf6ea8d379.AeraNFT" :
    checkAeraNFT0x30cf5dcf6ea8d379Vault(address: address)
    ,
    "A.d796ff17107bbff6.Art" :
    checkArt0xd796ff17107bbff6Vault(address: address)
    ,
    "A.7620acf6d7f2468a.Bl0x" :
    checkBl0x0x7620acf6d7f2468aVault(address: address)
    ,
    "A.d45e2bd9a3d5003b.Bobblz_NFT" :
    checkBobblz_NFT0xd45e2bd9a3d5003bVault(address: address)
    ,
    "A.329feb3ab062d289.BreakingT_NFT" :
    checkBreakingT_NFT0x329feb3ab062d289Vault(address: address)
    ,
    "A.f02b15e11eb3715b.BWAYX_NFT" :
    checkBWAYX_NFT0xf02b15e11eb3715bVault(address: address)
    ,
    "A.329feb3ab062d289.Canes_Vault_NFT" :
    checkCanes_Vault_NFT0x329feb3ab062d289Vault(address: address)
    ,
    "A.f887ece39166906e.Car" :
    checkCar0xf887ece39166906eVault(address: address)
    ,
    "A.f887ece39166906e.CarClub" :
    checkCarClub0xf887ece39166906eVault(address: address)
    ,
    "A.097bafa4e0b48eef.CharityNFT" :
    checkCharityNFT0x097bafa4e0b48eefVault(address: address)
    ,
    "A.d3df824bf81910a4.CryptoPiggoV2" :
    checkCryptoPiggoV20xd3df824bf81910a4Vault(address: address)
    ,
    "A.329feb3ab062d289.DGD_NFT" :
    checkDGD_NFT0x329feb3ab062d289Vault(address: address)
    ,
    "A.e81193c424cfd3fb.Doodles" :
    checkDoodles0xe81193c424cfd3fbVault(address: address)
    ,
    "A.a039bd7d55a96c0c.DriverzNFT" :
    checkDriverzNFT0xa039bd7d55a96c0cVault(address: address)
    ,
    "A.1e4aa0b87d10b141.EVMVMBridgedNFT_d112634f06902a977db1d596c77715d72f8da8a9" :
    checkEVMVMBridgedNFT_d112634f06902a977db1d596c77715d72f8da8a90x1e4aa0b87d10b141Vault(address: address)
    ,
    "A.2d4c3caffbeab845.FLOAT" :
    checkFLOAT0x2d4c3caffbeab845Vault(address: address)
    ,
    "A.921ea449dffec68a.Flobot" :
    checkFlobot0x921ea449dffec68aVault(address: address)
    ,
    "A.921ea449dffec68a.Flovatar" :
    checkFlovatar0x921ea449dffec68aVault(address: address)
    ,
    "A.921ea449dffec68a.FlovatarComponent" :
    checkFlovatarComponent0x921ea449dffec68aVault(address: address)
    ,
    "A.a45ead1cf1ca9eda.FlowRewards" :
    checkFlowRewards0xa45ead1cf1ca9edaVault(address: address)
    ,
    "A.9212a87501a8a6a2.FlowversePass" :
    checkFlowversePass0x9212a87501a8a6a2Vault(address: address)
    ,
    "A.ce4c02539d1fabe8.FlowverseSocks" :
    checkFlowverseSocks0xce4c02539d1fabe8Vault(address: address)
    ,
    "A.9212a87501a8a6a2.FlowverseTreasures" :
    checkFlowverseTreasures0x9212a87501a8a6a2Vault(address: address)
    ,
    "A.d2abb5dbf5e08666.FRC20SemiNFT" :
    checkFRC20SemiNFT0xd2abb5dbf5e08666Vault(address: address)
    ,
    "A.f3ee684cd0259fed.Fuchibola_NFT" :
    checkFuchibola_NFT0xf3ee684cd0259fedVault(address: address)
    ,
    "A.34f2bf4a80bb0f69.GooberXContract" :
    checkGooberXContract0x34f2bf4a80bb0f69Vault(address: address)
    ,
    "A.f887ece39166906e.Helmet" :
    checkHelmet0xf887ece39166906eVault(address: address)
    ,
    "A.a6ee47da88e6cbde.IconoGraphika" :
    checkIconoGraphika0xa6ee47da88e6cbdeVault(address: address)
    ,
    "A.699bf284101a76f1.JollyJokers" :
    checkJollyJokers0x699bf284101a76f1Vault(address: address)
    ,
    "A.5257f1455ed366fe.Magnetiq" :
    checkMagnetiq0x5257f1455ed366feVault(address: address)
    ,
    "A.d756450f386fb4ac.MetaverseMarket" :
    checkMetaverseMarket0xd756450f386fb4acVault(address: address)
    ,
    "A.8ebcbfd516b1da27.MFLClub" :
    checkMFLClub0x8ebcbfd516b1da27Vault(address: address)
    ,
    "A.8ebcbfd516b1da27.MFLPlayer" :
    checkMFLPlayer0x8ebcbfd516b1da27Vault(address: address)
    ,
    "A.0b80e42aaab305f0.MIKOSEANFT" :
    checkMIKOSEANFT0x0b80e42aaab305f0Vault(address: address)
    ,
    "A.123cb666996b8432.NFGv3" :
    checkNFGv30x123cb666996b8432Vault(address: address)
    ,
    "A.4f7ff543c936072b.OneShots" :
    checkOneShots0x4f7ff543c936072bVault(address: address)
    ,
    "A.e4cf4bdc1751c65d.PackNFT" :
    checkPackNFT0xe4cf4bdc1751c65dVault(address: address)
    ,
    "A.34f2bf4a80bb0f69.PartyMansionDrinksContract" :
    checkPartyMansionDrinksContract0x34f2bf4a80bb0f69Vault(address: address)
    ,
    "A.fdc436fd7db22e01.Piece" :
    checkPiece0xfdc436fd7db22e01Vault(address: address)
    ,
    "A.a3eb9784ae7dc9c8.PuffPalz" :
    checkPuffPalz0xa3eb9784ae7dc9c8Vault(address: address)
    ,
    "A.329feb3ab062d289.RaceDay_NFT" :
    checkRaceDay_NFT0x329feb3ab062d289Vault(address: address)
    ,
    "A.e81193c424cfd3fb.Redeemables" :
    checkRedeemables0xe81193c424cfd3fbVault(address: address)
    ,
    "A.396646f110afb2e6.RogueBunnies_NFT" :
    checkRogueBunnies_NFT0x396646f110afb2e6Vault(address: address)
    ,
    "A.ca5c31c0c03e11be.Sportbit" :
    checkSportbit0xca5c31c0c03e11beVault(address: address)
    ,
    "A.ca5c31c0c03e11be.Sportvatar" :
    checkSportvatar0xca5c31c0c03e11beVault(address: address)
    ,
    "A.0b2a3299cc857e29.TopShot" :
    checkTopShot0x0b2a3299cc857e29Vault(address: address)
    ,
    "A.329feb3ab062d289.UFC_NFT" :
    checkUFC_NFT0x329feb3ab062d289Vault(address: address)
    ,
    "A.e81193c424cfd3fb.Wearables" :
    checkWearables0xe81193c424cfd3fbVault(address: address)
    ,
    "A.f887ece39166906e.Wheel" :
    checkWheel0xf887ece39166906eVault(address: address)
    ,
    "A.62b3063fbe672fc8.ZeedzINO" :
    checkZeedzINO0x62b3063fbe672fc8Vault(address: address)
    ,
    "A.30cf5dcf6ea8d379.AeraRewards" :
    checkAeraRewards0x30cf5dcf6ea8d379Vault(address: address)
    ,
    "A.abe5a2bf47ce5bf3.aiSportsMinter" :
    checkaiSportsMinter0xabe5a2bf47ce5bf3Vault(address: address)
    ,
    "A.e4cf4bdc1751c65d.AllDay" :
    checkAllDay0xe4cf4bdc1751c65dVault(address: address)
    ,
    "A.ee4567ab7f63abf2.BlovizeNFT" :
    checkBlovizeNFT0xee4567ab7f63abf2Vault(address: address)
    ,
    "A.7a9442be0b3c178a.Boneyard" :
    checkBoneyard0x7a9442be0b3c178aVault(address: address)
    ,
    "A.2c9de937c319468d.Cimelio_NFT" :
    checkCimelio_NFT0x2c9de937c319468dVault(address: address)
    ,
    "A.d3df824bf81910a4.CryptoPiggo" :
    checkCryptoPiggo0xd3df824bf81910a4Vault(address: address)
    ,
    "A.d3df824bf81910a4.CryptoPiggoPotion" :
    checkCryptoPiggoPotion0xd3df824bf81910a4Vault(address: address)
    ,
    "A.e3ad6030cbaff1c2.DimensionX" :
    checkDimensionX0xe3ad6030cbaff1c2Vault(address: address)
    ,
    "A.233eb012d34b0070.Domains" :
    checkDomains0x233eb012d34b0070Vault(address: address)
    ,
    "A.4bbff461fa8f6192.FantastecNFT" :
    checkFantastecNFT0x4bbff461fa8f6192Vault(address: address)
    ,
    "A.921ea449dffec68a.FlovatarDustCollectible" :
    checkFlovatarDustCollectible0x921ea449dffec68aVault(address: address)
    ,
    "A.592eb32b47d8b85f.FlowtyWrapped" :
    checkFlowtyWrapped0x592eb32b47d8b85fVault(address: address)
    ,
    "A.9212a87501a8a6a2.FlowverseShirt" :
    checkFlowverseShirt0x9212a87501a8a6a2Vault(address: address)
    ,
    "A.8b148183c28ff88f.Gaia" :
    checkGaia0x8b148183c28ff88fVault(address: address)
    ,
    "A.87ca73a41bb50ad5.Golazos" :
    checkGolazos0x87ca73a41bb50ad5Vault(address: address)
    ,
    "A.1dc37ab51a54d83f.HeroesOfTheFlow" :
    checkHeroesOfTheFlow0x1dc37ab51a54d83fVault(address: address)
    ,
    "A.d0bcefdf1e67ea85.HWGarageCard" :
    checkHWGarageCard0xd0bcefdf1e67ea85Vault(address: address)
    ,
    "A.82ed1b9cba5bb1b3.KaratNFT" :
    checkKaratNFT0x82ed1b9cba5bb1b3Vault(address: address)
    ,
    "A.5eb12ad3d5a99945.KeeprItems" :
    checkKeeprItems0x5eb12ad3d5a99945Vault(address: address)
    ,
    "A.0d77ec47bbad8ef6.MatrixWorldVoucher" :
    checkMatrixWorldVoucher0x0d77ec47bbad8ef6Vault(address: address)
    ,
    "A.8ebcbfd516b1da27.MFLPack" :
    checkMFLPack0x8ebcbfd516b1da27Vault(address: address)
    ,
    "A.9212a87501a8a6a2.Ordinal" :
    checkOrdinal0x9212a87501a8a6a2Vault(address: address)
    ,
    "A.321d8fcde05f6e8c.Seussibles" :
    checkSeussibles0x321d8fcde05f6e8cVault(address: address)
    ,
    "A.0a2fbb92a8ae5c6d.Sk8tibles" :
    checkSk8tibles0x0a2fbb92a8ae5c6dVault(address: address)
    ,
    "A.5b82f21c0edf76e3.StarlyCard" :
    checkStarlyCard0x5b82f21c0edf76e3Vault(address: address)
    ,
    "A.427ceada271aa0b1.SturdyItems" :
    checkSturdyItems0x427ceada271aa0b1Vault(address: address)
    ,
    "A.ce9dd43888d99574.SemesterZeroV3" :
    checkSemesterZeroV30xce9dd43888d99574Vault(address: address)
    }
    }
  " + }, + "staking": { + "checkSetup": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY2hlY2tTZXR1cCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dTdGFraW5nQ29sbGVjdGlvbiBmcm9tIDB4OGQwZTg3YjY1MTU5YWU2MwoKCi8vLyBEZXRlcm1pbmVzIGlmIGFuIGFjY291bnQgaXMgc2V0IHVwIHdpdGggYSBTdGFraW5nIENvbGxlY3Rpb24KCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBCb29sIHsKICAgIHJldHVybiBGbG93U3Rha2luZ0NvbGxlY3Rpb24uZG9lc0FjY291bnRIYXZlU3Rha2luZ0NvbGxlY3Rpb24oYWRkcmVzczogYWRkcmVzcykKfQ\u003d\u003d", + "checkStakingEnabled": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY2hlY2tTdGFraW5nRW5hYmxlZCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dJRFRhYmxlU3Rha2luZyBmcm9tIDB4ODYyNGI1MmY5ZGRjZDA0YQoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKCk6Qm9vbCB7CiAgICByZXR1cm4gRmxvd0lEVGFibGVTdGFraW5nLnN0YWtpbmdFbmFibGVkKCkKfQ\u003d\u003d", + "closeStake": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY2xvc2VTdGFrZSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dTdGFraW5nQ29sbGVjdGlvbiBmcm9tIDB4OGQwZTg3YjY1MTU5YWU2MwoKCi8vIENsb3NlcyBvdXQgYSBzdGFraW5nIG9iamVjdCBpbiB0aGUgc3Rha2luZyBjb2xsZWN0aW9uCi8vIFRoaXMgZG9lcyBub3QgcmVtb3ZlIHRoZSByZWNvcmQgZnJvbSB0aGUgaWRlbnRpdHkgdGFibGUsCi8vIGJ1dCBpdCBkb2VzIG1lYW4gdGhhdCB0aGUgYWNjb3VudCB0aGF0IGNsb3NlcyBpdCBjYW5ub3QgZXZlciBhY2Nlc3MgaXQgYWdhaW4KCnRyYW5zYWN0aW9uKG5vZGVJRDogU3RyaW5nLCBkZWxlZ2F0b3JJRDogVUludDMyPykgewogICAgCiAgICBsZXQgc3Rha2luZ0NvbGxlY3Rpb25SZWY6IGF1dGgoRmxvd1N0YWtpbmdDb2xsZWN0aW9uLkNvbGxlY3Rpb25Pd25lcikgJkZsb3dTdGFraW5nQ29sbGVjdGlvbi5TdGFraW5nQ29sbGVjdGlvbgoKICAgIHByZXBhcmUoYWNjb3VudDogYXV0aChCb3Jyb3dWYWx1ZSkgJkFjY291bnQpIHsKICAgICAgICBzZWxmLnN0YWtpbmdDb2xsZWN0aW9uUmVmID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzxhdXRoKEZsb3dTdGFraW5nQ29sbGVjdGlvbi5Db2xsZWN0aW9uT3duZXIpICZGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb24+KGZyb206IEZsb3dTdGFraW5nQ29sbGVjdGlvbi5TdGFraW5nQ29sbGVjdGlvblN0b3JhZ2VQYXRoKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBhIHJlZmVyZW5jZSB0byBhIFN0YWtpbmdDb2xsZWN0aW9uIGluIHRoZSBwcmltYXJ5IHVzZXIncyBhY2NvdW50IikKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBzZWxmLnN0YWtpbmdDb2xsZWN0aW9uUmVmLmNsb3NlU3Rha2Uobm9kZUlEOiBub2RlSUQsIGRlbGVnYXRvcklEOiBkZWxlZ2F0b3JJRCkKICAgIH0KfQ\u003d\u003d", + "createDelegator": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY3JlYXRlRGVsZWdhdG9yIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd1N0YWtpbmdDb2xsZWN0aW9uIGZyb20gMHg4ZDBlODdiNjUxNTlhZTYzCgoKLy8vIFJlZ2lzdGVycyBhIGRlbGVnYXRvciBpbiB0aGUgc3Rha2luZyBjb2xsZWN0aW9uIHJlc291cmNlCi8vLyBmb3IgdGhlIHNwZWNpZmllZCBub2RlSUQgYW5kIHRoZSBhbW91bnQgb2YgdG9rZW5zIHRvIGNvbW1pdAoKdHJhbnNhY3Rpb24oaWQ6IFN0cmluZywgYW1vdW50OiBVRml4NjQpIHsKICAgIAogICAgbGV0IHN0YWtpbmdDb2xsZWN0aW9uUmVmOiBhdXRoKEZsb3dTdGFraW5nQ29sbGVjdGlvbi5Db2xsZWN0aW9uT3duZXIpICZGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb24KCiAgICBwcmVwYXJlKGFjY291bnQ6IGF1dGgoQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZiA9IGFjY291bnQuc3RvcmFnZS5ib3Jyb3c8YXV0aChGbG93U3Rha2luZ0NvbGxlY3Rpb24uQ29sbGVjdGlvbk93bmVyKSAmRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uPihmcm9tOiBGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb25TdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgYSByZWZlcmVuY2UgdG8gYSBTdGFraW5nQ29sbGVjdGlvbiBpbiB0aGUgcHJpbWFyeSB1c2VyJ3MgYWNjb3VudCIpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZi5yZWdpc3RlckRlbGVnYXRvcihub2RlSUQ6IGlkLCBhbW91bnQ6IGFtb3VudCkgICAgICAKICAgIH0KfQ\u003d\u003d", + "createStake": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY3JlYXRlU3Rha2UgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGbG93U3Rha2luZ0NvbGxlY3Rpb24gZnJvbSAweDhkMGU4N2I2NTE1OWFlNjMKCgovLy8gQ29tbWl0cyBuZXcgdG9rZW5zIHRvIHN0YWtlIGZvciB0aGUgc3BlY2lmaWVkIG5vZGUgb3IgZGVsZWdhdG9yIGluIHRoZSBzdGFraW5nIGNvbGxlY3Rpb24KLy8vIFRoZSB0b2tlbnMgZnJvbSB0aGUgbG9ja2VkIHZhdWx0IGFyZSB1c2VkIGZpcnN0LCBpZiBpdCBleGlzdHMKLy8vIGZvbGxvd2VkIGJ5IHRoZSB0b2tlbnMgZnJvbSB0aGUgdW5sb2NrZWQgdmF1bHQKCnRyYW5zYWN0aW9uKG5vZGVJRDogU3RyaW5nLCBkZWxlZ2F0b3JJRDogVUludDMyPywgYW1vdW50OiBVRml4NjQpIHsKICAgIAogICAgbGV0IHN0YWtpbmdDb2xsZWN0aW9uUmVmOiBhdXRoKEZsb3dTdGFraW5nQ29sbGVjdGlvbi5Db2xsZWN0aW9uT3duZXIpICZGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb24KCiAgICBwcmVwYXJlKGFjY291bnQ6IGF1dGgoQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZiA9IGFjY291bnQuc3RvcmFnZS5ib3Jyb3c8YXV0aChGbG93U3Rha2luZ0NvbGxlY3Rpb24uQ29sbGVjdGlvbk93bmVyKSAmRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uPihmcm9tOiBGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb25TdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgYSByZWZlcmVuY2UgdG8gYSBTdGFraW5nQ29sbGVjdGlvbiBpbiB0aGUgcHJpbWFyeSB1c2VyJ3MgYWNjb3VudCIpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZi5zdGFrZU5ld1Rva2Vucyhub2RlSUQ6IG5vZGVJRCwgZGVsZWdhdG9ySUQ6IGRlbGVnYXRvcklELCBhbW91bnQ6IGFtb3VudCkKICAgIH0KfQ\u003d\u003d", + "getApr": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QXByIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd0lEVGFibGVTdGFraW5nIGZyb20gMHg4NjI0YjUyZjlkZGNkMDRhCgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oKTogVUZpeDY0IHsKICAgIGxldCBhcHIgPSBGbG93SURUYWJsZVN0YWtpbmcuZ2V0RXBvY2hUb2tlblBheW91dCgpIC8gRmxvd0lEVGFibGVTdGFraW5nLmdldFRvdGFsU3Rha2VkKCkgLyA3LjAgKiAzNjUuMCAqICgxLjAgLSBGbG93SURUYWJsZVN0YWtpbmcuZ2V0UmV3YXJkQ3V0UGVyY2VudGFnZSgpKQogICAgcmV0dXJuIGFwcgp9", + "getApyWeekly": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QXB5V2Vla2x5IC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd0lEVGFibGVTdGFraW5nIGZyb20gMHg4NjI0YjUyZjlkZGNkMDRhCgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oKTogVUZpeDY0IHsKICAgIGxldCBhcHIgPSBGbG93SURUYWJsZVN0YWtpbmcuZ2V0RXBvY2hUb2tlblBheW91dCgpIC8gRmxvd0lEVGFibGVTdGFraW5nLmdldFRvdGFsU3Rha2VkKCkgKiA1NC4wICogKDEuMCAtIEZsb3dJRFRhYmxlU3Rha2luZy5nZXRSZXdhcmRDdXRQZXJjZW50YWdlKCkpCiAgICByZXR1cm4gYXByCn0\u003d", + "getDelegatesIndo": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0RGVsZWdhdGVzSW5kbyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKCmltcG9ydCBGbG93U3Rha2luZ0NvbGxlY3Rpb24gZnJvbSAweDhkMGU4N2I2NTE1OWFlNjMKCmltcG9ydCBGbG93SURUYWJsZVN0YWtpbmcgZnJvbSAweDg2MjRiNTJmOWRkY2QwNGEKCmltcG9ydCBMb2NrZWRUb2tlbnMgZnJvbSAweDhkMGU4N2I2NTE1OWFlNjMKCgphY2Nlc3MoYWxsKSBzdHJ1Y3QgRGVsZWdhdGVJbmZvIHsKICAgIGFjY2VzcyhhbGwpIGxldCBkZWxlZ2F0b3JJRDogVUludDMyCiAgICBhY2Nlc3MoYWxsKSBsZXQgbm9kZUlEOiBTdHJpbmcKICAgIGFjY2VzcyhhbGwpIGxldCB0b2tlbnNDb21taXR0ZWQ6IFVGaXg2NAogICAgYWNjZXNzKGFsbCkgbGV0IHRva2Vuc1N0YWtlZDogVUZpeDY0CiAgICBhY2Nlc3MoYWxsKSBsZXQgdG9rZW5zVW5zdGFraW5nOiBVRml4NjQKICAgIGFjY2VzcyhhbGwpIGxldCB0b2tlbnNSZXdhcmRlZDogVUZpeDY0CiAgICBhY2Nlc3MoYWxsKSBsZXQgdG9rZW5zVW5zdGFrZWQ6IFVGaXg2NAogICAgYWNjZXNzKGFsbCkgbGV0IHRva2Vuc1JlcXVlc3RlZFRvVW5zdGFrZTogVUZpeDY0CgogICAgLy8gUHJvamVjdGVkIFZhbHVlcwoKICAgIGFjY2VzcyhhbGwpIGxldCBpZDogU3RyaW5nCiAgICBhY2Nlc3MoYWxsKSBsZXQgcm9sZTogVUludDgKICAgIGFjY2VzcyhhbGwpIGxldCB1bnN0YWthYmxlVG9rZW5zOiBVRml4NjQKICAgIGFjY2VzcyhhbGwpIGxldCBkZWxlZ2F0ZWROb2RlSW5mbzogRmxvd0lEVGFibGVTdGFraW5nLk5vZGVJbmZvCiAgICBhY2Nlc3MoYWxsKSBsZXQgcmVzdGFrYWJsZVVuc3Rha2VkVG9rZW5zOiBVRml4NjQKCiAgICBpbml0KGRlbGVnYXRvckluZm86IEZsb3dJRFRhYmxlU3Rha2luZy5EZWxlZ2F0b3JJbmZvKSB7CiAgICAgICAgc2VsZi5kZWxlZ2F0b3JJRCA9IGRlbGVnYXRvckluZm8uaWQKICAgICAgICBzZWxmLm5vZGVJRCA9IGRlbGVnYXRvckluZm8ubm9kZUlECiAgICAgICAgc2VsZi50b2tlbnNDb21taXR0ZWQgPSBkZWxlZ2F0b3JJbmZvLnRva2Vuc0NvbW1pdHRlZAogICAgICAgIHNlbGYudG9rZW5zU3Rha2VkID0gZGVsZWdhdG9ySW5mby50b2tlbnNTdGFrZWQKICAgICAgICBzZWxmLnRva2Vuc1Vuc3Rha2luZyA9IGRlbGVnYXRvckluZm8udG9rZW5zVW5zdGFraW5nCiAgICAgICAgc2VsZi50b2tlbnNVbnN0YWtlZCA9IGRlbGVnYXRvckluZm8udG9rZW5zVW5zdGFrZWQKICAgICAgICBzZWxmLnRva2Vuc1Jld2FyZGVkID0gZGVsZWdhdG9ySW5mby50b2tlbnNSZXdhcmRlZAogICAgICAgIHNlbGYudG9rZW5zUmVxdWVzdGVkVG9VbnN0YWtlID0gZGVsZWdhdG9ySW5mby50b2tlbnNSZXF1ZXN0ZWRUb1Vuc3Rha2UKCiAgICAgICAgLy8gUHJvamVjdGVkIFZhbHVlcwogICAgICAgIGxldCBub2RlSW5mbyA9IEZsb3dJRFRhYmxlU3Rha2luZy5Ob2RlSW5mbyhub2RlSUQ6IGRlbGVnYXRvckluZm8ubm9kZUlEKQogICAgICAgIHNlbGYuZGVsZWdhdGVkTm9kZUluZm8gPSBub2RlSW5mbwogICAgICAgIHNlbGYuaWQgPSBub2RlSW5mby5pZAogICAgICAgIHNlbGYucm9sZSA9IG5vZGVJbmZvLnJvbGUKICAgICAgICBzZWxmLnVuc3Rha2FibGVUb2tlbnMgPSBzZWxmLnRva2Vuc1N0YWtlZCArIHNlbGYudG9rZW5zQ29tbWl0dGVkCiAgICAgICAgc2VsZi5yZXN0YWthYmxlVW5zdGFrZWRUb2tlbnMgPSBzZWxmLnRva2Vuc1Vuc3Rha2VkICsgc2VsZi50b2tlbnNSZXF1ZXN0ZWRUb1Vuc3Rha2UKICAgIH0KfQoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWNjb3VudDogQWRkcmVzcyk6IHtTdHJpbmc6IHtVSW50MzI6IERlbGVnYXRlSW5mb319PyB7CiAgICBsZXQgZG9lc0FjY291bnRIYXZlU3Rha2luZ0NvbGxlY3Rpb24gPSBGbG93U3Rha2luZ0NvbGxlY3Rpb24uZG9lc0FjY291bnRIYXZlU3Rha2luZ0NvbGxlY3Rpb24oYWRkcmVzczogYWNjb3VudCkKICAgIGlmICghZG9lc0FjY291bnRIYXZlU3Rha2luZ0NvbGxlY3Rpb24pIHsKICAgICAgICByZXR1cm4gbmlsCiAgICB9CgogICAgbGV0IGRlbGVnYXRvcklEczogW0Zsb3dTdGFraW5nQ29sbGVjdGlvbi5EZWxlZ2F0b3JJRHNdID0gRmxvd1N0YWtpbmdDb2xsZWN0aW9uLmdldERlbGVnYXRvcklEcyhhZGRyZXNzOiBhY2NvdW50KQoKICAgIGxldCBmb3JtYXR0ZWREZWxlZ2F0b3JJbmZvOiB7U3RyaW5nOiB7VUludDMyOiBEZWxlZ2F0ZUluZm99fSA9IHt9CgogICAgZm9yIGRlbGVnYXRvcklEIGluIGRlbGVnYXRvcklEcyB7CiAgICAgICAgaWYgbGV0IF9mb3JtYXR0ZWREZWxlZ2F0b3JJbmZvID0gZm9ybWF0dGVkRGVsZWdhdG9ySW5mb1tkZWxlZ2F0b3JJRC5kZWxlZ2F0b3JOb2RlSURdIHsKICAgICAgICAgICAgbGV0IGRlbGVnYXRvckluZm86IEZsb3dJRFRhYmxlU3Rha2luZy5EZWxlZ2F0b3JJbmZvID0gRmxvd0lEVGFibGVTdGFraW5nLkRlbGVnYXRvckluZm8obm9kZUlEOiBkZWxlZ2F0b3JJRC5kZWxlZ2F0b3JOb2RlSUQsIGRlbGVnYXRvcklEOiBkZWxlZ2F0b3JJRC5kZWxlZ2F0b3JJRCkKICAgICAgICAgICAgX2Zvcm1hdHRlZERlbGVnYXRvckluZm9bZGVsZWdhdG9ySUQuZGVsZWdhdG9ySURdID0gRGVsZWdhdGVJbmZvKGRlbGVnYXRvckluZm86IGRlbGVnYXRvckluZm8pCiAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgbGV0IGRlbGVnYXRvckluZm86IEZsb3dJRFRhYmxlU3Rha2luZy5EZWxlZ2F0b3JJbmZvID0gRmxvd0lEVGFibGVTdGFraW5nLkRlbGVnYXRvckluZm8obm9kZUlEOiBkZWxlZ2F0b3JJRC5kZWxlZ2F0b3JOb2RlSUQsIGRlbGVnYXRvcklEOiBkZWxlZ2F0b3JJRC5kZWxlZ2F0b3JJRCkKICAgICAgICAgICAgZm9ybWF0dGVkRGVsZWdhdG9ySW5mb1tkZWxlZ2F0b3JJRC5kZWxlZ2F0b3JOb2RlSURdID0geyBkZWxlZ2F0b3JJRC5kZWxlZ2F0b3JJRDogRGVsZWdhdGVJbmZvKGRlbGVnYXRvckluZm86IGRlbGVnYXRvckluZm8pfQogICAgICAgIH0KICAgIH0KCiAgICByZXR1cm4gZm9ybWF0dGVkRGVsZWdhdG9ySW5mbwp9Cg\u003d\u003d", + "getDelegatesInfo": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0RGVsZWdhdGVzSW5mbyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKCmltcG9ydCBGbG93U3Rha2luZ0NvbGxlY3Rpb24gZnJvbSAweDhkMGU4N2I2NTE1OWFlNjMKCmltcG9ydCBGbG93SURUYWJsZVN0YWtpbmcgZnJvbSAweDg2MjRiNTJmOWRkY2QwNGEKCmltcG9ydCBMb2NrZWRUb2tlbnMgZnJvbSAweDhkMGU4N2I2NTE1OWFlNjMKCgphY2Nlc3MoYWxsKSBzdHJ1Y3QgRGVsZWdhdGVJbmZvIHsKICAgIGFjY2VzcyhhbGwpIGxldCBkZWxlZ2F0b3JJRDogVUludDMyCiAgICBhY2Nlc3MoYWxsKSBsZXQgbm9kZUlEOiBTdHJpbmcKICAgIGFjY2VzcyhhbGwpIGxldCB0b2tlbnNDb21taXR0ZWQ6IFVGaXg2NAogICAgYWNjZXNzKGFsbCkgbGV0IHRva2Vuc1N0YWtlZDogVUZpeDY0CiAgICBhY2Nlc3MoYWxsKSBsZXQgdG9rZW5zVW5zdGFraW5nOiBVRml4NjQKICAgIGFjY2VzcyhhbGwpIGxldCB0b2tlbnNSZXdhcmRlZDogVUZpeDY0CiAgICBhY2Nlc3MoYWxsKSBsZXQgdG9rZW5zVW5zdGFrZWQ6IFVGaXg2NAogICAgYWNjZXNzKGFsbCkgbGV0IHRva2Vuc1JlcXVlc3RlZFRvVW5zdGFrZTogVUZpeDY0CgogICAgLy8gUHJvamVjdGVkIFZhbHVlcwoKICAgIGFjY2VzcyhhbGwpIGxldCBpZDogU3RyaW5nCiAgICBhY2Nlc3MoYWxsKSBsZXQgcm9sZTogVUludDgKICAgIGFjY2VzcyhhbGwpIGxldCB1bnN0YWthYmxlVG9rZW5zOiBVRml4NjQKICAgIGFjY2VzcyhhbGwpIGxldCBkZWxlZ2F0ZWROb2RlSW5mbzogRmxvd0lEVGFibGVTdGFraW5nLk5vZGVJbmZvCiAgICBhY2Nlc3MoYWxsKSBsZXQgcmVzdGFrYWJsZVVuc3Rha2VkVG9rZW5zOiBVRml4NjQKCiAgICBpbml0KGRlbGVnYXRvckluZm86IEZsb3dJRFRhYmxlU3Rha2luZy5EZWxlZ2F0b3JJbmZvKSB7CiAgICAgICAgc2VsZi5kZWxlZ2F0b3JJRCA9IGRlbGVnYXRvckluZm8uaWQKICAgICAgICBzZWxmLm5vZGVJRCA9IGRlbGVnYXRvckluZm8ubm9kZUlECiAgICAgICAgc2VsZi50b2tlbnNDb21taXR0ZWQgPSBkZWxlZ2F0b3JJbmZvLnRva2Vuc0NvbW1pdHRlZAogICAgICAgIHNlbGYudG9rZW5zU3Rha2VkID0gZGVsZWdhdG9ySW5mby50b2tlbnNTdGFrZWQKICAgICAgICBzZWxmLnRva2Vuc1Vuc3Rha2luZyA9IGRlbGVnYXRvckluZm8udG9rZW5zVW5zdGFraW5nCiAgICAgICAgc2VsZi50b2tlbnNVbnN0YWtlZCA9IGRlbGVnYXRvckluZm8udG9rZW5zVW5zdGFrZWQKICAgICAgICBzZWxmLnRva2Vuc1Jld2FyZGVkID0gZGVsZWdhdG9ySW5mby50b2tlbnNSZXdhcmRlZAogICAgICAgIHNlbGYudG9rZW5zUmVxdWVzdGVkVG9VbnN0YWtlID0gZGVsZWdhdG9ySW5mby50b2tlbnNSZXF1ZXN0ZWRUb1Vuc3Rha2UKCiAgICAgICAgLy8gUHJvamVjdGVkIFZhbHVlcwogICAgICAgIGxldCBub2RlSW5mbyA9IEZsb3dJRFRhYmxlU3Rha2luZy5Ob2RlSW5mbyhub2RlSUQ6IGRlbGVnYXRvckluZm8ubm9kZUlEKQogICAgICAgIHNlbGYuZGVsZWdhdGVkTm9kZUluZm8gPSBub2RlSW5mbwogICAgICAgIHNlbGYuaWQgPSBub2RlSW5mby5pZAogICAgICAgIHNlbGYucm9sZSA9IG5vZGVJbmZvLnJvbGUKICAgICAgICBzZWxmLnVuc3Rha2FibGVUb2tlbnMgPSBzZWxmLnRva2Vuc1N0YWtlZCArIHNlbGYudG9rZW5zQ29tbWl0dGVkCiAgICAgICAgc2VsZi5yZXN0YWthYmxlVW5zdGFrZWRUb2tlbnMgPSBzZWxmLnRva2Vuc1Vuc3Rha2VkICsgc2VsZi50b2tlbnNSZXF1ZXN0ZWRUb1Vuc3Rha2UKICAgIH0KfQoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWNjb3VudDogQWRkcmVzcyk6IHtTdHJpbmc6IHtVSW50MzI6IERlbGVnYXRlSW5mb319PyB7CiAgICBsZXQgZG9lc0FjY291bnRIYXZlU3Rha2luZ0NvbGxlY3Rpb24gPSBGbG93U3Rha2luZ0NvbGxlY3Rpb24uZG9lc0FjY291bnRIYXZlU3Rha2luZ0NvbGxlY3Rpb24oYWRkcmVzczogYWNjb3VudCkKICAgIGlmICghZG9lc0FjY291bnRIYXZlU3Rha2luZ0NvbGxlY3Rpb24pIHsKICAgICAgICByZXR1cm4gbmlsCiAgICB9CgogICAgbGV0IGRlbGVnYXRvcklEczogW0Zsb3dTdGFraW5nQ29sbGVjdGlvbi5EZWxlZ2F0b3JJRHNdID0gRmxvd1N0YWtpbmdDb2xsZWN0aW9uLmdldERlbGVnYXRvcklEcyhhZGRyZXNzOiBhY2NvdW50KQoKICAgIGxldCBmb3JtYXR0ZWREZWxlZ2F0b3JJbmZvOiB7U3RyaW5nOiB7VUludDMyOiBEZWxlZ2F0ZUluZm99fSA9IHt9CgogICAgZm9yIGRlbGVnYXRvcklEIGluIGRlbGVnYXRvcklEcyB7CiAgICAgICAgaWYgbGV0IF9mb3JtYXR0ZWREZWxlZ2F0b3JJbmZvID0gZm9ybWF0dGVkRGVsZWdhdG9ySW5mb1tkZWxlZ2F0b3JJRC5kZWxlZ2F0b3JOb2RlSURdIHsKICAgICAgICAgICAgbGV0IGRlbGVnYXRvckluZm86IEZsb3dJRFRhYmxlU3Rha2luZy5EZWxlZ2F0b3JJbmZvID0gRmxvd0lEVGFibGVTdGFraW5nLkRlbGVnYXRvckluZm8obm9kZUlEOiBkZWxlZ2F0b3JJRC5kZWxlZ2F0b3JOb2RlSUQsIGRlbGVnYXRvcklEOiBkZWxlZ2F0b3JJRC5kZWxlZ2F0b3JJRCkKICAgICAgICAgICAgX2Zvcm1hdHRlZERlbGVnYXRvckluZm9bZGVsZWdhdG9ySUQuZGVsZWdhdG9ySURdID0gRGVsZWdhdGVJbmZvKGRlbGVnYXRvckluZm86IGRlbGVnYXRvckluZm8pCiAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgbGV0IGRlbGVnYXRvckluZm86IEZsb3dJRFRhYmxlU3Rha2luZy5EZWxlZ2F0b3JJbmZvID0gRmxvd0lEVGFibGVTdGFraW5nLkRlbGVnYXRvckluZm8obm9kZUlEOiBkZWxlZ2F0b3JJRC5kZWxlZ2F0b3JOb2RlSUQsIGRlbGVnYXRvcklEOiBkZWxlZ2F0b3JJRC5kZWxlZ2F0b3JJRCkKICAgICAgICAgICAgZm9ybWF0dGVkRGVsZWdhdG9ySW5mb1tkZWxlZ2F0b3JJRC5kZWxlZ2F0b3JOb2RlSURdID0geyBkZWxlZ2F0b3JJRC5kZWxlZ2F0b3JJRDogRGVsZWdhdGVJbmZvKGRlbGVnYXRvckluZm86IGRlbGVnYXRvckluZm8pfQogICAgICAgIH0KICAgIH0KCiAgICByZXR1cm4gZm9ybWF0dGVkRGVsZWdhdG9ySW5mbwp9", + "getDelegatesInfoArray": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0RGVsZWdhdGVzSW5mb0FycmF5IC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgoKaW1wb3J0IEZsb3dTdGFraW5nQ29sbGVjdGlvbiBmcm9tIDB4OGQwZTg3YjY1MTU5YWU2MwoKaW1wb3J0IEZsb3dJRFRhYmxlU3Rha2luZyBmcm9tIDB4ODYyNGI1MmY5ZGRjZDA0YQoKaW1wb3J0IExvY2tlZFRva2VucyBmcm9tIDB4OGQwZTg3YjY1MTU5YWU2MwoKICAgICAgICAKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IFtGbG93SURUYWJsZVN0YWtpbmcuRGVsZWdhdG9ySW5mb10gewogICAgcmV0dXJuIEZsb3dTdGFraW5nQ29sbGVjdGlvbi5nZXRBbGxEZWxlZ2F0b3JJbmZvKGFkZHJlc3M6IGFkZHJlc3MpCn0\u003d", + "getDelegatesInfoArrayV2": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0RGVsZWdhdGVzSW5mb0FycmF5VjIgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCgppbXBvcnQgRmxvd1N0YWtpbmdDb2xsZWN0aW9uIGZyb20gMHg4ZDBlODdiNjUxNTlhZTYzCgppbXBvcnQgRmxvd0lEVGFibGVTdGFraW5nIGZyb20gMHg4NjI0YjUyZjlkZGNkMDRhCgppbXBvcnQgTG9ja2VkVG9rZW5zIGZyb20gMHg4ZDBlODdiNjUxNTlhZTYzCgogICAgICAgIAphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzKTogW0Zsb3dJRFRhYmxlU3Rha2luZy5EZWxlZ2F0b3JJbmZvXT8gewogICAgdmFyIHJlczogW0Zsb3dJRFRhYmxlU3Rha2luZy5EZWxlZ2F0b3JJbmZvXT8gPSBuaWwKCiAgICBsZXQgaW5pdGVkID0gRmxvd1N0YWtpbmdDb2xsZWN0aW9uLmRvZXNBY2NvdW50SGF2ZVN0YWtpbmdDb2xsZWN0aW9uKGFkZHJlc3M6IGFkZHJlc3MpCgogICAgaWYgaW5pdGVkIHsKICAgICAgICByZXMgPSBGbG93U3Rha2luZ0NvbGxlY3Rpb24uZ2V0QWxsRGVsZWdhdG9ySW5mbyhhZGRyZXNzOiBhZGRyZXNzKQogICAgfQogICAgcmV0dXJuIHJlcwp9", + "getDelegatesInfoV2": "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\u003d", + "getDelegatorInfo": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0RGVsZWdhdG9ySW5mbyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dJRFRhYmxlU3Rha2luZyBmcm9tIDB4ODYyNGI1MmY5ZGRjZDA0YQoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKG5vZGVJRDogU3RyaW5nLCBkZWxlZ2F0b3JJRDogVUludDMyKTogRmxvd0lEVGFibGVTdGFraW5nLkRlbGVnYXRvckluZm8gewogIHJldHVybiBGbG93SURUYWJsZVN0YWtpbmcuRGVsZWdhdG9ySW5mbyhub2RlSUQ6IG5vZGVJRCwgZGVsZWdhdG9ySUQ6IGRlbGVnYXRvcklEKQp9", + "getEpochMetadata": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0RXBvY2hNZXRhZGF0YSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dFcG9jaCBmcm9tIDB4ODYyNGI1MmY5ZGRjZDA0YQoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGVwb2NoQ291bnRlcjogVUludDY0KTogRmxvd0Vwb2NoLkVwb2NoTWV0YWRhdGEgewogICAgcmV0dXJuIEZsb3dFcG9jaC5nZXRFcG9jaE1ldGFkYXRhKGVwb2NoQ291bnRlcikhCn0\u003d", + "getNodeInfo": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Tm9kZUluZm8gLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGbG93SURUYWJsZVN0YWtpbmcgZnJvbSAweDg2MjRiNTJmOWRkY2QwNGEKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihub2RlSUQ6IFN0cmluZyk6IEZsb3dJRFRhYmxlU3Rha2luZy5Ob2RlSW5mbyB7CiAgcmV0dXJuIEZsb3dJRFRhYmxlU3Rha2luZy5Ob2RlSW5mbyhub2RlSUQ6IG5vZGVJRCkKfQ\u003d\u003d", + "getNodesInfo": "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", + "getStakeInfo": "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", + "getStakingInfo": "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", + "restakeReward": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcmVzdGFrZVJld2FyZCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKIGltcG9ydCBGbG93U3Rha2luZ0NvbGxlY3Rpb24gZnJvbSAweDhkMGU4N2I2NTE1OWFlNjMKCgovLy8gQ29tbWl0cyByZXdhcmRlZCB0b2tlbnMgdG8gc3Rha2UgZm9yIHRoZSBzcGVjaWZpZWQgbm9kZSBvciBkZWxlZ2F0b3IgaW4gdGhlIHN0YWtpbmcgY29sbGVjdGlvbgoKdHJhbnNhY3Rpb24obm9kZUlEOiBTdHJpbmcsIGRlbGVnYXRvcklEOiBVSW50MzI/LCBhbW91bnQ6IFVGaXg2NCkgewogICAgCiAgICBsZXQgc3Rha2luZ0NvbGxlY3Rpb25SZWY6IGF1dGgoRmxvd1N0YWtpbmdDb2xsZWN0aW9uLkNvbGxlY3Rpb25Pd25lcikgJkZsb3dTdGFraW5nQ29sbGVjdGlvbi5TdGFraW5nQ29sbGVjdGlvbgoKICAgIHByZXBhcmUoYWNjb3VudDogYXV0aChCb3Jyb3dWYWx1ZSkgJkFjY291bnQpIHsKICAgICAgICBzZWxmLnN0YWtpbmdDb2xsZWN0aW9uUmVmID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzxhdXRoKEZsb3dTdGFraW5nQ29sbGVjdGlvbi5Db2xsZWN0aW9uT3duZXIpICZGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb24+KGZyb206IEZsb3dTdGFraW5nQ29sbGVjdGlvbi5TdGFraW5nQ29sbGVjdGlvblN0b3JhZ2VQYXRoKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBhIHJlZmVyZW5jZSB0byBhIFN0YWtpbmdDb2xsZWN0aW9uIGluIHRoZSBwcmltYXJ5IHVzZXIncyBhY2NvdW50IikKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBzZWxmLnN0YWtpbmdDb2xsZWN0aW9uUmVmLnN0YWtlUmV3YXJkZWRUb2tlbnMobm9kZUlEOiBub2RlSUQsIGRlbGVnYXRvcklEOiBkZWxlZ2F0b3JJRCwgYW1vdW50OiBhbW91bnQpCiAgICB9Cn0\u003d", + "restakeUnstaked": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcmVzdGFrZVVuc3Rha2VkIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd1N0YWtpbmdDb2xsZWN0aW9uIGZyb20gMHg4ZDBlODdiNjUxNTlhZTYzCgoKLy8vIENvbW1pdHMgdW5zdGFrZWQgdG9rZW5zIHRvIHN0YWtlIGZvciB0aGUgc3BlY2lmaWVkIG5vZGUgb3IgZGVsZWdhdG9yIGluIHRoZSBzdGFraW5nIGNvbGxlY3Rpb24KCnRyYW5zYWN0aW9uKG5vZGVJRDogU3RyaW5nLCBkZWxlZ2F0b3JJRDogVUludDMyPywgYW1vdW50OiBVRml4NjQpIHsKICAgIAogICAgbGV0IHN0YWtpbmdDb2xsZWN0aW9uUmVmOiBhdXRoKEZsb3dTdGFraW5nQ29sbGVjdGlvbi5Db2xsZWN0aW9uT3duZXIpICZGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb24KCiAgICBwcmVwYXJlKGFjY291bnQ6IGF1dGgoQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZiA9IGFjY291bnQuc3RvcmFnZS5ib3Jyb3c8YXV0aChGbG93U3Rha2luZ0NvbGxlY3Rpb24uQ29sbGVjdGlvbk93bmVyKSAmRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uPihmcm9tOiBGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb25TdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgYSByZWZlcmVuY2UgdG8gYSBTdGFraW5nQ29sbGVjdGlvbiBpbiB0aGUgcHJpbWFyeSB1c2VyJ3MgYWNjb3VudCIpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZi5zdGFrZVVuc3Rha2VkVG9rZW5zKG5vZGVJRDogbm9kZUlELCBkZWxlZ2F0b3JJRDogZGVsZWdhdG9ySUQsIGFtb3VudDogYW1vdW50KQogICAgfQp9", + "setup": "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\u003d", + "unstake": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgdW5zdGFrZSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKIGltcG9ydCBGbG93U3Rha2luZ0NvbGxlY3Rpb24gZnJvbSAweDhkMGU4N2I2NTE1OWFlNjMKCgovLy8gUmVxdWVzdHMgdW5zdGFraW5nIGZvciB0aGUgc3BlY2lmaWVkIG5vZGUgb3IgZGVsZWdhdG9yIGluIHRoZSBzdGFraW5nIGNvbGxlY3Rpb24KCnRyYW5zYWN0aW9uKG5vZGVJRDogU3RyaW5nLCBkZWxlZ2F0b3JJRDogVUludDMyPywgYW1vdW50OiBVRml4NjQpIHsKICAgIAogICAgbGV0IHN0YWtpbmdDb2xsZWN0aW9uUmVmOiBhdXRoKEZsb3dTdGFraW5nQ29sbGVjdGlvbi5Db2xsZWN0aW9uT3duZXIpICZGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb24KCiAgICBwcmVwYXJlKGFjY291bnQ6IGF1dGgoQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZiA9IGFjY291bnQuc3RvcmFnZS5ib3Jyb3c8YXV0aChGbG93U3Rha2luZ0NvbGxlY3Rpb24uQ29sbGVjdGlvbk93bmVyKSAmRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uPihmcm9tOiBGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb25TdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgYSByZWZlcmVuY2UgdG8gYSBTdGFraW5nQ29sbGVjdGlvbiBpbiB0aGUgcHJpbWFyeSB1c2VyJ3MgYWNjb3VudCIpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZi5yZXF1ZXN0VW5zdGFraW5nKG5vZGVJRDogbm9kZUlELCBkZWxlZ2F0b3JJRDogZGVsZWdhdG9ySUQsIGFtb3VudDogYW1vdW50KQogICAgfQp9", + "withdrawLocked": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgd2l0aGRyYXdMb2NrZWQgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhGVU5HSUJMRVRPS0VOQUREUkVTUwppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHhGTE9XVE9LRU5BRERSRVNTCmltcG9ydCBMb2NrZWRUb2tlbnMgZnJvbSAweExPQ0tFRFRPS0VOQUREUkVTUwoKdHJhbnNhY3Rpb24oYW1vdW50OiBVRml4NjQpIHsKCiAgICBsZXQgaG9sZGVyUmVmOiBhdXRoKExvY2tlZFRva2Vucy5Ub2tlbk9wZXJhdGlvbnMsIEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZMb2NrZWRUb2tlbnMuVG9rZW5Ib2xkZXIKICAgIGxldCB2YXVsdFJlZjogYXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAmRmxvd1Rva2VuLlZhdWx0CgogICAgcHJlcGFyZShhY2N0OiBhdXRoKEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgIHNlbGYuaG9sZGVyUmVmID0gYWNjdC5zdG9yYWdlLmJvcnJvdzxhdXRoKExvY2tlZFRva2Vucy5Ub2tlbk9wZXJhdGlvbnMsIEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZMb2NrZWRUb2tlbnMuVG9rZW5Ib2xkZXI+KGZyb206IExvY2tlZFRva2Vucy5Ub2tlbkhvbGRlclN0b3JhZ2VQYXRoKQogICAgICAgICAgICA/PyBwYW5pYygiVGhlIHByaW1hcnkgdXNlciBhY2NvdW50IGRvZXMgbm90IGhhdmUgYW4gYXNzb2NpYXRlZCBsb2NrZWQgYWNjb3VudCIpCgogICAgICAgIHNlbGYudmF1bHRSZWYgPSBhY2N0LnN0b3JhZ2UuYm9ycm93PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJkZsb3dUb2tlbi5WYXVsdD4oZnJvbTogL3N0b3JhZ2UvZmxvd1Rva2VuVmF1bHQpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IGZsb3cgdG9rZW4gdmF1bHQgcmVmIikKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBzZWxmLnZhdWx0UmVmLmRlcG9zaXQoZnJvbTogPC1zZWxmLmhvbGRlclJlZi53aXRoZHJhdyhhbW91bnQ6IGFtb3VudCkpCiAgICB9Cn0\u003d", + "withdrawReward": "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\u003d\u003d", + "withdrawUnstaked": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgd2l0aGRyYXdVbnN0YWtlZCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKIGltcG9ydCBGbG93U3Rha2luZ0NvbGxlY3Rpb24gZnJvbSAweDhkMGU4N2I2NTE1OWFlNjMKCgovLy8gUmVxdWVzdCB0byB3aXRoZHJhdyB1bnN0YWtlZCB0b2tlbnMgZm9yIHRoZSBzcGVjaWZpZWQgbm9kZSBvciBkZWxlZ2F0b3IgaW4gdGhlIHN0YWtpbmcgY29sbGVjdGlvbgovLy8gVGhlIHRva2VucyBhcmUgYXV0b21hdGljYWxseSBkZXBvc2l0ZWQgdG8gdGhlIHVubG9ja2VkIGFjY291bnQgdmF1bHQgZmlyc3QsCi8vLyBBbmQgdGhlbiBhbnkgbG9ja2VkIHRva2VucyBhcmUgZGVwb3NpdGVkIGludG8gdGhlIGxvY2tlZCBhY2NvdW50IHZhdWx0IGlmIGl0IGlzIHRoZXJlCgp0cmFuc2FjdGlvbihub2RlSUQ6IFN0cmluZywgZGVsZWdhdG9ySUQ6IFVJbnQzMj8sIGFtb3VudDogVUZpeDY0KSB7CiAgICAKICAgIGxldCBzdGFraW5nQ29sbGVjdGlvblJlZjogYXV0aChGbG93U3Rha2luZ0NvbGxlY3Rpb24uQ29sbGVjdGlvbk93bmVyKSAmRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uCgogICAgcHJlcGFyZShhY2NvdW50OiBhdXRoKEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgIHNlbGYuc3Rha2luZ0NvbGxlY3Rpb25SZWYgPSBhY2NvdW50LnN0b3JhZ2UuYm9ycm93PGF1dGgoRmxvd1N0YWtpbmdDb2xsZWN0aW9uLkNvbGxlY3Rpb25Pd25lcikgJkZsb3dTdGFraW5nQ29sbGVjdGlvbi5TdGFraW5nQ29sbGVjdGlvbj4oZnJvbTogRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uU3RvcmFnZVBhdGgpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IGEgcmVmZXJlbmNlIHRvIGEgU3Rha2luZ0NvbGxlY3Rpb24gaW4gdGhlIHByaW1hcnkgdXNlcidzIGFjY291bnQiKQogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIHNlbGYuc3Rha2luZ0NvbGxlY3Rpb25SZWYud2l0aGRyYXdVbnN0YWtlZFRva2Vucyhub2RlSUQ6IG5vZGVJRCwgZGVsZWdhdG9ySUQ6IGRlbGVnYXRvcklELCBhbW91bnQ6IGFtb3VudCkKICAgIH0KfQ\u003d\u003d" + }, + "storage": { + "enableTokenStorage": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZW5hYmxlVG9rZW5TdG9yYWdlIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKaW1wb3J0IDxUb2tlbj4gZnJvbSA8VG9rZW5BZGRyZXNzPgoKdHJhbnNhY3Rpb24gewoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIENhcGFiaWxpdGllcykgJkFjY291bnQpIHsKCiAgICAgICAgaWYgc2lnbmVyLnN0b3JhZ2UuYm9ycm93PCY8VG9rZW4+LlZhdWx0Pihmcm9tOiA8VG9rZW5TdG9yYWdlUGF0aD4gKSA9PSBuaWwgewogICAgICAgICAgICBzaWduZXIuc3RvcmFnZS5zYXZlKDwtIDxUb2tlbj4uY3JlYXRlRW1wdHlWYXVsdCh2YXVsdFR5cGU6IFR5cGU8QDxUb2tlbj4uVmF1bHQ+KCkpLCB0bzogPFRva2VuU3RvcmFnZVBhdGg+KQogICAgICAgIH0KCiAgICAgICAgaWYgc2lnbmVyLmNhcGFiaWxpdGllcy5leGlzdHMoPFRva2VuUmVjZWl2ZXJQYXRoPikgPT0gZmFsc2UgewogICAgICAgICAgICBsZXQgcmVjZWl2ZXJDYXBhYmlsaXR5ID0gc2lnbmVyLmNhcGFiaWxpdGllcy5zdG9yYWdlLmlzc3VlPCY8VG9rZW4+LlZhdWx0Pig8VG9rZW5TdG9yYWdlUGF0aD4pCiAgICAgICAgICAgIHNpZ25lci5jYXBhYmlsaXRpZXMucHVibGlzaChyZWNlaXZlckNhcGFiaWxpdHksIGF0OiA8VG9rZW5SZWNlaXZlclBhdGg+KQogICAgICAgIAogICAgICAgIH0KICAgICAgIAogICAgICAgIGlmIHNpZ25lci5jYXBhYmlsaXRpZXMuZXhpc3RzKDxUb2tlbkJhbGFuY2VQYXRoPikgPT0gZmFsc2UgewogICAgICAgICAgICBsZXQgYmFsYW5jZUNhcGFiaWxpdHkgPSBzaWduZXIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8JjxUb2tlbj4uVmF1bHQ+KDxUb2tlblN0b3JhZ2VQYXRoPikKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5wdWJsaXNoKGJhbGFuY2VDYXBhYmlsaXR5LCBhdDogPFRva2VuQmFsYW5jZVBhdGg+KQogICAgICAgIH0KICAgIAogICAgfQp9", + "enableTokenStorageV2": "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\u003d\u003d", + "getBasicPublicItems": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QmFzaWNQdWJsaWNJdGVtcyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKYWNjZXNzKGFsbClzdHJ1Y3QgSXRlbSB7CiAgYWNjZXNzKGFsbClsZXQgYWRkcmVzczogQWRkcmVzcwogIGFjY2VzcyhhbGwpbGV0IHBhdGg6IFN0cmluZwogIGFjY2VzcyhhbGwpbGV0IHRhcmdldFBhdGg6IFN0cmluZz8KCiAgaW5pdChhZGRyZXNzOiBBZGRyZXNzLCBwYXRoOiBTdHJpbmcsIHRhcmdldFBhdGg6IFN0cmluZz8pIHsKICAgIHNlbGYuYWRkcmVzcyA9IGFkZHJlc3MKICAgIHNlbGYucGF0aCA9IHBhdGgKICAgIHNlbGYudGFyZ2V0UGF0aCA9IHRhcmdldFBhdGgKICB9Cn0KCmFjY2VzcyhhbGwpZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IFtJdGVtXSB7CiAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgbGV0IGl0ZW1zOiBbSXRlbV0gPSBbXQoKCiAgZnVuIGVhY2hQYXRoKHBhdGg6IFB1YmxpY1BhdGgsIGNhcFR5cGU6IFR5cGUpOiBCb29sIHsKICAgIC8vIHRvZG8KICAgIGxldCBjYXAgPSBhY2NvdW50LmNhcGFiaWxpdGllcy5nZXQ8JkFueVN0cnVjdD4ocGF0aCkKICAgIHZhciB0YXJnZXRQYXRoID0gIiIKCiAgICBpZiBjYXAgIT0gbmlsIHsKICAgICAgdGFyZ2V0UGF0aCA9ICIxMiIgCiAgICB9CiAgICBsZXQgaXRlbSA9IEl0ZW0oYWRkcmVzczogYWRkcmVzcywgcGF0aDogcGF0aC50b1N0cmluZygpLCB0YXJnZXRQYXRoOiB0YXJnZXRQYXRoKQogICAgaXRlbXMuYXBwZW5kKGl0ZW0pCiAgICByZXR1cm4gdHJ1ZQogIH0KICBhY2NvdW50LnN0b3JhZ2UuZm9yRWFjaFB1YmxpYyhlYWNoUGF0aCkKCiAgcmV0dXJuIGl0ZW1zCn0\u003d", + "getPrivateItems": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0UHJpdmF0ZUl0ZW1zIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgphY2Nlc3MoYWxsKXN0cnVjdCBJdGVtIHsKICBhY2Nlc3MoYWxsKWxldCBhZGRyZXNzOiBBZGRyZXNzCiAgYWNjZXNzKGFsbClsZXQgcGF0aDogU3RyaW5nCiAgYWNjZXNzKGFsbClsZXQgdHlwZTogVHlwZQogIGFjY2VzcyhhbGwpbGV0IHRhcmdldFBhdGg6IFN0cmluZz8KCiAgaW5pdCgKICAgIGFkZHJlc3M6IEFkZHJlc3MsIAogICAgcGF0aDogU3RyaW5nLCAKICAgIHR5cGU6IFR5cGUsIAogICAgdGFyZ2V0UGF0aDogU3RyaW5nPwogICkgewogICAgc2VsZi5hZGRyZXNzID0gYWRkcmVzcwogICAgc2VsZi5wYXRoID0gcGF0aAogICAgc2VsZi50eXBlID0gdHlwZQogICAgc2VsZi50YXJnZXRQYXRoID0gdGFyZ2V0UGF0aAogIH0KfQoKYWNjZXNzKGFsbClmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzLCBwYXRoTWFwOiB7U3RyaW5nOiBCb29sfSk6IFtJdGVtXSB7CiAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCgogIGxldCBpdGVtczogW0l0ZW1dID0gW10KCiAgYWNjb3VudC5zdG9yYWdlLmZvckVhY2hQcml2YXRlKGZ1biAocGF0aDogUHJpdmF0ZVBhdGgsIHR5cGU6IFR5cGUpOiBCb29sIHsKICAgIGlmICFwYXRoTWFwLmNvbnRhaW5zS2V5KHBhdGgudG9TdHJpbmcoKSkgewogICAgICByZXR1cm4gdHJ1ZQogICAgfQoKICAgIHZhciB0YXJnZXRQYXRoOiBTdHJpbmc/ID0gbmlsCiAgICBpZiBsZXQgdGFyZ2V0ID0gYWNjb3VudC5nZXRMaW5rVGFyZ2V0KHBhdGgpIHsKICAgICAgdGFyZ2V0UGF0aCA9IHRhcmdldC50b1N0cmluZygpCiAgICB9CgogICAgbGV0IGl0ZW0gPSBJdGVtKAogICAgICBhZGRyZXNzOiBhZGRyZXNzLAogICAgICBwYXRoOiBwYXRoLnRvU3RyaW5nKCksCiAgICAgIHR5cGU6IHR5cGUsCiAgICAgIHRhcmdldFBhdGg6IHRhcmdldFBhdGgKICAgICkKCiAgICBpdGVtcy5hcHBlbmQoaXRlbSkKICAgIHJldHVybiB0cnVlCiAgfSkKCiAgcmV0dXJuIGl0ZW1zCn0\u003d", + "getPrivatePaths": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0UHJpdmF0ZVBhdGhzIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgphY2Nlc3MoYWxsKWZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBbUHJpdmF0ZVBhdGhdIHsKICBsZXQgYWNjb3VudCA9IGdldEF1dGhBY2NvdW50KGFkZHJlc3MpCiAgbGV0IGNsZWFuZFBhdGhzOiBbUHJpdmF0ZVBhdGhdID0gW10KICBmb3IgcGF0aCBpbiBhY2NvdW50LnByaXZhdGVQYXRocyB7CiAgICBjbGVhbmRQYXRocy5hcHBlbmQocGF0aCkKICB9CiAgcmV0dXJuIGNsZWFuZFBhdGhzCn0\u003d", + "getPublicItem": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0UHVibGljSXRlbSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKLy8gQSB3b3JrYXJvdW5kIG1ldGhvZAppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCiAgCmFjY2VzcyhhbGwpIHN0cnVjdCBJdGVtIHsKICBhY2Nlc3MoYWxsKSBsZXQgYWRkcmVzczogQWRkcmVzcwogIGFjY2VzcyhhbGwpIGxldCBwYXRoOiBTdHJpbmcKICBhY2Nlc3MoYWxsKSBsZXQgdHlwZTogVHlwZQoKICBhY2Nlc3MoYWxsKSBsZXQgdGFyZ2V0UGF0aDogU3RyaW5nPwoKICBpbml0KAogICAgYWRkcmVzczogQWRkcmVzcywgCiAgICBwYXRoOiBTdHJpbmcsIAogICAgdHlwZTogVHlwZSwgCiAgICB0YXJnZXRQYXRoOiBTdHJpbmc/CiAgKSB7CiAgICBzZWxmLmFkZHJlc3MgPSBhZGRyZXNzCiAgICBzZWxmLnBhdGggPSBwYXRoCiAgICBzZWxmLnR5cGUgPSB0eXBlCiAgICBzZWxmLnRhcmdldFBhdGggPSB0YXJnZXRQYXRoCiAgfQp9CgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzLCBwYXRoTWFwOiB7U3RyaW5nOiBCb29sfSk6IFtJdGVtXSB7CiAgbGV0IGFjY291bnQgPSBnZXRBdXRoQWNjb3VudChhZGRyZXNzKQoKICBsZXQgaXRlbXM6IFtJdGVtXSA9IFtdCiAgYWNjb3VudC5mb3JFYWNoUHVibGljKGZ1biAocGF0aDogUHVibGljUGF0aCwgdHlwZTogVHlwZSk6IEJvb2wgewogICAgaWYgIXBhdGhNYXAuY29udGFpbnNLZXkocGF0aC50b1N0cmluZygpKSB7CiAgICAgIHJldHVybiB0cnVlCiAgICB9CgogICAgdmFyIHRhcmdldFBhdGg6IFN0cmluZz8gPSBuaWwKCiAgICBpZiBsZXQgdGFyZ2V0ID0gYWNjb3VudC5nZXRMaW5rVGFyZ2V0KHBhdGgpIHsKICAgICAgdGFyZ2V0UGF0aCA9IHRhcmdldC50b1N0cmluZygpCiAgICB9CgogICAgbGV0IGl0ZW0gPSBJdGVtKAogICAgICBhZGRyZXNzOiBhZGRyZXNzLAogICAgICBwYXRoOiBwYXRoLnRvU3RyaW5nKCksCiAgICAgIHR5cGU6IHR5cGUsCiAgICAgIHRhcmdldFBhdGg6IHRhcmdldFBhdGgKICAgICkKCiAgICBpdGVtcy5hcHBlbmQoaXRlbSkKICAgIHJldHVybiBmYWxzZQogIH0pCgogIHJldHVybiBpdGVtcwp9", + "getPublicItems": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0UHVibGljSXRlbXMgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4MWQ3ZTU3YWE1NTgxNzQ0OAoKICAKYWNjZXNzKGFsbCkgc3RydWN0IEl0ZW0gewogIGFjY2VzcyhhbGwpIGxldCBhZGRyZXNzOiBBZGRyZXNzCiAgYWNjZXNzKGFsbCkgbGV0IHBhdGg6IFN0cmluZwogIGFjY2VzcyhhbGwpIGxldCB0eXBlOiBUeXBlCgogIGFjY2VzcyhhbGwpIGxldCB0YXJnZXRQYXRoOiBTdHJpbmc/CgogIGFjY2VzcyhhbGwpIGxldCBpc0NvbGxlY3Rpb25DYXA6IEJvb2wKICBhY2Nlc3MoYWxsKSBsZXQgdG9rZW5JRHM6IFtVSW50NjRdCgogIGFjY2VzcyhhbGwpIGxldCBpc0JhbGFuY2VDYXA6IEJvb2wKICBhY2Nlc3MoYWxsKSBsZXQgYmFsYW5jZTogVUZpeDY0PwoKICBpbml0KAogICAgYWRkcmVzczogQWRkcmVzcywgCiAgICBwYXRoOiBTdHJpbmcsIAogICAgdHlwZTogVHlwZSwgCiAgICB0YXJnZXRQYXRoOiBTdHJpbmc/LCAKICAgIGlzQ29sbGVjdGlvbkNhcDogQm9vbCwgCiAgICB0b2tlbklEczogW1VJbnQ2NF0sCiAgICBpc0JhbGFuY2VDYXA6IEJvb2wsCiAgICBiYWxhbmNlOiBVRml4NjQ/CiAgKSB7CiAgICBzZWxmLmFkZHJlc3MgPSBhZGRyZXNzCiAgICBzZWxmLnBhdGggPSBwYXRoCiAgICBzZWxmLnR5cGUgPSB0eXBlCiAgICBzZWxmLnRhcmdldFBhdGggPSB0YXJnZXRQYXRoCiAgICBzZWxmLmlzQ29sbGVjdGlvbkNhcCA9IGlzQ29sbGVjdGlvbkNhcAogICAgc2VsZi50b2tlbklEcyA9IHRva2VuSURzCiAgICBzZWxmLmlzQmFsYW5jZUNhcCA9IGlzQmFsYW5jZUNhcAogICAgc2VsZi5iYWxhbmNlID0gYmFsYW5jZQogIH0KfQoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcywgcGF0aE1hcDoge1N0cmluZzogQm9vbH0pOiBbSXRlbV0gewogIGxldCBhY2NvdW50ID0gZ2V0QXV0aEFjY291bnQoYWRkcmVzcykKCiAgbGV0IGl0ZW1zOiBbSXRlbV0gPSBbXQogIGxldCBiYWxhbmNlQ2FwVHlwZSA9IFR5cGU8Q2FwYWJpbGl0eTwmQW55UmVzb3VyY2V7RnVuZ2libGVUb2tlbi5CYWxhbmNlfT4+KCkKICBsZXQgY29sbGVjdGlvblR5cGUgPSBUeXBlPENhcGFiaWxpdHk8JkFueVJlc291cmNle05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvblB1YmxpY30+PigpCgogIGFjY291bnQuZm9yRWFjaFB1YmxpYyhmdW4gKHBhdGg6IFB1YmxpY1BhdGgsIHR5cGU6IFR5cGUpOiBCb29sIHsKICAgIGlmICFwYXRoTWFwLmNvbnRhaW5zS2V5KHBhdGgudG9TdHJpbmcoKSkgewogICAgICByZXR1cm4gdHJ1ZQogICAgfQoKICAgIHZhciB0YXJnZXRQYXRoOiBTdHJpbmc/ID0gbmlsCiAgICB2YXIgaXNDb2xsZWN0aW9uQ2FwID0gZmFsc2UKICAgIHZhciBpc0JhbGFuY2VDYXAgPSBmYWxzZQogICAgdmFyIHRva2VuSURzOiBbVUludDY0XSA9IFtdCiAgICB2YXIgYmFsYW5jZTogVUZpeDY0PyA9IG5pbAoKICAgIGlmIGxldCB0YXJnZXQgPSBhY2NvdW50LmdldExpbmtUYXJnZXQocGF0aCkgewogICAgICB0YXJnZXRQYXRoID0gdGFyZ2V0LnRvU3RyaW5nKCkKICAgIH0KCiAgICBpZiAodHlwZS5pc1N1YnR5cGUob2Y6IGJhbGFuY2VDYXBUeXBlKSkgewogICAgICBpc0JhbGFuY2VDYXAgPSB0cnVlCiAgICAgIGxldCB2YXVsdFJlZiA9IGFjY291bnQKICAgICAgICAgIC5nZXRDYXBhYmlsaXR5KHBhdGgpCiAgICAgICAgICAuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5CYWxhbmNlfT4oKQoKICAgICAgaWYgbGV0IHZhdWx0ID0gdmF1bHRSZWYgewogICAgICAgICAgYmFsYW5jZSA9IHZhdWx0LmJhbGFuY2UKICAgICAgfQogICAgfSBlbHNlIGlmICh0eXBlLmlzU3VidHlwZShvZjogY29sbGVjdGlvblR5cGUpKSB7CiAgICAgIGlzQ29sbGVjdGlvbkNhcCA9IHRydWUKICAgICAgbGV0IGNvbGxlY3Rpb25SZWYgPSBhY2NvdW50CiAgICAgICAgLmdldENhcGFiaWxpdHkocGF0aCkKICAgICAgICAuYm9ycm93PCZ7Tm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9uUHVibGljfT4oKQoKICAgICAgaWYgbGV0IGNvbGxlY3Rpb24gPSBjb2xsZWN0aW9uUmVmIHsKICAgICAgICB0b2tlbklEcyA9IGNvbGxlY3Rpb24uZ2V0SURzKCkKICAgICAgfQogICAgfQoKICAgIGxldCBpdGVtID0gSXRlbSgKICAgICAgYWRkcmVzczogYWRkcmVzcywKICAgICAgcGF0aDogcGF0aC50b1N0cmluZygpLAogICAgICB0eXBlOiB0eXBlLAogICAgICB0YXJnZXRQYXRoOiB0YXJnZXRQYXRoLAogICAgICBpc0NvbGxlY3Rpb25DYXA6IGlzQ29sbGVjdGlvbkNhcCwKICAgICAgdG9rZW5JRHM6IHRva2VuSURzLAogICAgICBpc0JhbGFuY2VDYXA6IGlzQmFsYW5jZUNhcCwKICAgICAgYmFsYW5jZTogYmFsYW5jZQogICAgKQoKICAgIGl0ZW1zLmFwcGVuZChpdGVtKQogICAgcmV0dXJuIHRydWUKICB9KQoKICByZXR1cm4gaXRlbXMKfQ\u003d\u003d", + "getPublicPaths": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0UHVibGljUGF0aHMgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCnB1YiBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzKTogW1B1YmxpY1BhdGhdIHsKICBsZXQgYWNjb3VudCA9IGdldEF1dGhBY2NvdW50KGFkZHJlc3MpCiAgbGV0IGNsZWFuZFBhdGhzOiBbUHVibGljUGF0aF0gPSBbXQogIGZvciBwYXRoIGluIGFjY291bnQucHVibGljUGF0aHMgewogICAgY2xlYW5kUGF0aHMuYXBwZW5kKHBhdGgpCiAgfQogIHJldHVybiBjbGVhbmRQYXRocwp9", + "getStoragePaths": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0U3RvcmFnZVBhdGhzIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgpwdWIgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IFtTdG9yYWdlUGF0aF0gewogIGxldCBhY2NvdW50ID0gZ2V0QXV0aEFjY291bnQoYWRkcmVzcykKICBsZXQgY2xlYW5kUGF0aHM6IFtTdG9yYWdlUGF0aF0gPSBbXQogIGZvciBwYXRoIGluIGFjY291bnQuc3RvcmFnZVBhdGhzIHsKICAgIGNsZWFuZFBhdGhzLmFwcGVuZChwYXRoKQogIH0KICByZXR1cm4gY2xlYW5kUGF0aHMKfQ\u003d\u003d", + "getStoredItems": "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", + "getStoredResource": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0U3RvcmVkUmVzb3VyY2UgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCnB1YiBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzLCBwYXRoU3RyOiBTdHJpbmcpOiAmQW55UmVzb3VyY2U/IHsKICBsZXQgYWNjb3VudCA9IGdldEF1dGhBY2NvdW50KGFkZHJlc3MpCiAgbGV0IHBhdGggPSBTdG9yYWdlUGF0aChpZGVudGlmaWVyOiBwYXRoU3RyKSEKICByZXR1cm4gYWNjb3VudC5ib3Jyb3c8JkFueVJlc291cmNlPihmcm9tOiBwYXRoKQp9", + "getStoredStruct": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0U3RvcmVkU3RydWN0IC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgpwdWIgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcywgcGF0aFN0cjogU3RyaW5nKTogJkFueVN0cnVjdD8gewogIGxldCBhY2NvdW50ID0gZ2V0QXV0aEFjY291bnQoYWRkcmVzcykKICBsZXQgcGF0aCA9IFN0b3JhZ2VQYXRoKGlkZW50aWZpZXI6IHBhdGhTdHIpIQogIHJldHVybiBhY2NvdW50LmJvcnJvdzwmQW55U3RydWN0Pihmcm9tOiBwYXRoKQp9" }, "swap": { - "DeployPairTemplate": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgRGVwbG95UGFpclRlbXBsYXRlIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHgxNjU0NjUzMzk5MDQwYTYxCnRyYW5zYWN0aW9uKHBhaXJUZW1wbGF0ZUNvZGU6IFN0cmluZykgewogICAgcHJlcGFyZShkZXBsb3lBY2NvdW50OiBBdXRoQWNjb3VudCkgewogICAgICAgIGxldCB0b2tlbjBWYXVsdCA8LSBGbG93VG9rZW4uY3JlYXRlRW1wdHlWYXVsdCgpCiAgICAgICAgbGV0IHRva2VuMVZhdWx0IDwtIEZsb3dUb2tlbi5jcmVhdGVFbXB0eVZhdWx0KCkKICAgICAgICBkZXBsb3lBY2NvdW50LmNvbnRyYWN0cy5hZGQobmFtZTogIlN3YXBQYWlyIiwgY29kZTogcGFpclRlbXBsYXRlQ29kZS51dGY4LCB0b2tlbjBWYXVsdDogPC10b2tlbjBWYXVsdCwgdG9rZW4xVmF1bHQ6IDwtdG9rZW4xVmF1bHQpCiAgICB9Cn0\u003d", - "CreatePairTemplate": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgQ3JlYXRlUGFpclRlbXBsYXRlIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgVG9rZW4wTmFtZSBmcm9tIFRva2VuMEFkZHIKaW1wb3J0IFRva2VuMU5hbWUgZnJvbSBUb2tlbjFBZGRyCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDE2NTQ2NTMzOTkwNDBhNjEKaW1wb3J0IFN3YXBGYWN0b3J5IGZyb20gMHhiMDYzYzE2Y2FjODVkYmQxCnRyYW5zYWN0aW9uKCkgewogICAgcHJlcGFyZSh1c2VyQWNjb3VudDogQXV0aEFjY291bnQpIHsKICAgICAgICBsZXQgZmxvd1ZhdWx0UmVmID0gdXNlckFjY291bnQuYm9ycm93PCZGbG93VG9rZW4uVmF1bHQ+KGZyb206IC9zdG9yYWdlL2Zsb3dUb2tlblZhdWx0KSEKICAgICAgICBhc3NlcnQoZmxvd1ZhdWx0UmVmLmJhbGFuY2UgPj0gMC4wMDIsIG1lc3NhZ2U6ICJJbnN1ZmZpY2llbnQgYmFsYW5jZSB0byBjcmVhdGUgcGFpciwgbWluaW11bSBiYWxhbmNlIHJlcXVpcmVtZW50OiAwLjAwMiBmbG93IikKICAgICAgICBsZXQgYWNjb3VudENyZWF0aW9uRmVlVmF1bHQgPC0gZmxvd1ZhdWx0UmVmLndpdGhkcmF3KGFtb3VudDogMC4wMDEpCiAgICAgICAgbGV0IHRva2VuMFZhdWx0IDwtIFRva2VuME5hbWUuY3JlYXRlRW1wdHlWYXVsdCgpCiAgICAgICAgbGV0IHRva2VuMVZhdWx0IDwtIFRva2VuMU5hbWUuY3JlYXRlRW1wdHlWYXVsdCgpCiAgICAgICAgU3dhcEZhY3RvcnkuY3JlYXRlUGFpcih0b2tlbjBWYXVsdDogPC10b2tlbjBWYXVsdCwgdG9rZW4xVmF1bHQ6IDwtdG9rZW4xVmF1bHQsIGFjY291bnRDcmVhdGlvbkZlZTogPC1hY2NvdW50Q3JlYXRpb25GZWVWYXVsdCkKICAgIH0KfQ\u003d\u003d", - "AddLiquidity": "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\u003d\u003d", - "RemoveLiquidity": "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\u003d\u003d", - "SwapExactTokensForTokens": "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\u003d\u003d", - "SwapTokensForExactTokens": "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", - "MintAllTokens": "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\u003d", + "DeployPairTemplate": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgRGVwbG95UGFpclRlbXBsYXRlIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHgxNjU0NjUzMzk5MDQwYTYxCnRyYW5zYWN0aW9uKHBhaXJUZW1wbGF0ZUNvZGU6IFN0cmluZykgewogICAgcHJlcGFyZShkZXBsb3lBY2NvdW50OiBBdXRoQWNjb3VudCkgewogICAgICAgIGxldCB0b2tlbjBWYXVsdCA8LSBGbG93VG9rZW4uY3JlYXRlRW1wdHlWYXVsdCgpCiAgICAgICAgbGV0IHRva2VuMVZhdWx0IDwtIEZsb3dUb2tlbi5jcmVhdGVFbXB0eVZhdWx0KCkKICAgICAgICBkZXBsb3lBY2NvdW50LmNvbnRyYWN0cy5hZGQobmFtZTogIlN3YXBQYWlyIiwgY29kZTogcGFpclRlbXBsYXRlQ29kZS51dGY4LCB0b2tlbjBWYXVsdDogPC10b2tlbjBWYXVsdCwgdG9rZW4xVmF1bHQ6IDwtdG9rZW4xVmF1bHQpCiAgICB9Cn0\u003d", + "CreatePairTemplate": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgQ3JlYXRlUGFpclRlbXBsYXRlIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgVG9rZW4wTmFtZSBmcm9tIFRva2VuMEFkZHIKaW1wb3J0IFRva2VuMU5hbWUgZnJvbSBUb2tlbjFBZGRyCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDE2NTQ2NTMzOTkwNDBhNjEKaW1wb3J0IFN3YXBGYWN0b3J5IGZyb20gMHhiMDYzYzE2Y2FjODVkYmQxCnRyYW5zYWN0aW9uKCkgewogICAgcHJlcGFyZSh1c2VyQWNjb3VudDogQXV0aEFjY291bnQpIHsKICAgICAgICBsZXQgZmxvd1ZhdWx0UmVmID0gdXNlckFjY291bnQuYm9ycm93PCZGbG93VG9rZW4uVmF1bHQ+KGZyb206IC9zdG9yYWdlL2Zsb3dUb2tlblZhdWx0KSEKICAgICAgICBhc3NlcnQoZmxvd1ZhdWx0UmVmLmJhbGFuY2UgPj0gMC4wMDIsIG1lc3NhZ2U6ICJJbnN1ZmZpY2llbnQgYmFsYW5jZSB0byBjcmVhdGUgcGFpciwgbWluaW11bSBiYWxhbmNlIHJlcXVpcmVtZW50OiAwLjAwMiBmbG93IikKICAgICAgICBsZXQgYWNjb3VudENyZWF0aW9uRmVlVmF1bHQgPC0gZmxvd1ZhdWx0UmVmLndpdGhkcmF3KGFtb3VudDogMC4wMDEpCiAgICAgICAgbGV0IHRva2VuMFZhdWx0IDwtIFRva2VuME5hbWUuY3JlYXRlRW1wdHlWYXVsdCgpCiAgICAgICAgbGV0IHRva2VuMVZhdWx0IDwtIFRva2VuMU5hbWUuY3JlYXRlRW1wdHlWYXVsdCgpCiAgICAgICAgU3dhcEZhY3RvcnkuY3JlYXRlUGFpcih0b2tlbjBWYXVsdDogPC10b2tlbjBWYXVsdCwgdG9rZW4xVmF1bHQ6IDwtdG9rZW4xVmF1bHQsIGFjY291bnRDcmVhdGlvbkZlZTogPC1hY2NvdW50Q3JlYXRpb25GZWVWYXVsdCkKICAgIH0KfQ\u003d\u003d", + "AddLiquidity": "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\u003d\u003d", + "RemoveLiquidity": "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\u003d\u003d", + "SwapExactTokensForTokens": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgU3dhcEV4YWN0VG9rZW5zRm9yVG9rZW5zIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgVG9rZW4xTmFtZSBmcm9tIFRva2VuMUFkZHIKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKaW1wb3J0IFN3YXBSb3V0ZXIgZnJvbSAweGE2ODUwNzc2YTk0ZTY1NTEKaW1wb3J0IFN3YXBFcnJvciBmcm9tIDB4Yjc4ZWY3YWZhNTJmZjkwNgp0cmFuc2FjdGlvbigKICAgIHRva2VuS2V5RmxhdFNwbGl0UGF0aDogW1N0cmluZ10sCiAgICBhbW91bnRJblNwbGl0OiBbVUZpeDY0XSwKICAgIGFtb3VudE91dE1pbjogVUZpeDY0LAogICAgZGVhZGxpbmU6IFVGaXg2NCwKICAgIHRva2VuSW5WYXVsdFBhdGg6IFN0b3JhZ2VQYXRoLAogICAgdG9rZW5PdXRWYXVsdFBhdGg6IFN0b3JhZ2VQYXRoLAogICAgdG9rZW5PdXRSZWNlaXZlclBhdGg6IFB1YmxpY1BhdGgsCiAgICB0b2tlbk91dEJhbGFuY2VQYXRoOiBQdWJsaWNQYXRoLAopIHsKICAgIHByZXBhcmUodXNlckFjY291bnQ6IEF1dGhBY2NvdW50KSB7CiAgICAgICAgYXNzZXJ0KGRlYWRsaW5lID49IGdldEN1cnJlbnRCbG9jaygpLnRpbWVzdGFtcCwgbWVzc2FnZToKICAgICAgICAgICAgU3dhcEVycm9yLkVycm9yRW5jb2RlKAogICAgICAgICAgICAgICAgbXNnOiAiRVhQSVJFRCIsCiAgICAgICAgICAgICAgICBlcnI6IFN3YXBFcnJvci5FcnJvckNvZGUuRVhQSVJFRAogICAgICAgICAgICApCiAgICAgICAgKQogICAgICAgIGxldCBsZW4gPSB0b2tlbktleUZsYXRTcGxpdFBhdGgubGVuZ3RoCiAgICAgICAgbGV0IHRva2VuSW5LZXkgPSB0b2tlbktleUZsYXRTcGxpdFBhdGhbMF0KICAgICAgICBsZXQgdG9rZW5PdXRLZXkgPSB0b2tlbktleUZsYXRTcGxpdFBhdGhbbGVuLTFdCiAgICAgICAgdmFyIHRva2VuT3V0QW1vdW50VG90YWwgPSAwLjAKICAgICAgICB2YXIgdG9rZW5PdXRSZWNlaXZlclJlZiA9IHVzZXJBY2NvdW50LmJvcnJvdzwmRnVuZ2libGVUb2tlbi5WYXVsdD4oZnJvbTogdG9rZW5PdXRWYXVsdFBhdGgpCiAgICAgICAgaWYgdG9rZW5PdXRSZWNlaXZlclJlZiA9PSBuaWwgewogICAgICAgICAgICB1c2VyQWNjb3VudC5zYXZlKDwtIFRva2VuMU5hbWUuY3JlYXRlRW1wdHlWYXVsdCgpLCB0bzogdG9rZW5PdXRWYXVsdFBhdGgpCiAgICAgICAgICAgIHVzZXJBY2NvdW50Lmxpbms8JlRva2VuMU5hbWUuVmF1bHR7RnVuZ2libGVUb2tlbi5SZWNlaXZlcn0+KHRva2VuT3V0UmVjZWl2ZXJQYXRoLCB0YXJnZXQ6IHRva2VuT3V0VmF1bHRQYXRoKQogICAgICAgICAgICB1c2VyQWNjb3VudC5saW5rPCZUb2tlbjFOYW1lLlZhdWx0e0Z1bmdpYmxlVG9rZW4uQmFsYW5jZX0+KHRva2VuT3V0QmFsYW5jZVBhdGgsIHRhcmdldDogdG9rZW5PdXRWYXVsdFBhdGgpCiAgICAgICAgICAgIHRva2VuT3V0UmVjZWl2ZXJSZWYgPSB1c2VyQWNjb3VudC5ib3Jyb3c8JkZ1bmdpYmxlVG9rZW4uVmF1bHQ+KGZyb206IHRva2VuT3V0VmF1bHRQYXRoKQogICAgICAgIH0KICAgICAgICB2YXIgcGF0aEluZGV4ID0gMAogICAgICAgIHZhciBpID0gMAogICAgICAgIHZhciBwYXRoOiBbU3RyaW5nXSA9IFtdCiAgICAgICAgd2hpbGUoaSA8IGxlbikgewogICAgICAgICAgICB2YXIgY3VyVG9rZW5LZXkgPSB0b2tlbktleUZsYXRTcGxpdFBhdGhbaV0KICAgICAgICAgICAgcGF0aC5hcHBlbmQoY3VyVG9rZW5LZXkpCiAgICAgICAgICAgIGlmIChjdXJUb2tlbktleSA9PSB0b2tlbk91dEtleSkgewogICAgICAgICAgICAgICAgbGV0IHRva2VuSW5BbW91bnQgPSBhbW91bnRJblNwbGl0W3BhdGhJbmRleF0KICAgICAgICAgICAgICAgIGxldCB0b2tlbkluVmF1bHQgPC0gdXNlckFjY291bnQuYm9ycm93PCZGdW5naWJsZVRva2VuLlZhdWx0Pihmcm9tOiB0b2tlbkluVmF1bHRQYXRoKSEud2l0aGRyYXcoYW1vdW50OiB0b2tlbkluQW1vdW50KQogICAgICAgICAgICAgICAgbGV0IHRva2VuT3V0VmF1bHQgPC0gU3dhcFJvdXRlci5zd2FwV2l0aFBhdGgodmF1bHRJbjogPC0gdG9rZW5JblZhdWx0LCB0b2tlbktleVBhdGg6IHBhdGgsIGV4YWN0QW1vdW50czogbmlsKQogICAgICAgICAgICAgICAgdG9rZW5PdXRBbW91bnRUb3RhbCA9IHRva2VuT3V0QW1vdW50VG90YWwgKyB0b2tlbk91dFZhdWx0LmJhbGFuY2UKICAgICAgICAgICAgICAgIHRva2VuT3V0UmVjZWl2ZXJSZWYhLmRlcG9zaXQoZnJvbTogPC0gdG9rZW5PdXRWYXVsdCkKICAgICAgICAgICAgICAgIHBhdGggPSBbXQogICAgICAgICAgICAgICAgcGF0aEluZGV4ID0gcGF0aEluZGV4ICsgMQogICAgICAgICAgICB9CiAgICAgICAgICAgIGkgPSBpICsgMQogICAgICAgIH0KICAgICAgICBhc3NlcnQodG9rZW5PdXRBbW91bnRUb3RhbCA+PSBhbW91bnRPdXRNaW4sIG1lc3NhZ2U6CiAgICAgICAgICAgIFN3YXBFcnJvci5FcnJvckVuY29kZSgKICAgICAgICAgICAgICAgIG1zZzogIlNMSVBQQUdFX09GRlNFVF9UT09fTEFSR0UgZXhwZWN0IG1pbiAiLmNvbmNhdChhbW91bnRPdXRNaW4udG9TdHJpbmcoKSkuY29uY2F0KCIgZ290ICIpLmNvbmNhdCh0b2tlbk91dEFtb3VudFRvdGFsLnRvU3RyaW5nKCkpLAogICAgICAgICAgICAgICAgZXJyOiBTd2FwRXJyb3IuRXJyb3JDb2RlLlNMSVBQQUdFX09GRlNFVF9UT09fTEFSR0UKICAgICAgICAgICAgKQogICAgICAgICkKICAgIH0KfQ\u003d\u003d", + "SwapTokensForExactTokens": "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", + "MintAllTokens": "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\u003d", "QueryTokenNames": "cHViIGZ1biBtYWluKHF1ZXJ5QWRkcjogQWRkcmVzcyk6IFtTdHJpbmddIHsKICAgIGxldCBuYW1lcyA9IGdldEFjY291bnQocXVlcnlBZGRyKS5jb250cmFjdHMubmFtZXMKICAgIGxldCB0b2tlbk5hbWVzOiBbU3RyaW5nXSA9IFtdCiAgICBsZXQgY29sb246IFVJbnQ4ID0gNTgKICAgIGxldCBzcGFjZTogVUludDggPSAzMgogICAgbGV0IGJyYWNlOiBVSW50OCA9IDEyMwogICAgbGV0IHRva2VuSW5kZW50aWZpZXI6IFtVSW50OF0gPSBbNzAsIDExNywgMTEwLCAxMDMsIDEwNSwgOTgsIDEwOCwgMTAxLCA4NCwgMTExLCAxMDcsIDEwMSwgMTEwXSAKICAgIGxldCBpbmRlbnRpZmllckxlbmd0aCA9IHRva2VuSW5kZW50aWZpZXIubGVuZ3RoCiAgICBmb3IgbmFtZSBpbiBuYW1lcyB7CiAgICAgICAgbGV0IGNvZGUgPSBnZXRBY2NvdW50KHF1ZXJ5QWRkcikuY29udHJhY3RzLmdldChuYW1lOiBuYW1lKSEuY29kZQogICAgICAgIGxldCBjb2RlTGVuZ3RoID0gY29kZS5sZW5ndGgKICAgICAgICB2YXIgaXNUb2tlbiA9IGZhbHNlCiAgICAgICAgdmFyIGkgPSAxMwogICAgICAgIHdoaWxlKGkgPCBjb2RlTGVuZ3RoLTEpIHsKICAgICAgICAgICAgaWYgY29kZVtpXSA9PSBicmFjZSB7CiAgICAgICAgICAgICAgICBicmVhawogICAgICAgICAgICB9CiAgICAgICAgICAgIGlmIGNvZGVbaV0gPT0gY29sb24gJiYgY29kZVtpKzFdID09IHNwYWNlIHsKICAgICAgICAgICAgICAgIGkgPSBpICsgMQogICAgICAgICAgICAgICAgd2hpbGUoY29kZVtpXSA9PSBzcGFjZSAmJiBpIDwgY29kZUxlbmd0aCkgewogICAgICAgICAgICAgICAgICAgIGkgPSBpICsgMQogICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgdmFyIGogPSAwCiAgICAgICAgICAgICAgICB3aGlsZShqIDwgaW5kZW50aWZpZXJMZW5ndGggJiYgaSA8IGNvZGVMZW5ndGgpIHsKICAgICAgICAgICAgICAgICAgICBpZiBjb2RlW2ldID09IHRva2VuSW5kZW50aWZpZXJbal0gewogICAgICAgICAgICAgICAgICAgICAgICBpID0gaSArIDEKICAgICAgICAgICAgICAgICAgICAgICAgaiA9IGogKyAxCiAgICAgICAgICAgICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgICAgICAgICAgICAgYnJlYWsKICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICBpZiBqID09IGluZGVudGlmaWVyTGVuZ3RoICYmIChjb2RlW2ldPT1zcGFjZSB8fCBjb2RlW2ldPT1icmFjZSkgewogICAgICAgICAgICAgICAgICAgIGlzVG9rZW4gPSB0cnVlCiAgICAgICAgICAgICAgICAgICAgYnJlYWsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgICAgIGkgPSBpICsgMQogICAgICAgICAgICB9CiAgICAgICAgfQogICAgICAgIGlmIGlzVG9rZW4gewogICAgICAgICAgICB0b2tlbk5hbWVzLmFwcGVuZChuYW1lKQogICAgICAgIH0KICAgIH0KICAgIHJldHVybiB0b2tlbk5hbWVzCn0\u003d", "QueryPairArrayAddr": "aW1wb3J0IFN3YXBGYWN0b3J5IGZyb20gMHhiMDYzYzE2Y2FjODVkYmQxCnB1YiBmdW4gbWFpbihmcm9tOiBVSW50NjQsIHRvOiBVSW50NjQpOiBbQWRkcmVzc10gewogICAgcmV0dXJuIFN3YXBGYWN0b3J5LmdldFNsaWNlZFBhaXJzKGZyb206IGZyb20sIHRvOiB0bykKfQo\u003d", "QueryPairArrayInfo": "aW1wb3J0IFN3YXBGYWN0b3J5IGZyb20gMHhiMDYzYzE2Y2FjODVkYmQxCnB1YiBmdW4gbWFpbihmcm9tOiBVSW50NjQsIHRvOiBVSW50NjQpOiBbQW55U3RydWN0XSB7CiAgICByZXR1cm4gU3dhcEZhY3RvcnkuZ2V0U2xpY2VkUGFpckluZm9zKGZyb206IGZyb20sIHRvOiB0bykKfQo\u003d", @@ -44,511 +279,264 @@ "A.231cc0dbbcffc4b7.ceWBTC" ] }, - "basic": { - "accountStorage": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYWNjb3VudFN0b3JhZ2UgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCiBhY2Nlc3MoYWxsKSBzdHJ1Y3QgU3RvcmFnZUluZm8gewogICAgYWNjZXNzKGFsbCkgIGxldCBjYXBhY2l0eTogVUludDY0CiAgICBhY2Nlc3MoYWxsKSAgbGV0IHVzZWQ6IFVJbnQ2NAogICAgYWNjZXNzKGFsbCkgIGxldCBhdmFpbGFibGU6IFVJbnQ2NAoKICAgIGluaXQoY2FwYWNpdHk6IFVJbnQ2NCwgdXNlZDogVUludDY0LCBhdmFpbGFibGU6IFVJbnQ2NCkgewogICAgICAgIHNlbGYuY2FwYWNpdHkgPSBjYXBhY2l0eQogICAgICAgIHNlbGYudXNlZCA9IHVzZWQKICAgICAgICBzZWxmLmF2YWlsYWJsZSA9IGF2YWlsYWJsZQogICAgfQp9CgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyOiBBZGRyZXNzKTogU3RvcmFnZUluZm8gewogICAgbGV0IGFjY3QgPSBnZXRBY2NvdW50KGFkZHIpCiAgICB2YXIgYXZhaWxhYmxlOiBVSW50NjQgPSAwCiAgICBpZiBhY2N0LnN0b3JhZ2UuY2FwYWNpdHkgPiAwIHsKICAgICAgICBhdmFpbGFibGUgPSBhY2N0LnN0b3JhZ2UuY2FwYWNpdHkgLSBhY2N0LnN0b3JhZ2UudXNlZAogICAgfQogICAgcmV0dXJuIFN0b3JhZ2VJbmZvKGNhcGFjaXR5OiBhY2N0LnN0b3JhZ2UuY2FwYWNpdHksCiAgICAgICAgICAgIHVzZWQ6IGFjY3Quc3RvcmFnZS51c2VkLAogICAgICAgICAgICBhdmFpbGFibGU6IGF2YWlsYWJsZSkKfQ\u003d\u003d", - "addContractToAccount": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYWRkQ29udHJhY3RUb0FjY291bnQgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCnRyYW5zYWN0aW9uKG5hbWU6IFN0cmluZywgY29kZTogU3RyaW5nKSB7CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChDb250cmFjdHMsIEFkZENvbnRyYWN0KSAmQWNjb3VudCkgewogICAgICAgIHNpZ25lci5jb250cmFjdHMuYWRkKG5hbWU6IG5hbWUsIGNvZGU6IGNvZGUudXRmOCkKICAgIH0KfQ\u003d\u003d", - "addKey": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYWRkS2V5IC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgQ3J5cHRvCgp0cmFuc2FjdGlvbihwdWJsaWNLZXk6IFN0cmluZywgc2lnbmF0dXJlQWxnb3JpdGhtOiBVSW50OCwgaGFzaEFsZ29yaXRobTogVUludDgsIHdlaWdodDogVUZpeDY0KSB7CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChLZXlzKSAmQWNjb3VudCkgewogICAgICAgIGxldCBrZXkgPSBQdWJsaWNLZXkoCiAgICAgICAgICAgIHB1YmxpY0tleTogcHVibGljS2V5LmRlY29kZUhleCgpLAogICAgICAgICAgICBzaWduYXR1cmVBbGdvcml0aG06IFNpZ25hdHVyZUFsZ29yaXRobShyYXdWYWx1ZTogc2lnbmF0dXJlQWxnb3JpdGhtKSEKICAgICAgICApCgogICAgICAgIHNpZ25lci5rZXlzLmFkZCgKICAgICAgICAgICAgcHVibGljS2V5OiBrZXksCiAgICAgICAgICAgIGhhc2hBbGdvcml0aG06IEhhc2hBbGdvcml0aG0ocmF3VmFsdWU6IGhhc2hBbGdvcml0aG0pISwKICAgICAgICAgICAgd2VpZ2h0OiB3ZWlnaHQKICAgICAgICApCiAgICB9Cn0\u003d", - "addKeyTemp": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYWRkS2V5VGVtcCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IENyeXB0bwoKdHJhbnNhY3Rpb24ocHVibGljS2V5czogW0NyeXB0by5LZXlMaXN0RW50cnldLCBjb250cmFjdHM6IHtTdHJpbmc6IFN0cmluZ30pIHsKCXByZXBhcmUoc2lnbmVyOiBhdXRoKEJvcnJvd1ZhbHVlIHwgU3RvcmFnZSkgJkFjY291bnQpIHsKCgkJbGV0IGFjY291bnQgPSBBY2NvdW50KHBheWVyOiBzaWduZXIpCgoJCS8vIGFkZCBhbGwgdGhlIGtleXMgdG8gdGhlIGFjY291bnQKCQlmb3Iga2V5IGluIHB1YmxpY0tleXMgewoJCQlhY2NvdW50LmtleXMuYWRkKHB1YmxpY0tleToga2V5LnB1YmxpY0tleSwgaGFzaEFsZ29yaXRobToga2V5Lmhhc2hBbGdvcml0aG0sIHdlaWdodDoga2V5LndlaWdodCkKCQl9CgkJCgkJLy8gYWRkIGNvbnRyYWN0cyBpZiBwcm92aWRlZAoJCWZvciBjb250cmFjdCBpbiBjb250cmFjdHMua2V5cyB7CgkJCWFjY291bnQuY29udHJhY3RzLmFkZChuYW1lOiBjb250cmFjdCwgY29kZTogY29udHJhY3RzW2NvbnRyYWN0XSEuZGVjb2RlSGV4KCkpCgkJfQoJfQp9", - "createAccount": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY3JlYXRlQWNjb3VudCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IENyeXB0bwppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHgxNjU0NjUzMzk5MDQwYTYxCgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKCiB0cmFuc2FjdGlvbihwdWJsaWNLZXlzOiBbQ3J5cHRvLktleUxpc3RFbnRyeV0sIGNvbnRyYWN0czoge1N0cmluZzogU3RyaW5nfSwgZnVuZEFtb3VudDogVUZpeDY0KSB7CiAgICBsZXQgdG9rZW5SZWNlaXZlcjogJntGdW5naWJsZVRva2VuLlJlY2VpdmVyfQogICAgbGV0IHNlbnRWYXVsdDogQEZ1bmdpYmxlVG9rZW4uVmF1bHQKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChCb3Jyb3dWYWx1ZSB8IFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IGFjY291bnQgPSBBY2NvdW50KHBheWVyOiBzaWduZXIpCiAgICAgICAgZm9yIGtleSBpbiBwdWJsaWNLZXlzIHsKICAgICAgICAgICAgYWNjb3VudC5rZXlzLmFkZChwdWJsaWNLZXk6IGtleS5wdWJsaWNLZXksIGhhc2hBbGdvcml0aG06IGtleS5oYXNoQWxnb3JpdGhtLCB3ZWlnaHQ6IGtleS53ZWlnaHQpCiAgICAgICAgfQogICAgICAgIGZvciBjb250cmFjdCBpbiBjb250cmFjdHMua2V5cyB7CiAgICAgICAgICAgIGFjY291bnQuY29udHJhY3RzLmFkZChuYW1lOiBjb250cmFjdCwgY29kZTogY29udHJhY3RzW2NvbnRyYWN0XSEuZGVjb2RlSGV4KCkpCiAgICAgICAgfQogICAgICAgIHNlbGYudG9rZW5SZWNlaXZlciA9IGFjY291bnQuY2FwYWJpbGl0aWVzLmJvcnJvdzwme0Z1bmdpYmxlVG9rZW4uUmVjZWl2ZXJ9PigvcHVibGljL2Zsb3dUb2tlblJlY2VpdmVyKSA/PyBwYW5pYygiVW5hYmxlIHRvIGJvcnJvdyByZWNlaXZlciByZWZlcmVuY2UiKQogICAgICAgIGxldCB2YXVsdFJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZGbG93VG9rZW4uVmF1bHQ+KGZyb206IC9zdG9yYWdlL2Zsb3dUb2tlblZhdWx0KSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIG93bmVyJydzIFZhdWx0ISIpCiAgICAgICAgc2VsZi5zZW50VmF1bHQgPC0gdmF1bHRSZWYud2l0aGRyYXcoYW1vdW50OiBmdW5kQW1vdW50KQogICAgfQogICAgZXhlY3V0ZSB7CiAgICAgICAgc2VsZi50b2tlblJlY2VpdmVyLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKICAgIH0KIH0\u003d", - "createAccountSdk": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY3JlYXRlQWNjb3VudFNkayAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IENyeXB0bwoKdHJhbnNhY3Rpb24ocHVibGljS2V5OiBTdHJpbmcsIHNpZ25hdHVyZUFsZ29yaXRobTogVUludDgsIGhhc2hBbGdvcml0aG06IFVJbnQ4LCB3ZWlnaHQ6IFVGaXg2NCwgY29udHJhY3RzOiB7U3RyaW5nOiBTdHJpbmd9KSB7CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChCb3Jyb3dWYWx1ZSB8IFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IGFjY291bnQgPSBBY2NvdW50KHBheWVyOiBzaWduZXIpCgogICAgICAgIGxldCBrZXkgPSBQdWJsaWNLZXkoCiAgICAgICAgICAgIHB1YmxpY0tleTogcHVibGljS2V5LmRlY29kZUhleCgpLAogICAgICAgICAgICBzaWduYXR1cmVBbGdvcml0aG06IFNpZ25hdHVyZUFsZ29yaXRobShyYXdWYWx1ZTogc2lnbmF0dXJlQWxnb3JpdGhtKSEKICAgICAgICApCgogICAgICAgIGFjY291bnQua2V5cy5hZGQoCiAgICAgICAgICAgIHB1YmxpY0tleToga2V5LAogICAgICAgICAgICBoYXNoQWxnb3JpdGhtOiBIYXNoQWxnb3JpdGhtKHJhd1ZhbHVlOiBoYXNoQWxnb3JpdGhtKSEsCiAgICAgICAgICAgIHdlaWdodDogd2VpZ2h0CiAgICAgICAgKQoKICAgICAgICBmb3IgY29udHJhY3QgaW4gY29udHJhY3RzLmtleXMgewogICAgICAgICAgICBhY2NvdW50LmNvbnRyYWN0cy5hZGQobmFtZTogY29udHJhY3QsIGNvZGU6IGNvbnRyYWN0c1tjb250cmFjdF0hLmRlY29kZUhleCgpKQogICAgICAgIH0KICAgIH0KfQ\u003d\u003d", - "getAccountInfo": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QWNjb3VudEluZm8gLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmFjY2VzcyhhbGwpIHN0cnVjdCBSZXN1bHQgewogIGFjY2VzcyhhbGwpIGxldCBhZGRyZXNzOiBBZGRyZXNzCiAgYWNjZXNzKGFsbCkgbGV0IGJhbGFuY2U6IFVGaXg2NAogIGFjY2VzcyhhbGwpIGxldCBhdmFpbGFibGVCYWxhbmNlOiBVRml4NjQKICBhY2Nlc3MoYWxsKSBsZXQgc3RvcmFnZVVzZWQ6IFVJbnQ2NAogIGFjY2VzcyhhbGwpIGxldCBzdG9yYWdlQ2FwYWNpdHk6IFVJbnQ2NAogIGFjY2VzcyhhbGwpIGxldCBzdG9yYWdlRmxvdzogVUZpeDY0CgogIGluaXQoCiAgICBhZGRyZXNzOiBBZGRyZXNzLAogICAgYmFsYW5jZTogVUZpeDY0LAogICAgYXZhaWxhYmxlQmFsYW5jZTogVUZpeDY0LAogICAgc3RvcmFnZVVzZWQ6IFVJbnQ2NCwKICAgIHN0b3JhZ2VDYXBhY2l0eTogVUludDY0LAogICAgc3RvcmFnZUZsb3c6IFVGaXg2NCwKICApIHsKICAgIHNlbGYuYWRkcmVzcyA9IGFkZHJlc3MKICAgIHNlbGYuYmFsYW5jZSA9IGJhbGFuY2UKICAgIHNlbGYuYXZhaWxhYmxlQmFsYW5jZSA9IGF2YWlsYWJsZUJhbGFuY2UKICAgIHNlbGYuc3RvcmFnZVVzZWQgPSBzdG9yYWdlVXNlZAogICAgc2VsZi5zdG9yYWdlQ2FwYWNpdHkgPSBzdG9yYWdlQ2FwYWNpdHkKICAgIHNlbGYuc3RvcmFnZUZsb3cgPSBzdG9yYWdlRmxvdwogIH0KfQoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IFJlc3VsdCB7CiAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgcmV0dXJuIFJlc3VsdCgKICAgIGFkZHJlc3M6IGFjY291bnQuYWRkcmVzcywKICAgIGJhbGFuY2U6IGFjY291bnQuYmFsYW5jZSwKICAgIGF2YWlsYWJsZUJhbGFuY2U6IGFjY291bnQuYXZhaWxhYmxlQmFsYW5jZSwKICAgIHN0b3JhZ2VVc2VkOiBhY2NvdW50LnN0b3JhZ2UudXNlZCwKICAgIHN0b3JhZ2VDYXBhY2l0eTogYWNjb3VudC5zdG9yYWdlLmNhcGFjaXR5LAogICAgc3RvcmFnZUZsb3c6IGFjY291bnQuYmFsYW5jZSAtIGFjY291bnQuYXZhaWxhYmxlQmFsYW5jZQogICkKfQ\u003d\u003d", - "getAccountMinFlow": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QWNjb3VudE1pbkZsb3cgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBVRml4NjQgewogIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogIHJldHVybiBhY2NvdW50LmJhbGFuY2UgLSBhY2NvdW50LmF2YWlsYWJsZUJhbGFuY2UKfQ\u003d\u003d", - "getAccountTotalFlowBalance": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QWNjb3VudFRvdGFsRmxvd0JhbGFuY2UgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHgxNjU0NjUzMzk5MDQwYTYxCgppbXBvcnQgTG9ja2VkVG9rZW5zIGZyb20gMHg4ZDBlODdiNjUxNTlhZTYzCgovLyBpbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKLy8gaW1wb3J0IEZsb3dUb2tlbiBmcm9tIDB4MTY1NDY1MzM5OTA0MGE2MQoKLy8gaW1wb3J0IExvY2tlZFRva2VucyBmcm9tIDB4OGQwZTg3YjY1MTU5YWU2MwoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBVRml4NjQgewogICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICBsZXQgdW5sb2NrZWRWYXVsdCA9IGFjY291bnQKICAgICAgLmNhcGFiaWxpdGllcy5nZXQ8JntGdW5naWJsZVRva2VuLkJhbGFuY2V9PigvcHVibGljL2Zsb3dUb2tlbkJhbGFuY2UpIQogICAgICAuYm9ycm93KCkKICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBCYWxhbmNlIHJlZmVyZW5jZSB0byB0aGUgVmF1bHQiKQogICAgbGV0IHVubG9ja2VkQmFsYW5jZSA9IHVubG9ja2VkVmF1bHQuYmFsYW5jZQogICAgICAgIAogICAgbGV0IGxvY2tlZEFjY291bnRJbmZvQ2FwID0gYWNjb3VudAogICAgICAuY2FwYWJpbGl0aWVzLmdldAogICAgICA8JkxvY2tlZFRva2Vucy5Ub2tlbkhvbGRlcj4KICAgICAgKExvY2tlZFRva2Vucy5Mb2NrZWRBY2NvdW50SW5mb1B1YmxpY1BhdGgpCiAgICBpZiBsb2NrZWRBY2NvdW50SW5mb0NhcCA9PSBuaWwgfHwgIShsb2NrZWRBY2NvdW50SW5mb0NhcCEuY2hlY2soKSkgewogICAgICAgIHJldHVybiB1bmxvY2tlZEJhbGFuY2UKICAgIH0KICAgIAogICAgbGV0IGxvY2tlZEFjY291bnRJbmZvUmVmID0gbG9ja2VkQWNjb3VudEluZm9DYXAhLmJvcnJvdygpIQogICAgbGV0IGxvY2tlZEJhbGFuY2UgPSBsb2NrZWRBY2NvdW50SW5mb1JlZi5nZXRMb2NrZWRBY2NvdW50QmFsYW5jZSgpCiAgICAKICAgIHJldHVybiBsb2NrZWRCYWxhbmNlICsgdW5sb2NrZWRCYWxhbmNlCn0\u003d", - "getAccountTotalLockedFlowBalance": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QWNjb3VudFRvdGFsTG9ja2VkRmxvd0JhbGFuY2UgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHgxNjU0NjUzMzk5MDQwYTYxCgppbXBvcnQgTG9ja2VkVG9rZW5zIGZyb20gMHg4ZDBlODdiNjUxNTlhZTYzCgoKLy8gaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKCi8vIGltcG9ydCBGbG93VG9rZW4gZnJvbSAweDE2NTQ2NTMzOTkwNDBhNjEKCi8vIGltcG9ydCBMb2NrZWRUb2tlbnMgZnJvbSAweDhkMGU4N2I2NTE1OWFlNjMKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzKTogVUZpeDY0IHsKICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQoKICAgIGxldCBsb2NrZWRBY2NvdW50SW5mb0NhcCA9IGFjY291bnQKICAgICAgLmNhcGFiaWxpdGllcy5nZXQKICAgICAgPCZMb2NrZWRUb2tlbnMuVG9rZW5Ib2xkZXI+CiAgICAgIChMb2NrZWRUb2tlbnMuTG9ja2VkQWNjb3VudEluZm9QdWJsaWNQYXRoKQogICAgaWYgbG9ja2VkQWNjb3VudEluZm9DYXAgPT0gbmlsIHx8ICEobG9ja2VkQWNjb3VudEluZm9DYXAhLmNoZWNrKCkpIHsKICAgICAgICByZXR1cm4gVUZpeDY0KDApCiAgICB9CiAgICAKICAgIGxldCBsb2NrZWRBY2NvdW50SW5mb1JlZiA9IGxvY2tlZEFjY291bnRJbmZvQ2FwIS5ib3Jyb3coKSEKICAgIGxldCBsb2NrZWRCYWxhbmNlID0gbG9ja2VkQWNjb3VudEluZm9SZWYuZ2V0TG9ja2VkQWNjb3VudEJhbGFuY2UoKQogICAgCiAgICByZXR1cm4gbG9ja2VkQmFsYW5jZQp9", - "getAccountTotalUnlockedFlowBalance": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QWNjb3VudFRvdGFsVW5sb2NrZWRGbG93QmFsYW5jZSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKLy8gaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKCi8vIGltcG9ydCBGbG93VG9rZW4gZnJvbSAweDE2NTQ2NTMzOTkwNDBhNjEKCi8vIGltcG9ydCBMb2NrZWRUb2tlbnMgZnJvbSAweDhkMGU4N2I2NTE1OWFlNjMKCgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKaW1wb3J0IEZsb3dUb2tlbiBmcm9tIDB4MTY1NDY1MzM5OTA0MGE2MQoKaW1wb3J0IExvY2tlZFRva2VucyBmcm9tIDB4OGQwZTg3YjY1MTU5YWU2MwoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBVRml4NjQgewogICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCgogICAgbGV0IHVubG9ja2VkVmF1bHQgPSBhY2NvdW50CiAgICAgIC5jYXBhYmlsaXRpZXMuZ2V0PCZGbG93VG9rZW4uVmF1bHQ+KC9wdWJsaWMvZmxvd1Rva2VuQmFsYW5jZSkhCiAgICAgIC5ib3Jyb3coKQogICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IEJhbGFuY2UgcmVmZXJlbmNlIHRvIHRoZSBWYXVsdCIpCiAgICBsZXQgdW5sb2NrZWRCYWxhbmNlID0gdW5sb2NrZWRWYXVsdC5iYWxhbmNlCgogICAgbGV0IGxvY2tlZEFjY291bnRJbmZvQ2FwID0gYWNjb3VudAogICAgICAuY2FwYWJpbGl0aWVzLmdldAogICAgICA8JkxvY2tlZFRva2Vucy5Ub2tlbkhvbGRlcj4KICAgICAgKExvY2tlZFRva2Vucy5Mb2NrZWRBY2NvdW50SW5mb1B1YmxpY1BhdGgpCiAgICBpZiBsb2NrZWRBY2NvdW50SW5mb0NhcCA9PSBuaWwgfHwgIShsb2NrZWRBY2NvdW50SW5mb0NhcCEuY2hlY2soKSkgewogICAgICAgIHJldHVybiB1bmxvY2tlZEJhbGFuY2UKICAgIH0KICAgIAogICAgbGV0IGxvY2tlZEFjY291bnRJbmZvUmVmID0gbG9ja2VkQWNjb3VudEluZm9DYXAhLmJvcnJvdygpIQogICAgbGV0IGxvY2tlZEJhbGFuY2UgPSBsb2NrZWRBY2NvdW50SW5mb1JlZi5nZXRMb2NrZWRBY2NvdW50QmFsYW5jZSgpCiAgICBsZXQgbG9ja2VkQmFsYW5jZVVubG9ja2VkID0gbG9ja2VkQWNjb3VudEluZm9SZWYuZ2V0VW5sb2NrTGltaXQoKQoKICAgIGlmIGxvY2tlZEJhbGFuY2UgPT0gVUZpeDY0KDApIHsKICAgICAgICByZXR1cm4gdW5sb2NrZWRCYWxhbmNlCiAgICB9CgogICAgaWYgbG9ja2VkQmFsYW5jZVVubG9ja2VkID4gbG9ja2VkQmFsYW5jZSB7CiAgICAgICAgcmV0dXJuIHVubG9ja2VkQmFsYW5jZSArIGxvY2tlZEJhbGFuY2UKICAgIH0KCiAgICByZXR1cm4gbG9ja2VkQmFsYW5jZVVubG9ja2VkICsgdW5sb2NrZWRCYWxhbmNlCn0\u003d", - "getAccountsDetail": "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", - "getFindAddress": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0RmluZEFkZHJlc3MgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGSU5EIGZyb20gMHgwOTdiYWZhNGUwYjQ4ZWVmCgovL0NoZWNrIHRoZSBzdGF0dXMgb2YgYSBmaW4gdXNlcgphY2Nlc3MoYWxsKSBmdW4gbWFpbihuYW1lOiBTdHJpbmcpIDogQWRkcmVzcz8gewogICAgbGV0IHN0YXR1cyA9IEZJTkQuc3RhdHVzKG5hbWUpCiAgICByZXR1cm4gc3RhdHVzLm93bmVyCn0\u003d", - "getFindDomainByAddress": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0RmluZERvbWFpbkJ5QWRkcmVzcyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZJTkQgZnJvbSAweDA5N2JhZmE0ZTBiNDhlZWYKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzKSA6IFN0cmluZz97CiAgICByZXR1cm4gRklORC5yZXZlcnNlTG9va3VwKGFkZHJlc3MpCn0\u003d", - "getFlowBalanceForAnyAccounts": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Rmxvd0JhbGFuY2VGb3JBbnlBY2NvdW50cyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4ZTQ2N2I5ZGQxMWZhMDBkZgoKCi8vIEdldCB0aGUgYWNjb3VudCBiYWxhbmNlIGZvciBhIENPQSBhY2NvdW50CmFjY2VzcyhhbGwpIGZ1biBnZXRFVk1CYWxhbmNlKF8gYWRkcmVzczogU3RyaW5nKTogVUZpeDY0PyB7CiAgICByZXR1cm4gRVZNLmFkZHJlc3NGcm9tU3RyaW5nKGFkZHJlc3MpLmJhbGFuY2UoKS5pbkZMT1coKQp9CgovLyBHZXQgdGhlIGF2YWlsYWJsZSBhY2NvdW50IGJhbGFuY2UgZm9yIGEgRmxvdyBhY2NvdW50CmFjY2VzcyhhbGwpIGZ1biBnZXRGbG93QmFsYW5jZShfIGFkZHJlc3M6IFN0cmluZyk6IFVGaXg2ND8gewogICAgaWYgbGV0IGFjY291bnQgPSBBZGRyZXNzLmZyb21TdHJpbmcoYWRkcmVzcykgewogICAgICAgIC8vIFVzZSBhdmFpbGFibGUgYmFsYW5jZSBpbnN0ZWFkIG9mIHRvdGFsIGJhbGFuY2UKICAgICAgICByZXR1cm4gZ2V0QWNjb3VudChhY2NvdW50KS5hdmFpbGFibGVCYWxhbmNlCiAgICB9CiAgICByZXR1cm4gbmlsCn0KCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3NlczogW1N0cmluZ10pOiB7U3RyaW5nOiBVRml4NjQ/fSB7CiAgICBsZXQgcmVzOiB7U3RyaW5nOiBVRml4NjQ/fSA9IHt9CgogICAgZm9yIGFkZHIgaW4gYWRkcmVzc2VzIHsKICAgICAgICBsZXQgaGV4ID0gYWRkclsxXSA9PSAieCIgPyBhZGRyIDogIjB4Ii5jb25jYXQoYWRkcikKICAgICAgICBpZiBsZXQgZmxvd0JhbGFuY2UgPSBnZXRGbG93QmFsYW5jZShoZXgpIHsKICAgICAgICAgICAgcmVzW2hleF0gPSBmbG93QmFsYW5jZQogICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgIGlmIGxldCBldm1CYWxhbmNlID0gZ2V0RVZNQmFsYW5jZShoZXgpIHsKICAgICAgICAgICAgICAgIHJlc1toZXhdID0gZXZtQmFsYW5jZQogICAgICAgICAgICB9CiAgICAgICAgfQogICAgfQogICAgcmV0dXJuIHJlcwp9", - "getFlownsAddress": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Rmxvd25zQWRkcmVzcyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3ducyBmcm9tIDB4MjMzZWIwMTJkMzRiMDA3MAoKaW1wb3J0IERvbWFpbnMgZnJvbSAweDIzM2ViMDEyZDM0YjAwNzAKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihuYW1lOiBTdHJpbmcsIHJvb3Q6IFN0cmluZykgOiBBZGRyZXNzPyB7CiAgICBsZXQgcHJlZml4ID0gIjB4IgogICAgbGV0IHJvb3RIYWhzaCA9IEZsb3ducy5oYXNoKG5vZGU6ICIiLCBsYWJsZTogcm9vdCkKICAgIGxldCBuYW1laGFzaCA9IHByZWZpeC5jb25jYXQoRmxvd25zLmhhc2gobm9kZTogcm9vdEhhaHNoLCBsYWJsZTogbmFtZSkpCiAgICB2YXIgYWRkcmVzcyA9IERvbWFpbnMuZ2V0UmVjb3JkcyhuYW1laGFzaCkKICAgIHJldHVybiBhZGRyZXNzCn0\u003d", - "getFlownsDomainsByAddress": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Rmxvd25zRG9tYWluc0J5QWRkcmVzcyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IERvbWFpbnMgZnJvbSAweDIzM2ViMDEyZDM0YjAwNzAKCi8vIGFkZHJlc3M6IEZsb3cgYWRkcmVzcwoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IFtEb21haW5zLkRvbWFpbkRldGFpbF0gewogICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICBsZXQgY29sbGVjdGlvbkNhcCA9IGFjY291bnQuZ2V0Q2FwYWJpbGl0eTwme0RvbWFpbnMuQ29sbGVjdGlvblB1YmxpY30+KERvbWFpbnMuQ29sbGVjdGlvblB1YmxpY1BhdGgpCiAgICBsZXQgY29sbGVjdGlvbiA9IGNvbGxlY3Rpb25DYXAuYm9ycm93KCkhCiAgICBsZXQgZG9tYWluczpbRG9tYWlucy5Eb21haW5EZXRhaWxdID0gW10KICAgIGxldCBpZHMgPSBjb2xsZWN0aW9uLmdldElEcygpCgogICAgZm9yIGlkIGluIGlkcyB7CiAgICAgICAgbGV0IGRvbWFpbiA9IGNvbGxlY3Rpb24uYm9ycm93RG9tYWluKGlkOiBpZCkKICAgICAgICBsZXQgZGV0YWlsID0gZG9tYWluLmdldERldGFpbCgpCiAgICAgICAgZG9tYWlucy5hcHBlbmQoZGV0YWlsKQogICAgfQoKICAgIHJldHVybiBkb21haW5zCn0\u003d", - "getStorageInfo": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0U3RvcmFnZUluZm8gLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCiBhY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyOiBBZGRyZXNzKToge1N0cmluZzogVUludDY0fSB7CiAgICBsZXQgYWNjdCA9IGdldEFjY291bnQoYWRkcikKICAgIGxldCByZXQ6IHtTdHJpbmc6IFVJbnQ2NH0gPSB7fQogICAgcmV0WyJjYXBhY2l0eSJdID0gYWNjdC5zdG9yYWdlLmNhcGFjaXR5CiAgICByZXRbInVzZWQiXSA9IGFjY3Quc3RvcmFnZS51c2VkCiAgICBpZiBhY2N0LnN0b3JhZ2UuY2FwYWNpdHkgPiAwIHsKICAgICAgICByZXRbImF2YWlsYWJsZSJdID0gYWNjdC5zdG9yYWdlLmNhcGFjaXR5IC0gIGFjY3Quc3RvcmFnZS51c2VkCiAgICB9IGVsc2UgewogICAgICAgIHJldFsiYXZhaWxhYmxlIl0gPSAwCiAgICB9CiAgICAKICAgIHJldHVybiByZXQKfQ\u003d\u003d", - "getTokenBalanceWithModel": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0VG9rZW5CYWxhbmNlV2l0aE1vZGVsIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKaW1wb3J0IDxUb2tlbj4gZnJvbSA8VG9rZW5BZGRyZXNzPgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IFVGaXg2NCB7CiAgICBsZXQgYWNjb3VudCA9IGdldEFjY291bnQoYWRkcmVzcykKCiAgICBsZXQgdmF1bHRSZWYgPSBhY2NvdW50LmNhcGFiaWxpdGllcy5ib3Jyb3c8JntGdW5naWJsZVRva2VuLkJhbGFuY2V9Pig8VG9rZW5CYWxhbmNlUGF0aD4pCiAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBCYWxhbmNlIGNhcGFiaWxpdHkiKQoKICAgIHJldHVybiB2YXVsdFJlZi5iYWxhbmNlCn0\u003d", - "isKeyHasFullAuth": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgaXNLZXlIYXNGdWxsQXV0aCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MsIHB1YmxpY0tleTogU3RyaW5nKTogQm9vbCB7CiAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgdmFyIGZsYWcgPSBmYWxzZQogIGZ1biBhY2NvdW50Rm4oYWNjb3VudEtleTogQWNjb3VudEtleSk6IEJvb2wgewogICAgbGV0IGtleSA9IFN0cmluZy5lbmNvZGVIZXgoYWNjb3VudEtleS5wdWJsaWNLZXkucHVibGljS2V5KQogICAgaWYgcHVibGljS2V5ID09IGtleSB7CiAgICAgIGZsYWcgPSBhY2NvdW50S2V5LndlaWdodCA+PSBVRml4NjQoMTAwMCkgJiYgIWFjY291bnRLZXkuaXNSZXZva2VkCiAgICB9CiAgICByZXR1cm4gZmFsc2UKICB9CiAgYWNjb3VudC5rZXlzLmZvckVhY2goYWNjb3VudEZuKQoKICByZXR1cm4gZmxhZwp9Cg\u003d\u003d", - "isKeysHasFullAuth": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgaXNLZXlzSGFzRnVsbEF1dGggLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzLCBwdWJsaWNLZXlzOiBbU3RyaW5nXSk6IEJvb2wgewogIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogIHZhciB3ZWlnaHQ6IFVGaXg2NCA9IDAuMAogIGZ1biBhY2NvdW50Rm4oYWNjb3VudEtleTogQWNjb3VudEtleSk6IEJvb2wgewogICAgbGV0IGtleSA9IFN0cmluZy5lbmNvZGVIZXgoYWNjb3VudEtleS5wdWJsaWNLZXkucHVibGljS2V5KQogICAgaWYgcHVibGljS2V5cy5jb250YWlucyhrZXkpICYmICFhY2NvdW50S2V5LmlzUmV2b2tlZCB7CiAgICAgIHdlaWdodCA9IHdlaWdodCArIGFjY291bnRLZXkud2VpZ2h0IAogICAgfQogICAgcmV0dXJuIGZhbHNlCiAgfQogIGFjY291bnQua2V5cy5mb3JFYWNoKGFjY291bnRGbikKCiAgcmV0dXJuIHdlaWdodCA+PSBVRml4NjQoMTAwMCkKfQo\u003d", - "isLockedFlowEnable": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgaXNMb2NrZWRGbG93RW5hYmxlIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTG9ja2VkVG9rZW5zIGZyb20gMHg4ZDBlODdiNjUxNTlhZTYzCgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IEJvb2wgewogICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICByZXR1cm4gYWNjb3VudC5jYXBhYmlsaXRpZXMuZXhpc3RzKExvY2tlZFRva2Vucy5Mb2NrZWRBY2NvdW50SW5mb1B1YmxpY1BhdGgpCn0\u003d", - "isTokenStorageEnabled": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgaXNUb2tlblN0b3JhZ2VFbmFibGVkIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKaW1wb3J0IDxUb2tlbj4gZnJvbSA8VG9rZW5BZGRyZXNzPgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAKICAgIGxldCByZWNlaXZlciA9IGFjY291bnQuY2FwYWJpbGl0aWVzLmV4aXN0cyg8VG9rZW5SZWNlaXZlclBhdGg+KQogICAgbGV0IGJhbGFuY2UgPSBhY2NvdW50LmNhcGFiaWxpdGllcy5leGlzdHMoPFRva2VuQmFsYW5jZVBhdGg+KQoKICAgIHJldHVybiByZWNlaXZlciAmJiBiYWxhbmNlCn0\u003d", - "queryBalanceForAccounts": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcXVlcnlCYWxhbmNlRm9yQWNjb3VudHMgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBOb25GdW5naWJsZVRva2VuIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcnM6IFtBZGRyZXNzXSk6IHtBZGRyZXNzOiBBbnlTdHJ1Y3R9IHsKCiAgICB2YXIgcmVzdWx0OiB7QWRkcmVzczogQW55U3RydWN0fSA9IHt9CiAgICBmb3IgYWRkciBpbiBhZGRycyB7CiAgICAgICAgbGV0IGFjY291bnRJbmZvID0gZ2V0QWNjb3VudEluZm8oYWRkcmVzczogYWRkcikKICAgICAgICByZXN1bHRbYWRkcl0gPSBhY2NvdW50SW5mbwogICAgfQogICAgcmV0dXJuIHJlc3VsdAp9CgphY2Nlc3MoYWxsKSBmdW4gZ2V0QWNjb3VudEluZm8oYWRkcmVzczogQWRkcmVzcyk6IEFueVN0cnVjdCB7CiAgICBsZXQgYWNjID0gZ2V0QXV0aEFjY291bnQ8YXV0aChTdG9yYWdlKSAmQWNjb3VudD4oYWRkcmVzcykKICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgbGV0IGZvdW5kVHlwZXM6IFtUeXBlXSA9IFtdCiAgICB2YXIgbmZ0Q291bnRzID0gMAoKICAgICBhY2Muc3RvcmFnZS5mb3JFYWNoU3RvcmVkKGZ1biAocGF0aDogU3RvcmFnZVBhdGgsIHR5cGU6IFR5cGUpOiBCb29sIHsKICAgICAgaWYgdHlwZS5pc1N1YnR5cGUob2Y6IFR5cGU8QHtOb25GdW5naWJsZVRva2VuLkNvbGxlY3Rpb259PigpKSAmJiAhdHlwZS5pc1JlY292ZXJlZCB7CiAgICAgICAgICB2YXIgY29sbGVjdGlvbiA9IGFjYy5zdG9yYWdlLmJvcnJvdzwme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0+KGZyb206cGF0aCkhCiAgICAgICAgICBsZXQgaWRzID0gY29sbGVjdGlvbi5nZXRJRHMoKQogICAgICAgICAgICBuZnRDb3VudHMgPSBuZnRDb3VudHMgKyBpZHMubGVuZ3RoCiAgICAgICAgfQogICAgICAgIHJldHVybiB0cnVlCiAgICB9KQoKICAgIHJldHVybiB7CiAgICAgICAgImZsb3dCYWxhbmNlIjogYWNjb3VudC5iYWxhbmNlLAogICAgICAgICJuZnRDb3VudHMiOiBuZnRDb3VudHMKICAgIH0KfQo\u003d", - "queryCustomFT": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcXVlcnlDdXN0b21GVCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IE1ldGFkYXRhVmlld3MgZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCmltcG9ydCBWaWV3UmVzb2x2ZXIgZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCmltcG9ydCBOb25GdW5naWJsZVRva2VuIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgRnVuZ2libGVUb2tlbk1ldGFkYXRhVmlld3MgZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKTWV0YWRhdGFWaWV3cwoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGNvbnRyYWN0QWRkcmVzczogQWRkcmVzcywgY29udHJhY3ROYW1lOiBTdHJpbmcpOiBGdW5naWJsZVRva2VuTWV0YWRhdGFWaWV3cy5GVFZhdWx0RGF0YSB7CiAgICAKICAgIGxldCB2aWV3UmVzb2x2ZXIgPSBnZXRBY2NvdW50KGNvbnRyYWN0QWRkcmVzcykuY29udHJhY3RzLmJvcnJvdzwme1ZpZXdSZXNvbHZlcn0+KG5hbWU6IGNvbnRyYWN0TmFtZSkKICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IFZpZXdSZXNvbHZlciBmcm9tIEZ1bmdpYmxlVG9rZW4gY29udHJhY3QiKQogICAgbGV0IHZhdWx0RGF0YSA9IHZpZXdSZXNvbHZlci5yZXNvbHZlQ29udHJhY3RWaWV3KAogICAgICAgIHJlc291cmNlVHlwZTogbmlsLAogICAgICAgIHZpZXdUeXBlOiBUeXBlPEZ1bmdpYmxlVG9rZW5NZXRhZGF0YVZpZXdzLkZUVmF1bHREYXRhPigpCiAgICApIGFzISBGdW5naWJsZVRva2VuTWV0YWRhdGFWaWV3cy5GVFZhdWx0RGF0YT8gPz8gcGFuaWMoIkNvdWxkIG5vdCByZXNvbHZlIEZUVmF1bHREYXRhIHZpZXciKQoKICAgIHJldHVybiB2YXVsdERhdGEKfQ\u003d\u003d", - "queryCustomNFT": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcXVlcnlDdXN0b21ORlQgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgVmlld1Jlc29sdmVyIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4MWQ3ZTU3YWE1NTgxNzQ0OAoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGNvbnRyYWN0QWRkcmVzczogQWRkcmVzcywgY29udHJhY3ROYW1lOiBTdHJpbmcpOiBNZXRhZGF0YVZpZXdzLk5GVENvbGxlY3Rpb25EYXRhIHsKCiAgICBsZXQgdmlld1Jlc29sdmVyID0gZ2V0QWNjb3VudChjb250cmFjdEFkZHJlc3MpLmNvbnRyYWN0cy5ib3Jyb3c8JntWaWV3UmVzb2x2ZXJ9PihuYW1lOiBjb250cmFjdE5hbWUpCiAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgVmlld1Jlc29sdmVyIGZyb20gTkZUIGNvbnRyYWN0IikKICAgIGxldCBjb2xsZWN0aW9uRGF0YSA9IHZpZXdSZXNvbHZlci5yZXNvbHZlQ29udHJhY3RWaWV3KAogICAgICAgICAgICByZXNvdXJjZVR5cGU6IG5pbCwKICAgICAgICAgICAgdmlld1R5cGU6IFR5cGU8TWV0YWRhdGFWaWV3cy5ORlRDb2xsZWN0aW9uRGF0YT4oKQogICAgICAgICkgYXMhIE1ldGFkYXRhVmlld3MuTkZUQ29sbGVjdGlvbkRhdGE/ID8/IHBhbmljKCJDb3VsZCBub3QgcmVzb2x2ZSBORlRDb2xsZWN0aW9uRGF0YSB2aWV3IikKICAgIAogICAgcmV0dXJuIGNvbGxlY3Rpb25EYXRhCn0\u003d", - "queryFlowBalance": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcXVlcnlGbG93QmFsYW5jZSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDE2NTQ2NTMzOTkwNDBhNjEKCgphY2Nlc3MoYWxsKSBmdW4gY2hlY2tGbG93VG9rZW5CYWxhbmNlKGFkZHJlc3M6IEFkZHJlc3MpIDogVUZpeDY0IHsKICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgbGV0IHZhdWx0UmVmID0gYWNjb3VudC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5CYWxhbmNlfT4oL3B1YmxpYy9mbG93VG9rZW5CYWxhbmNlKQogICAgPz8gbmlsCgogICAgCiAgICBpZiB2YXVsdFJlZiAhPSBuaWwgewogICAgICAgIHJldHVybiB2YXVsdFJlZiEuYmFsYW5jZQogICAgfQogICAgCiAgICByZXR1cm4gMC4wCn0KCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJzOiBbQWRkcmVzc10pOiBbVUZpeDY0XSB7CiAgICBsZXQgYmFsczogW1VGaXg2NF0gPSBbXQoKICAgIGZvciBhZGRyIGluIGFkZHJzIHsKICAgICAgICBsZXQgYmFsID0gY2hlY2tGbG93VG9rZW5CYWxhbmNlKGFkZHJlc3M6IGFkZHIpCiAgICAgICAgYmFscy5hcHBlbmQoYmFsKQogICAgfQogICAgCiAgICByZXR1cm4gYmFscwp9", - "removeAccountKeyByIndex": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcmVtb3ZlQWNjb3VudEtleUJ5SW5kZXggLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCnRyYW5zYWN0aW9uKGtleUluZGV4OiBJbnQpIHsKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKEtleXMpICZBY2NvdW50KSB7CiAgICAgICAgc2lnbmVyLmtleXMucmV2b2tlKGtleUluZGV4OiBrZXlJbmRleCkKICAgIH0KfQ\u003d\u003d", - "removeContractFromAccount": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcmVtb3ZlQ29udHJhY3RGcm9tQWNjb3VudCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKdHJhbnNhY3Rpb24obmFtZTogU3RyaW5nKSB7CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChSZW1vdmVDb250cmFjdCkgJkFjY291bnQpIHsKICAgICAgICBzaWduZXIuY29udHJhY3RzLnJlbW92ZShuYW1lOiBuYW1lKQogICAgfQp9", - "revokeKey": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcmV2b2tlS2V5IC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+Cgp0cmFuc2FjdGlvbihpbmRleDogSW50KSB7CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChLZXlzKSAmQWNjb3VudCkgewogICAgICAgIC8vIEdldCBhIGtleSBmcm9tIGFuIGF1dGggYWNjb3VudC4KICAgICAgICBsZXQga2V5QSA9IHNpZ25lci5rZXlzLnJldm9rZShrZXlJbmRleDogaW5kZXgpCiAgICB9Cn0\u003d", - "test": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgdGVzdCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDE2NTQ2NTMzOTkwNDBhNjEKCgp0cmFuc2FjdGlvbihhbW91bnQ6IFVGaXg2NCwgcmVjaXBpZW50OiBBZGRyZXNzKSB7CgogICAgLy8gVGhlIFZhdWx0IHJlc291cmNlIHRoYXQgaG9sZHMgdGhlIHRva2VucyB0aGF0IGFyZSBiZWluZyB0cmFuc2ZlcmVkCiAgICBsZXQgc2VudFZhdWx0OiBAe0Z1bmdpYmxlVG9rZW4uVmF1bHR9CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSwgQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgIC8vIEdldCBhIHJlZmVyZW5jZSB0byB0aGUgc2lnbmVyJ3Mgc3RvcmVkIHZhdWx0CiAgICAgICAgbGV0IHZhdWx0UmVmID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJkZsb3dUb2tlbi5WYXVsdD4oZnJvbTogL3N0b3JhZ2UvZmxvd1Rva2VuVmF1bHQpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IHJlZmVyZW5jZSB0byB0aGUgb3duZXIncyBWYXVsdCEiKQoKICAgICAgICAvLyBXaXRoZHJhdyB0b2tlbnMgZnJvbSB0aGUgc2lnbmVyJ3Mgc3RvcmVkIHZhdWx0CiAgICAgICAgc2VsZi5zZW50VmF1bHQgPC0gdmF1bHRSZWYud2l0aGRyYXcoYW1vdW50OiBhbW91bnQpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgLy8gR2V0IHRoZSByZWNpcGllbnQncyBwdWJsaWMgYWNjb3VudCBvYmplY3QKICAgICAgICBsZXQgcmVjaXBpZW50QWNjb3VudCA9IGdldEFjY291bnQocmVjaXBpZW50KQoKICAgICAgICAvLyBHZXQgYSByZWZlcmVuY2UgdG8gdGhlIHJlY2lwaWVudCdzIFJlY2VpdmVyCiAgICAgICAgbGV0IHJlY2VpdmVyUmVmID0gcmVjaXBpZW50QWNjb3VudC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5SZWNlaXZlcn0+KC9wdWJsaWMvZmxvd1Rva2VuUmVjZWl2ZXIpIQogICAgICAgICAgICAKICAgICAgICAvLyBEZXBvc2l0IHRoZSB3aXRoZHJhd24gdG9rZW5zIGluIHRoZSByZWNpcGllbnQncyByZWNlaXZlcgogICAgICAgIHJlY2VpdmVyUmVmLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKICAgIH0KfQ\u003d\u003d", - "updateContractOfAccount": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgdXBkYXRlQ29udHJhY3RPZkFjY291bnQgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCnRyYW5zYWN0aW9uKG5hbWU6IFN0cmluZywgY29kZTogU3RyaW5nKSB7CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChVcGRhdGVDb250cmFjdCkgJkFjY291bnQpIHsKICAgICAgICBzaWduZXIuY29udHJhY3RzLnVwZGF0ZShuYW1lOiBuYW1lLCBjb2RlOiBjb2RlLnV0ZjgpCiAgICB9Cn0\u003d", - "verifyUserSignature": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgdmVyaWZ5VXNlclNpZ25hdHVyZSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IENyeXB0bwoKYWNjZXNzKGFsbCkgZnVuIG1haW4oCiAgICBtZXNzYWdlOiBTdHJpbmcsCiAgICByYXdQdWJsaWNLZXlzOiBbU3RyaW5nXSwKICAgIHdlaWdodHM6IFtVRml4NjRdLAogICAgc2lnbkFsZ29zOiBbVUludDhdLAogICAgaGFzaEFsZ29zOiBbVUludDhdLAogICAgc2lnbmF0dXJlczogW1N0cmluZ10sCik6IEJvb2wgewoKICAgIGxldCBrZXlMaXN0ID0gQ3J5cHRvLktleUxpc3QoKQoKICAgIHZhciBpID0gMAogICAgZm9yIHJhd1B1YmxpY0tleSBpbiByYXdQdWJsaWNLZXlzIHsKICAgIGtleUxpc3QuYWRkKAogICAgICAgIFB1YmxpY0tleSgKICAgICAgICBwdWJsaWNLZXk6IHJhd1B1YmxpY0tleS5kZWNvZGVIZXgoKSwKICAgICAgICBzaWduYXR1cmVBbGdvcml0aG06IFNpZ25hdHVyZUFsZ29yaXRobShyYXdWYWx1ZTogc2lnbkFsZ29zW2ldKSEKICAgICAgICApLAogICAgICAgIGhhc2hBbGdvcml0aG06IEhhc2hBbGdvcml0aG0ocmF3VmFsdWU6IGhhc2hBbGdvc1tpXSkhLAogICAgICAgIHdlaWdodDogd2VpZ2h0c1tpXSwKICAgICkKICAgIGkgPSBpICsgMQogICAgfQoKICAgIGxldCBzaWduYXR1cmVTZXQ6IFtDcnlwdG8uS2V5TGlzdFNpZ25hdHVyZV0gPSBbXQoKICAgIHZhciBqID0gMAogICAgZm9yIHNpZ25hdHVyZSBpbiBzaWduYXR1cmVzIHsKICAgIHNpZ25hdHVyZVNldC5hcHBlbmQoCiAgICAgICAgQ3J5cHRvLktleUxpc3RTaWduYXR1cmUoCiAgICAgICAgICAgIGtleUluZGV4OiBqLAogICAgICAgICAgICBzaWduYXR1cmU6IHNpZ25hdHVyZS5kZWNvZGVIZXgoKQogICAgICAgICkKICAgICkKICAgICAgICBqID0gaiArIDEKICAgIH0KCiAgICBsZXQgc2lnbmVkRGF0YSA9IG1lc3NhZ2UuZGVjb2RlSGV4KCkKCiAgICByZXR1cm4ga2V5TGlzdC52ZXJpZnkoCiAgICAgICAgc2lnbmF0dXJlU2V0OiBzaWduYXR1cmVTZXQsCiAgICAgICAgc2lnbmVkRGF0YTogc2lnbmVkRGF0YSwKICAgICAgICBkb21haW5TZXBhcmF0aW9uVGFnOiAiRkxPVy1WMC4wLXVzZXIiCiAgICApCn0\u003d", - "withdrawAllUnlockedFlow": "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\u003d\u003d", - "withdrawUnlockedFlow": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgd2l0aGRyYXdVbmxvY2tlZEZsb3cgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCi8vIGltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgovLyBpbXBvcnQgRmxvd1Rva2VuIGZyb20gMHgxNjU0NjUzMzk5MDQwYTYxCgovLyBpbXBvcnQgTG9ja2VkVG9rZW5zIGZyb20gMHg4ZDBlODdiNjUxNTlhZTYzCgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDE2NTQ2NTMzOTkwNDBhNjEKCmltcG9ydCBMb2NrZWRUb2tlbnMgZnJvbSAweDhkMGU4N2I2NTE1OWFlNjMKCgp0cmFuc2FjdGlvbihhbW91bnQ6IFVGaXg2NCkgewoKICAgIGxldCBob2xkZXJSZWY6IGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgICZMb2NrZWRUb2tlbnMuVG9rZW5Ib2xkZXIKICAgIGxldCB2YXVsdFJlZjogJkZsb3dUb2tlbi5WYXVsdAoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgIHNlbGYuaG9sZGVyUmVmID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJkxvY2tlZFRva2Vucy5Ub2tlbkhvbGRlcj4oZnJvbTogTG9ja2VkVG9rZW5zLlRva2VuSG9sZGVyU3RvcmFnZVBhdGgpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IGEgcmVmZXJlbmNlIHRvIFRva2VuSG9sZGVyIikKCiAgICAgICAgc2VsZi52YXVsdFJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzwmRmxvd1Rva2VuLlZhdWx0Pihmcm9tOiAvc3RvcmFnZS9mbG93VG9rZW5WYXVsdCkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgZmxvdyB0b2tlbiB2YXVsdCByZWYiKQogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIHNlbGYudmF1bHRSZWYuZGVwb3NpdChmcm9tOiA8LXNlbGYuaG9sZGVyUmVmLndpdGhkcmF3KGFtb3VudDogYW1vdW50KSkKICAgIH0KfQ\u003d\u003d" - }, - "bridge": { - "batchBridgeNFTFromEvm": "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", - "batchBridgeNFTFromEvmV2": "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\u003d\u003d", - "batchBridgeNFTFromEvmWithPayer": "// Flow Wallet - mainnet Script  batchBridgeNFTFromEvmWithPayer - v2.72
// <platform_info>

import MetadataViews from 0x1d7e57aa55817448

import ViewResolver from 0x1d7e57aa55817448

import NonFungibleToken from 0x1d7e57aa55817448

import FungibleToken from 0xf233dcee88fe0abe

import FlowToken from 0x1654653399040a61

import FungibleTokenMetadataViews from 0xf233dcee88fe0abe

import ScopedFTProviders from 0x1e4aa0b87d10b141

import EVM from 0xe467b9dd11fa00df

import FlowEVMBridgeUtils from 0x1e4aa0b87d10b141

import FlowEVMBridge from 0x1e4aa0b87d10b141

import FlowEVMBridgeConfig from 0x1e4aa0b87d10b141

import CrossVMMetadataViews from 0x1d7e57aa55817448


/// This transaction bridges an NFT from EVM to Cadence assuming it has already been onboarded to the FlowEVMBridge
/// NOTE: The ERC721 must have first been onboarded to the bridge. This can be checked via the method
///     FlowEVMBridge.evmAddressRequiresOnboarding(address: self.evmContractAddress)
///
/// @param nftIdentifier: The Cadence type identifier of the NFT to bridge - e.g. nft.getType().identifier
/// @param id: The ERC721 id of the NFT to bridge to Cadence from EVM
///
transaction(nftIdentifier: String, ids: [UInt256]) {

    let nftType: Type
    let collection: &{NonFungibleToken.Collection}
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let coa: auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount
    let viewResolver: &{ViewResolver}

    prepare(signer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account, payer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        /* --- Construct the NFT type --- */
        //
        // Construct the NFT type from the provided identifier
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        // Parse the NFT identifier into its components
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: self.nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Reference the signer's NFT Collection --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: self.nftType,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        if signer.storage.borrow<&{NonFungibleToken.Collection}>(from: collectionData.storagePath) == nil {
            signer.storage.save(<-collectionData.createEmptyCollection(), to: collectionData.storagePath)
            signer.capabilities.unpublish(collectionData.publicPath)
            let collectionCap = signer.capabilities.storage.issue<&{NonFungibleToken.Collection}>(collectionData.storagePath)
            signer.capabilities.publish(collectionCap, at: collectionData.publicPath)
        }
        self.collection = signer.storage.borrow<&{NonFungibleToken.Collection}>(from: collectionData.storagePath)
            ?? panic("Could not borrow collection from storage path")

        /* --- Configure a ScopedFTProvider --- */
        //
        // Calculate the bridge fee - bridging from EVM consumes no storage, so flat fee
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000) + (FlowEVMBridgeConfig.baseFee * UFix64(ids.length))
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if payer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = payer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            payer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = payer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
            provider: providerCapCopy,
            filters: [ providerFilter ],
            expiration: getCurrentBlock().timestamp + 1.0
        )
    }

    execute {
        // Unwrap NFTs from project-defined ERC721 wrapper contract if applicable
        unwrapNFTsIfApplicable(self.coa, nftIDs: ids, nftType: self.nftType, viewResolver: self.viewResolver)

        // Execute the bridge
        var idx = 0
        while idx < ids.length {
            let nftId = ids[idx]!
            // Execute the bridge
            let nft: @{NonFungibleToken.NFT} <- self.coa.withdrawNFT(
                type: self.nftType,
                id: nftId,
                feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
            // Ensure the bridged nft is the correct type
            assert(
                nft.getType() == self.nftType,
                message: "Bridged nft type mismatch - requested: ".concat(self.nftType.identifier)
                    .concat(", received: ").concat(nft.getType().identifier)
            )
            // Deposit the bridged NFT into the signer's collection
            self.collection.deposit(token: <-nft)
            idx = idx + 1
        }

        // Destroy the ScopedFTProvider
        destroy self.scopedProvider
    }
}

/// Unwraps NFTs from a project's custom ERC721 wrapper contract to bridged NFTs on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
///
access(all) fun unwrapNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt256],
    nftType: Type,
    viewResolver: &{ViewResolver}
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            for id in nftIDs {
                // Unwrap NFT if it is wrapped
                if isNFTWrapped(coa,
                    nftID: id,
                    underlying: underlyingAddress,
                    wrapper: crossVMPointer.evmContractAddress
                ) {
                    let res = mustCall(coa, crossVMPointer.evmContractAddress,
                        functionSig: "withdrawTo(address,uint256[])",
                        args: [coa.address(), [id]]
                    )
                    let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                    assert(decodedRes.length == 1, message: "Invalid response length")
                    assert(decodedRes[0] as! Bool, message: "Failed to unwrap NFT")
                }
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is wrapped in the underlying ERC721 contract
///
access(all) fun isNFTWrapped(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftID: UInt256,
    underlying: EVM.EVMAddress,
    wrapper: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: underlying,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return false
    if res.status != EVM.Status.successful || res.data.length == 0{
        return false
    }

    // Decode and compare the addresses
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    let owner = decodedResult[0] as! EVM.EVMAddress
    return owner.toString() == wrapper.toString()
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", - "batchBridgeNFTToEvm": "// Flow Wallet - mainnet Script  batchBridgeNFTToEvm - v2.72
// <platform_info>

import FungibleToken from 0xf233dcee88fe0abe

import FlowToken from 0x1654653399040a61

import MetadataViews from 0x1d7e57aa55817448

import ViewResolver from 0x1d7e57aa55817448

import NonFungibleToken from 0x1d7e57aa55817448

import ScopedFTProviders from 0x1e4aa0b87d10b141

import EVM from 0xe467b9dd11fa00df

import FlowEVMBridgeUtils from 0x1e4aa0b87d10b141

import FlowEVMBridge from 0x1e4aa0b87d10b141

import FlowEVMBridgeConfig from 0x1e4aa0b87d10b141

import CrossVMMetadataViews from 0x1d7e57aa55817448


transaction(nftContractAddress: Address, nftContractName: String, ids: [UInt64]) {

    let nfts: @{UInt64 : {NonFungibleToken.NFT}}
    let coa: auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let nftType: Type
    let viewResolver: &{ViewResolver}

    prepare(signer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account) {

        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        self.nfts <- {}
        /* --- Retrieve the NFT --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        
        // Initialize nftType from the contract
        let nftIdentifier = "A.".concat(nftContractAddress.toString().slice(from: 2, upTo: nftContractAddress.toString().length)).concat(".").concat(nftContractName).concat(".NFT")
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
            
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: nil,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        let collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            ) ?? panic("Could not access signer's NFT Collection")

        // Withdraw the requested NFT & calculate the approximate bridge fee based on NFT storage usage
        let currentStorageUsage = signer.storage.used
        for id in ids {
            let nft <- collection.withdraw(withdrawID: id)
            self.nfts[id] <-! nft
        }
        // self.nft <- collection.withdraw(withdrawID: id)
        let withdrawnStorageUsage = signer.storage.used
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(
                bytes: currentStorageUsage - withdrawnStorageUsage
            ) * 1.10 * UFix64(ids.length)

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    execute {
        // Execute the bridge
        var idx = 0
        while idx < ids.length {
            let nftId = ids[idx]!
            let nft <- self.nfts.remove(key: nftId)! as @{NonFungibleToken.NFT}
            self.coa.depositNFT(
                nft: <- nft!,
                feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
            idx = idx + 1
        }

        // Destroy the ScopedFTProvider
        destroy self.scopedProvider
        destroy self.nfts

        // Wrap NFTs if applicable
        wrapAndTransferNFTsIfApplicable(self.coa,
            nftIDs: ids,
            nftType: self.nftType,
            viewResolver: self.viewResolver,
            recipientIfNotCoa: nil
        )
    }
}

/// Wraps and transfers bridged NFTs into a project's custom ERC721 wrapper contract on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
/// @param recipientIfNotCoa: The EVM address to transfer the wrapped NFTs to, nil if the NFTs should stay in signer's COA
///
access(all) fun wrapAndTransferNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt64],
    nftType: Type,
    viewResolver: &{ViewResolver},
    recipientIfNotCoa: EVM.EVMAddress?
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            // Wrap NFTs if underlying ERC721 address matches bridge's associated address for NFT type
            if underlyingAddress.equals(FlowEVMBridgeConfig.getEVMAddressAssociated(with: nftType)!) {
                // Approve contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, true]
                )

                // Wrap NFTs with provided IDs, and check if the call was successful
                let res = mustCall(coa, crossVMPointer.evmContractAddress,
                    functionSig: "depositFor(address,uint256[])",
                    args: [coa.address(), nftIDs]
                )
                let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                assert(decodedRes.length == 1, message: "Invalid response length")
                assert(decodedRes[0] as! Bool, message: "Failed to wrap NFTs")

                // Transfer NFTs to recipient if provided
                if let to = recipientIfNotCoa {
                    mustTransferNFTs(coa, crossVMPointer.evmContractAddress, nftIDs: nftIDs, to: to)
                }

                // Revoke approval for contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, false]
                )
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is owned by the provided EVM address
///
access(all) fun isOwner(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    _ nftID: UInt64,
    _ ownerToCheck: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: erc721Address,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )
    assert(res.status == EVM.Status.successful, message: "Call to ERC721.ownerOf(uint256) failed")
    let decodedRes = EVM.decodeABI(types: [Type<EVM.EVMAddress>()], data: res.data)
    if decodedRes.length == 1 {
        let actualOwner = decodedRes[0] as! EVM.EVMAddress
        return actualOwner.equals(ownerToCheck)
    }
    return false
}

/// Transfers NFTs from the provided COA to the provided EVM address
///
access(all) fun mustTransferNFTs(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    nftIDs: [UInt64],
    to: EVM.EVMAddress
) {
    for id in nftIDs {
        assert(isOwner(coa, erc721Address, id, coa.address()), message: "NFT not owned by signer's COA")
        mustCall(coa, erc721Address,
            functionSig: "safeTransferFrom(address,address,uint256)",
            args: [coa.address(), to, id]
        )
        assert(isOwner(coa, erc721Address, id, to), message: "NFT not transferred to recipient")
    }
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", - "batchBridgeNFTToEvmAddress": "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\u003d", - "batchBridgeNFTToEvmAddressWithPayer": "// Flow Wallet - mainnet Script  batchBridgeNFTToEvmAddressWithPayer - v2.72
// <platform_info>

import MetadataViews from 0x1d7e57aa55817448

import ViewResolver from 0x1d7e57aa55817448

import NonFungibleToken from 0x1d7e57aa55817448

import FungibleToken from 0xf233dcee88fe0abe

import FlowToken from 0x1654653399040a61

import FungibleTokenMetadataViews from 0xf233dcee88fe0abe

import ScopedFTProviders from 0x1e4aa0b87d10b141

import EVM from 0xe467b9dd11fa00df

import FlowEVMBridgeUtils from 0x1e4aa0b87d10b141

import FlowEVMBridge from 0x1e4aa0b87d10b141

import FlowEVMBridgeConfig from 0x1e4aa0b87d10b141

import CrossVMMetadataViews from 0x1d7e57aa55817448


/// Bridges an NFT from the signer's collection in Cadence to the signer's COA in FlowEVM
///
/// NOTE: This transaction also onboards the NFT to the bridge if necessary which may incur additional fees
///     than bridging an asset that has already been onboarded.
///
/// @param nftIdentifier: The Cadence type identifier of the NFT to bridge - e.g. nft.getType().identifier
/// @param id: The Cadence NFT.id of the NFT to bridge to EVM
///
transaction(nftIdentifier: String, ids: [UInt64], recipient: String) {
    let nft: @{NonFungibleToken.NFT}
    let requiresOnboarding: Bool
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let collection: auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}
    let nftType: Type
    let coa: auth(EVM.Call) &EVM.CadenceOwnedAccount
    let viewResolver: &{ViewResolver}

    prepare(signer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account, payer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account) {
        // Retrieve or create COA
        if let coa = signer.storage.borrow<auth(EVM.Call) &EVM.CadenceOwnedAccount>(from: /storage/evm) {
            self.coa = coa
        } else {
            signer.storage.save<@EVM.CadenceOwnedAccount>(<- EVM.createCadenceOwnedAccount(), to: /storage/evm)
            signer.capabilities.publish(
                signer.capabilities.storage.issue<&EVM.CadenceOwnedAccount>(/storage/evm),
                at: /public/evm
            )
            self.coa = signer.storage.borrow<auth(EVM.Call) &EVM.CadenceOwnedAccount>(from: /storage/evm)!
        }

        /* --- Construct the NFT type --- */
        //
        // Construct the NFT type from the provided identifier
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        // Parse the NFT identifier into its components
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: self.nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Retrieve the NFT --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: nil,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        self.collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            ) ?? panic("Could not access signer's NFT Collection")

        // Withdraw the requested NFT & calculate the approximate bridge fee based on NFT storage usage
        let currentStorageUsage = signer.storage.used
        self.nft <- self.collection.withdraw(withdrawID: ids[0])
        let withdrawnStorageUsage = signer.storage.used
        var approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000) + (FlowEVMBridgeConfig.baseFee * UFix64(ids.length))

        // Determine if the NFT requires onboarding - this impacts the fee required
        self.requiresOnboarding = FlowEVMBridge.typeRequiresOnboarding(self.nft.getType())
            ?? panic("Bridge does not support this asset type")
        if self.requiresOnboarding {
            approxFee = approxFee + FlowEVMBridgeConfig.onboardFee
        }

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if payer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = payer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            payer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = payer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    pre {
        self.nft.getType().identifier == nftIdentifier:
            "Attempting to send invalid nft type - requested: ".concat(nftIdentifier)
            .concat(", sending: ").concat(self.nft.getType().identifier)
    }

    execute {
        if self.requiresOnboarding {
            // Onboard the NFT to the bridge
            FlowEVMBridge.onboardByType(
                self.nft.getType(),
                feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
        }
        // Execute the bridge transaction
        self.coa.depositNFT(
            nft: <- self.nft,
            feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )

        var idx = 0
        for id in ids {
            if idx == 0 {
                idx = idx + 1
                continue
            }

            self.coa.depositNFT(
                nft: <- self.collection.withdraw(withdrawID: id),
                feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
        }

        // Destroy the ScopedFTProvider
        destroy self.scopedProvider

        // Wrap NFTs if applicable
        wrapAndTransferNFTsIfApplicable(self.coa,
            nftIDs: ids,
            nftType: self.nftType,
            viewResolver: self.viewResolver,
            recipientIfNotCoa: EVM.addressFromString(recipient)
        )
    }
}

/// Wraps and transfers bridged NFTs into a project's custom ERC721 wrapper contract on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
/// @param recipientIfNotCoa: The EVM address to transfer the wrapped NFTs to, nil if the NFTs should stay in signer's COA
///
access(all) fun wrapAndTransferNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt64],
    nftType: Type,
    viewResolver: &{ViewResolver},
    recipientIfNotCoa: EVM.EVMAddress?
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            // Wrap NFTs if underlying ERC721 address matches bridge's associated address for NFT type

            if underlyingAddress.equals(FlowEVMBridgeConfig.getEVMAddressAssociated(with: nftType)!) {
                // Approve contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, true]
                )

                // Wrap NFTs with provided IDs, and check if the call was successful
                let res = mustCall(coa, crossVMPointer.evmContractAddress,
                    functionSig: "depositFor(address,uint256[])",
                    args: [coa.address(), nftIDs]
                )
                let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                assert(decodedRes.length == 1, message: "Invalid response length")
                assert(decodedRes[0] as! Bool, message: "Failed to wrap NFTs")

                // Transfer NFTs to recipient if provided
                if let to = recipientIfNotCoa {
                    mustTransferNFTs(coa, crossVMPointer.evmContractAddress, nftIDs: nftIDs, to: to)
                }

                // Revoke approval for contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, false]
                )
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is owned by the provided EVM address
///
access(all) fun isOwner(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    _ nftID: UInt64,
    _ ownerToCheck: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: erc721Address,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )
    assert(res.status == EVM.Status.successful, message: "Call to ERC721.ownerOf(uint256) failed")
    let decodedRes = EVM.decodeABI(types: [Type<EVM.EVMAddress>()], data: res.data)
    if decodedRes.length == 1 {
        let actualOwner = decodedRes[0] as! EVM.EVMAddress
        return actualOwner.equals(ownerToCheck)
    }
    return false
}

/// Transfers NFTs from the provided COA to the provided EVM address
///
access(all) fun mustTransferNFTs(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    nftIDs: [UInt64],
    to: EVM.EVMAddress
) {
    for id in nftIDs {
        assert(isOwner(coa, erc721Address, id, coa.address()), message: "NFT not owned by signer's COA")
        mustCall(coa, erc721Address,
            functionSig: "safeTransferFrom(address,address,uint256)",
            args: [coa.address(), to, id]
        )
        assert(isOwner(coa, erc721Address, id, to), message: "NFT not transferred to recipient")
    }
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", - "batchBridgeNFTToEvmV2": "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\u003d", - "batchBridgeNFTToEvmWithPayer": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYmF0Y2hCcmlkZ2VORlRUb0V2bVdpdGhQYXllciAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKCmltcG9ydCBDcm9zc1ZNTWV0YWRhdGFWaWV3cyBmcm9tIDB4MWQ3ZTU3YWE1NTgxNzQ0OAoKaW1wb3J0IE1ldGFkYXRhVmlld3MgZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCmltcG9ydCBWaWV3UmVzb2x2ZXIgZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCmltcG9ydCBOb25GdW5naWJsZVRva2VuIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKaW1wb3J0IEZsb3dUb2tlbiBmcm9tIDB4MTY1NDY1MzM5OTA0MGE2MQoKaW1wb3J0IEZ1bmdpYmxlVG9rZW5NZXRhZGF0YVZpZXdzIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgppbXBvcnQgU2NvcGVkRlRQcm92aWRlcnMgZnJvbSAweDFlNGFhMGI4N2QxMGIxNDEKCmltcG9ydCBFVk0gZnJvbSAweGU0NjdiOWRkMTFmYTAwZGYKCmltcG9ydCBGbG93RVZNQnJpZGdlVXRpbHMgZnJvbSAweDFlNGFhMGI4N2QxMGIxNDEKCmltcG9ydCBGbG93RVZNQnJpZGdlIGZyb20gMHgxZTRhYTBiODdkMTBiMTQxCgppbXBvcnQgRmxvd0VWTUJyaWRnZUNvbmZpZyBmcm9tIDB4MWU0YWEwYjg3ZDEwYjE0MQoKCi8vLyBCcmlkZ2VzIGFuIE5GVCBmcm9tIHRoZSBzaWduZXIncyBjb2xsZWN0aW9uIGluIENhZGVuY2UgdG8gdGhlIHNpZ25lcidzIENPQSBpbiBGbG93RVZNCi8vLwovLy8gTk9URTogVGhpcyB0cmFuc2FjdGlvbiBhbHNvIG9uYm9hcmRzIHRoZSBORlQgdG8gdGhlIGJyaWRnZSBpZiBuZWNlc3Nhcnkgd2hpY2ggbWF5IGluY3VyIGFkZGl0aW9uYWwgZmVlcwovLy8gICAgIHRoYW4gYnJpZGdpbmcgYW4gYXNzZXQgdGhhdCBoYXMgYWxyZWFkeSBiZWVuIG9uYm9hcmRlZC4KLy8vCi8vLyBAcGFyYW0gbmZ0SWRlbnRpZmllcjogVGhlIENhZGVuY2UgdHlwZSBpZGVudGlmaWVyIG9mIHRoZSBORlQgdG8gYnJpZGdlIC0gZS5nLiBuZnQuZ2V0VHlwZSgpLmlkZW50aWZpZXIKLy8vIEBwYXJhbSBpZHM6IFRoZSBDYWRlbmNlIGlkcyBvZiB0aGUgTkZUcyB0byBicmlkZ2UgdG8gRVZNCi8vLwp0cmFuc2FjdGlvbihuZnRJZGVudGlmaWVyOiBTdHJpbmcsIGlkczogW1VJbnQ2NF0pIHsKCiAgICBsZXQgY29hOiBhdXRoKEVWTS5DYWxsLCBFVk0uQnJpZGdlKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQKICAgIGxldCByZXF1aXJlc09uYm9hcmRpbmc6IEJvb2wKICAgIGxldCBuZnRUeXBlOiBUeXBlCgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoQ29weVZhbHVlLCBCb3Jyb3dWYWx1ZSwgSXNzdWVTdG9yYWdlQ2FwYWJpbGl0eUNvbnRyb2xsZXIsIFB1Ymxpc2hDYXBhYmlsaXR5LCBTYXZlVmFsdWUpICZBY2NvdW50LCBwYXllcjogYXV0aChDb3B5VmFsdWUsIEJvcnJvd1ZhbHVlLCBJc3N1ZVN0b3JhZ2VDYXBhYmlsaXR5Q29udHJvbGxlciwgUHVibGlzaENhcGFiaWxpdHksIFNhdmVWYWx1ZSkgJkFjY291bnQpIHsKICAgICAgICAvKiAtLS0gUmVmZXJlbmNlIHRoZSBzaWduZXIncyBDYWRlbmNlT3duZWRBY2NvdW50IC0tLSAqLwogICAgICAgIC8vCiAgICAgICAgLy8gQm9ycm93IGEgcmVmZXJlbmNlIHRvIHRoZSBzaWduZXIncyBDT0EKICAgICAgICBzZWxmLmNvYSA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEVWTS5DYWxsLCBFVk0uQnJpZGdlKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KGZyb206IC9zdG9yYWdlL2V2bSkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgQ09BIGZyb20gcHJvdmlkZWQgZ2F0ZXdheSBhZGRyZXNzIikKCiAgICAgICAgLyogLS0tIENvbnN0cnVjdCB0aGUgTkZUIHR5cGUgLS0tICovCiAgICAgICAgLy8KICAgICAgICAvLyBDb25zdHJ1Y3QgdGhlIE5GVCB0eXBlIGZyb20gdGhlIHByb3ZpZGVkIGlkZW50aWZpZXIKICAgICAgICBzZWxmLm5mdFR5cGUgPSBDb21wb3NpdGVUeXBlKG5mdElkZW50aWZpZXIpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgY29uc3RydWN0IE5GVCB0eXBlIGZyb20gaWRlbnRpZmllcjogIi5jb25jYXQobmZ0SWRlbnRpZmllcikpCiAgICAgICAgLy8gUGFyc2UgdGhlIE5GVCBpZGVudGlmaWVyIGludG8gaXRzIGNvbXBvbmVudHMKICAgICAgICBsZXQgbmZ0Q29udHJhY3RBZGRyZXNzID0gRmxvd0VWTUJyaWRnZVV0aWxzLmdldENvbnRyYWN0QWRkcmVzcyhmcm9tVHlwZTogc2VsZi5uZnRUeXBlKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGdldCBjb250cmFjdCBhZGRyZXNzIGZyb20gaWRlbnRpZmllcjogIi5jb25jYXQobmZ0SWRlbnRpZmllcikpCiAgICAgICAgbGV0IG5mdENvbnRyYWN0TmFtZSA9IEZsb3dFVk1CcmlkZ2VVdGlscy5nZXRDb250cmFjdE5hbWUoZnJvbVR5cGU6IHNlbGYubmZ0VHlwZSkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBnZXQgY29udHJhY3QgbmFtZSBmcm9tIGlkZW50aWZpZXI6ICIuY29uY2F0KG5mdElkZW50aWZpZXIpKQoKICAgICAgICAvKiAtLS0gUmV0cmlldmUgdGhlIE5GVCAtLS0gKi8KICAgICAgICAvLwogICAgICAgIC8vIEJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgTkZUIGNvbGxlY3Rpb24sIGNvbmZpZ3VyaW5nIGlmIG5lY2Vzc2FyeQogICAgICAgIGxldCB2aWV3UmVzb2x2ZXIgPSBnZXRBY2NvdW50KG5mdENvbnRyYWN0QWRkcmVzcykuY29udHJhY3RzLmJvcnJvdzwme1ZpZXdSZXNvbHZlcn0+KG5hbWU6IG5mdENvbnRyYWN0TmFtZSkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgVmlld1Jlc29sdmVyIGZyb20gTkZUIGNvbnRyYWN0IikKICAgICAgICBsZXQgY29sbGVjdGlvbkRhdGEgPSB2aWV3UmVzb2x2ZXIucmVzb2x2ZUNvbnRyYWN0VmlldygKICAgICAgICAgICAgICAgIHJlc291cmNlVHlwZTogc2VsZi5uZnRUeXBlLAogICAgICAgICAgICAgICAgdmlld1R5cGU6IFR5cGU8TWV0YWRhdGFWaWV3cy5ORlRDb2xsZWN0aW9uRGF0YT4oKQogICAgICAgICAgICApIGFzISBNZXRhZGF0YVZpZXdzLk5GVENvbGxlY3Rpb25EYXRhPyA/PyBwYW5pYygiQ291bGQgbm90IHJlc29sdmUgTkZUQ29sbGVjdGlvbkRhdGEgdmlldyIpCiAgICAgICAgbGV0IGNvbGxlY3Rpb24gPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChOb25GdW5naWJsZVRva2VuLldpdGhkcmF3KSAme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0+KAogICAgICAgICAgICAgICAgZnJvbTogY29sbGVjdGlvbkRhdGEuc3RvcmFnZVBhdGgKICAgICAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGFjY2VzcyBzaWduZXIncyBORlQgQ29sbGVjdGlvbiIpCgogICAgICAgIC8vIFdpdGhkcmF3IHRoZSByZXF1ZXN0ZWQgTkZUICYgY2FsY3VsYXRlIHRoZSBhcHByb3hpbWF0ZSBicmlkZ2UgZmVlIGJhc2VkIG9uIE5GVCBzdG9yYWdlIHVzYWdlCiAgICAgICAgbGV0IGN1cnJlbnRTdG9yYWdlVXNhZ2UgPSBzaWduZXIuc3RvcmFnZS51c2VkCiAgICAgICAgbGV0IG5mdCA8LSBjb2xsZWN0aW9uLndpdGhkcmF3KHdpdGhkcmF3SUQ6IGlkc1swXSkKICAgICAgICBsZXQgd2l0aGRyYXduU3RvcmFnZVVzYWdlID0gc2lnbmVyLnN0b3JhZ2UudXNlZAogICAgICAgIHZhciBhcHByb3hGZWUgPSBGbG93RVZNQnJpZGdlVXRpbHMuY2FsY3VsYXRlQnJpZGdlRmVlKGJ5dGVzOiA0MDBfMDAwKSArIChGbG93RVZNQnJpZGdlQ29uZmlnLmJhc2VGZWUgKiBVRml4NjQoaWRzLmxlbmd0aCkpCiAgICAgICAgLy8gRGV0ZXJtaW5lIGlmIHRoZSBORlQgcmVxdWlyZXMgb25ib2FyZGluZyAtIHRoaXMgaW1wYWN0cyB0aGUgZmVlIHJlcXVpcmVkCiAgICAgICAgc2VsZi5yZXF1aXJlc09uYm9hcmRpbmcgPSBGbG93RVZNQnJpZGdlLnR5cGVSZXF1aXJlc09uYm9hcmRpbmcoc2VsZi5uZnRUeXBlKQogICAgICAgICAgICA/PyBwYW5pYygiQnJpZGdlIGRvZXMgbm90IHN1cHBvcnQgdGhpcyBhc3NldCB0eXBlIikKICAgICAgICBpZiBzZWxmLnJlcXVpcmVzT25ib2FyZGluZyB7CiAgICAgICAgICAgIGFwcHJveEZlZSA9IGFwcHJveEZlZSArIEZsb3dFVk1CcmlkZ2VDb25maWcub25ib2FyZEZlZQogICAgICAgIH0KCiAgICAgICAgLyogLS0tIENvbmZpZ3VyZSBhIFNjb3BlZEZUUHJvdmlkZXIgLS0tICovCiAgICAgICAgLy8KICAgICAgICAvLyBJc3N1ZSBhbmQgc3RvcmUgYnJpZGdlLWRlZGljYXRlZCBQcm92aWRlciBDYXBhYmlsaXR5IGluIHN0b3JhZ2UgaWYgbmVjZXNzYXJ5CiAgICAgICAgaWYgcGF5ZXIuc3RvcmFnZS50eXBlKGF0OiBGbG93RVZNQnJpZGdlQ29uZmlnLnByb3ZpZGVyQ2FwYWJpbGl0eVN0b3JhZ2VQYXRoKSA9PSBuaWwgewogICAgICAgICAgICBsZXQgcHJvdmlkZXJDYXAgPSBwYXllci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+KAogICAgICAgICAgICAgICAgL3N0b3JhZ2UvZmxvd1Rva2VuVmF1bHQKICAgICAgICAgICAgKQogICAgICAgICAgICBwYXllci5zdG9yYWdlLnNhdmUocHJvdmlkZXJDYXAsIHRvOiBGbG93RVZNQnJpZGdlQ29uZmlnLnByb3ZpZGVyQ2FwYWJpbGl0eVN0b3JhZ2VQYXRoKQogICAgICAgIH0KICAgICAgICAvLyBDb3B5IHRoZSBzdG9yZWQgUHJvdmlkZXIgY2FwYWJpbGl0eSBhbmQgY3JlYXRlIGEgU2NvcGVkRlRQcm92aWRlcgogICAgICAgIGxldCBwcm92aWRlckNhcENvcHkgPSBwYXllci5zdG9yYWdlLmNvcHk8Q2FwYWJpbGl0eTxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+PigKICAgICAgICAgICAgICAgIGZyb206IEZsb3dFVk1CcmlkZ2VDb25maWcucHJvdmlkZXJDYXBhYmlsaXR5U3RvcmFnZVBhdGgKICAgICAgICAgICAgKSA/PyBwYW5pYygiSW52YWxpZCBQcm92aWRlciBDYXBhYmlsaXR5IGZvdW5kIGluIHN0b3JhZ2UuIikKICAgICAgICBsZXQgcHJvdmlkZXJGaWx0ZXIgPSBTY29wZWRGVFByb3ZpZGVycy5BbGxvd2FuY2VGaWx0ZXIoYXBwcm94RmVlKQogICAgICAgIGxldCBzY29wZWRQcm92aWRlciA8LSBTY29wZWRGVFByb3ZpZGVycy5jcmVhdGVTY29wZWRGVFByb3ZpZGVyKAogICAgICAgICAgICAgICAgcHJvdmlkZXI6IHByb3ZpZGVyQ2FwQ29weSwKICAgICAgICAgICAgICAgIGZpbHRlcnM6IFsgcHJvdmlkZXJGaWx0ZXIgXSwKICAgICAgICAgICAgICAgIGV4cGlyYXRpb246IGdldEN1cnJlbnRCbG9jaygpLnRpbWVzdGFtcCArIDEuMAogICAgICAgICkKICAgICAgICBzZWxmLmNvYS5kZXBvc2l0TkZUKAogICAgICAgICAgICBuZnQ6IDwtIG5mdCwKICAgICAgICAgICAgZmVlUHJvdmlkZXI6ICZzY29wZWRQcm92aWRlciBhcyBhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0KICAgICAgICApCgogICAgICAgIHZhciBpZHggPSAwCiAgICAgICAgd2hpbGUgaWR4IDwgaWRzLmxlbmd0aCB7CiAgICAgICAgICAgIGlmIGlkeCA9PSAwIHsKICAgICAgICAgICAgICAgIGlkeCA9IGlkeCArIDEKICAgICAgICAgICAgICAgIGNvbnRpbnVlCiAgICAgICAgICAgIH0KICAgICAgICAgICAgbGV0IG5mdElkID0gaWRzW2lkeF0hCiAgICAgICAgICAgIGxldCBuZnQgPC0gY29sbGVjdGlvbi53aXRoZHJhdyh3aXRoZHJhd0lEOiBuZnRJZCkhIGFzIEB7Tm9uRnVuZ2libGVUb2tlbi5ORlR9CiAgICAgICAgICAgIHNlbGYuY29hLmRlcG9zaXRORlQoCiAgICAgICAgICAgICAgICBuZnQ6IDwtIG5mdCwKICAgICAgICAgICAgICAgIGZlZVByb3ZpZGVyOiAmc2NvcGVkUHJvdmlkZXIgYXMgYXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAme0Z1bmdpYmxlVG9rZW4uUHJvdmlkZXJ9CiAgICAgICAgICAgICkKICAgICAgICAgICAgaWR4ID0gaWR4ICsgMQogICAgICAgIH0KCiAgICAgICAgLy8gRGVzdHJveSB0aGUgU2NvcGVkRlRQcm92aWRlcgogICAgICAgIGRlc3Ryb3kgc2NvcGVkUHJvdmlkZXIKCiAgICAgICAgLy8gV3JhcCBORlRzIGlmIGFwcGxpY2FibGUKICAgICAgICB3cmFwQW5kVHJhbnNmZXJORlRzSWZBcHBsaWNhYmxlKHNlbGYuY29hLAogICAgICAgICAgICBuZnRJRHM6IGlkcywKICAgICAgICAgICAgbmZ0VHlwZTogc2VsZi5uZnRUeXBlLAogICAgICAgICAgICB2aWV3UmVzb2x2ZXI6IHZpZXdSZXNvbHZlciwKICAgICAgICAgICAgcmVjaXBpZW50SWZOb3RDb2E6IG5pbAogICAgICAgICkKICAgIH0KfQoKLy8vIFdyYXBzIGFuZCB0cmFuc2ZlcnMgYnJpZGdlZCBORlRzIGludG8gYSBwcm9qZWN0J3MgY3VzdG9tIEVSQzcyMSB3cmFwcGVyIGNvbnRyYWN0IG9uIEVWTSwgaWYgYXBwbGljYWJsZS4KLy8vIEVuYWJsZXMgcHJvamVjdHMgdG8gdXNlIHRoZWlyIG93biBFUkM3MjEgY29udHJhY3Qgd2hpbGUgbGV2ZXJhZ2luZyB0aGUgYnJpZGdlJ3MgdW5kZXJseWluZyBjb250cmFjdCwKLy8vIHVudGlsIGRpcmVjdCBjdXN0b20gY29udHJhY3Qgc3VwcG9ydCBpcyBhZGRlZCB0byB0aGUgYnJpZGdlLgovLy8KLy8vIEBwYXJhbSBjb2E6IFRoZSBDT0Egb2YgdGhlIHNpZ25lcgovLy8gQHBhcmFtIG5mdElEczogVGhlIElEcyBvZiB0aGUgTkZUcyB0byB3cmFwCi8vLyBAcGFyYW0gbmZ0VHlwZTogVGhlIHR5cGUgb2YgdGhlIE5GVHMgdG8gd3JhcAovLy8gQHBhcmFtIHZpZXdSZXNvbHZlcjogVGhlIFZpZXdSZXNvbHZlciBvZiB0aGUgTkZUIGNvbnRyYWN0Ci8vLyBAcGFyYW0gcmVjaXBpZW50SWZOb3RDb2E6IFRoZSBFVk0gYWRkcmVzcyB0byB0cmFuc2ZlciB0aGUgd3JhcHBlZCBORlRzIHRvLCBuaWwgaWYgdGhlIE5GVHMgc2hvdWxkIHN0YXkgaW4gc2lnbmVyJ3MgQ09BCi8vLwphY2Nlc3MoYWxsKSBmdW4gd3JhcEFuZFRyYW5zZmVyTkZUc0lmQXBwbGljYWJsZSgKICAgIF8gY29hOiBhdXRoKEVWTS5DYWxsKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQsCiAgICBuZnRJRHM6IFtVSW50NjRdLAogICAgbmZ0VHlwZTogVHlwZSwKICAgIHZpZXdSZXNvbHZlcjogJntWaWV3UmVzb2x2ZXJ9LAogICAgcmVjaXBpZW50SWZOb3RDb2E6IEVWTS5FVk1BZGRyZXNzPwopIHsKICAgIC8vIEdldCB0aGUgcHJvamVjdC1kZWZpbmVkIEVSQzcyMSBhZGRyZXNzIGlmIGl0IGV4aXN0cwogICAgaWYgbGV0IGNyb3NzVk1Qb2ludGVyID0gdmlld1Jlc29sdmVyLnJlc29sdmVDb250cmFjdFZpZXcoCiAgICAgICAgICAgIHJlc291cmNlVHlwZTogbmZ0VHlwZSwKICAgICAgICAgICAgdmlld1R5cGU6IFR5cGU8Q3Jvc3NWTU1ldGFkYXRhVmlld3MuRVZNUG9pbnRlcj4oKQogICAgKSBhcyEgQ3Jvc3NWTU1ldGFkYXRhVmlld3MuRVZNUG9pbnRlcj8gewogICAgICAgIC8vIEdldCB0aGUgdW5kZXJseWluZyBFUkM3MjEgYWRkcmVzcyBpZiBpdCBleGlzdHMKICAgICAgICBpZiBsZXQgdW5kZXJseWluZ0FkZHJlc3MgPSBnZXRVbmRlcmx5aW5nRVJDNzIxQWRkcmVzcyhjb2EsIGNyb3NzVk1Qb2ludGVyLmV2bUNvbnRyYWN0QWRkcmVzcykgewogICAgICAgICAgICAvLyBXcmFwIE5GVHMgaWYgdW5kZXJseWluZyBFUkM3MjEgYWRkcmVzcyBtYXRjaGVzIGJyaWRnZSdzIGFzc29jaWF0ZWQgYWRkcmVzcyBmb3IgTkZUIHR5cGUKICAgICAgICAgICAgaWYgdW5kZXJseWluZ0FkZHJlc3MuZXF1YWxzKEZsb3dFVk1CcmlkZ2VDb25maWcuZ2V0RVZNQWRkcmVzc0Fzc29jaWF0ZWQod2l0aDogbmZ0VHlwZSkhKSB7CiAgICAgICAgICAgICAgICAvLyBBcHByb3ZlIGNvbnRyYWN0IHRvIHdpdGhkcmF3IHVuZGVybHlpbmcgTkZUcyBmcm9tIHNpZ25lcidzIGNvYQogICAgICAgICAgICAgICAgbXVzdENhbGwoY29hLCB1bmRlcmx5aW5nQWRkcmVzcywKICAgICAgICAgICAgICAgICAgICBmdW5jdGlvblNpZzogInNldEFwcHJvdmFsRm9yQWxsKGFkZHJlc3MsYm9vbCkiLAogICAgICAgICAgICAgICAgICAgIGFyZ3M6IFtjcm9zc1ZNUG9pbnRlci5ldm1Db250cmFjdEFkZHJlc3MsIHRydWVdCiAgICAgICAgICAgICAgICApCgogICAgICAgICAgICAgICAgLy8gV3JhcCBORlRzIHdpdGggcHJvdmlkZWQgSURzLCBhbmQgY2hlY2sgaWYgdGhlIGNhbGwgd2FzIHN1Y2Nlc3NmdWwKICAgICAgICAgICAgICAgIGxldCByZXMgPSBtdXN0Q2FsbChjb2EsIGNyb3NzVk1Qb2ludGVyLmV2bUNvbnRyYWN0QWRkcmVzcywKICAgICAgICAgICAgICAgICAgICBmdW5jdGlvblNpZzogImRlcG9zaXRGb3IoYWRkcmVzcyx1aW50MjU2W10pIiwKICAgICAgICAgICAgICAgICAgICBhcmdzOiBbY29hLmFkZHJlc3MoKSwgbmZ0SURzXQogICAgICAgICAgICAgICAgKQogICAgICAgICAgICAgICAgbGV0IGRlY29kZWRSZXMgPSBFVk0uZGVjb2RlQUJJKHR5cGVzOiBbVHlwZTxCb29sPigpXSwgZGF0YTogcmVzLmRhdGEpCiAgICAgICAgICAgICAgICBhc3NlcnQoZGVjb2RlZFJlcy5sZW5ndGggPT0gMSwgbWVzc2FnZTogIkludmFsaWQgcmVzcG9uc2UgbGVuZ3RoIikKICAgICAgICAgICAgICAgIGFzc2VydChkZWNvZGVkUmVzWzBdIGFzISBCb29sLCBtZXNzYWdlOiAiRmFpbGVkIHRvIHdyYXAgTkZUcyIpCgogICAgICAgICAgICAgICAgLy8gVHJhbnNmZXIgTkZUcyB0byByZWNpcGllbnQgaWYgcHJvdmlkZWQKICAgICAgICAgICAgICAgIGlmIGxldCB0byA9IHJlY2lwaWVudElmTm90Q29hIHsKICAgICAgICAgICAgICAgICAgICBtdXN0VHJhbnNmZXJORlRzKGNvYSwgY3Jvc3NWTVBvaW50ZXIuZXZtQ29udHJhY3RBZGRyZXNzLCBuZnRJRHM6IG5mdElEcywgdG86IHRvKQogICAgICAgICAgICAgICAgfQoKICAgICAgICAgICAgICAgIC8vIFJldm9rZSBhcHByb3ZhbCBmb3IgY29udHJhY3QgdG8gd2l0aGRyYXcgdW5kZXJseWluZyBORlRzIGZyb20gc2lnbmVyJ3MgY29hCiAgICAgICAgICAgICAgICBtdXN0Q2FsbChjb2EsIHVuZGVybHlpbmdBZGRyZXNzLAogICAgICAgICAgICAgICAgICAgIGZ1bmN0aW9uU2lnOiAic2V0QXBwcm92YWxGb3JBbGwoYWRkcmVzcyxib29sKSIsCiAgICAgICAgICAgICAgICAgICAgYXJnczogW2Nyb3NzVk1Qb2ludGVyLmV2bUNvbnRyYWN0QWRkcmVzcywgZmFsc2VdCiAgICAgICAgICAgICAgICApCiAgICAgICAgICAgIH0KICAgICAgICB9CiAgICB9Cn0KCi8vLyBHZXRzIHRoZSB1bmRlcmx5aW5nIEVSQzcyMSBhZGRyZXNzIGlmIGl0IGV4aXN0cyAoaS5lLiBpZiB0aGUgRVJDNzIxIGlzIGEgd3JhcHBlcikKLy8vCmFjY2VzcyhhbGwpIGZ1biBnZXRVbmRlcmx5aW5nRVJDNzIxQWRkcmVzcygKICAgIF8gY29hOiBhdXRoKEVWTS5DYWxsKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQsCiAgICBfIHdyYXBwZXJBZGRyZXNzOiBFVk0uRVZNQWRkcmVzcwopOiBFVk0uRVZNQWRkcmVzcz8gewogICAgbGV0IHJlcyA9IGNvYS5jYWxsKAogICAgICAgIHRvOiB3cmFwcGVyQWRkcmVzcywKICAgICAgICBkYXRhOiBFVk0uZW5jb2RlQUJJV2l0aFNpZ25hdHVyZSgidW5kZXJseWluZygpIiwgW10pLAogICAgICAgIGdhc0xpbWl0OiAxMDBfMDAwLAogICAgICAgIHZhbHVlOiBFVk0uQmFsYW5jZShhdHRvZmxvdzogMCkKICAgICkKCiAgICAvLyBJZiB0aGUgY2FsbCBmYWlscywgcmV0dXJuIG5pbAogICAgaWYgcmVzLnN0YXR1cyAhPSBFVk0uU3RhdHVzLnN1Y2Nlc3NmdWwgfHwgcmVzLmRhdGEubGVuZ3RoID09IDAgewogICAgICAgIHJldHVybiBuaWwKICAgIH0KCiAgICAvLyBEZWNvZGUgYW5kIHJldHVybiB0aGUgdW5kZXJseWluZyBFUkM3MjEgYWRkcmVzcwogICAgbGV0IGRlY29kZWRSZXN1bHQgPSBFVk0uZGVjb2RlQUJJKAogICAgICAgIHR5cGVzOiBbVHlwZTxFVk0uRVZNQWRkcmVzcz4oKV0sCiAgICAgICAgZGF0YTogcmVzLmRhdGEKICAgICkKICAgIGFzc2VydChkZWNvZGVkUmVzdWx0Lmxlbmd0aCA9PSAxLCBtZXNzYWdlOiAiSW52YWxpZCByZXNwb25zZSBsZW5ndGgiKQogICAgcmV0dXJuIGRlY29kZWRSZXN1bHRbMF0gYXMhIEVWTS5FVk1BZGRyZXNzCn0KCi8vLyBDaGVja3MgaWYgdGhlIHByb3ZpZGVkIE5GVCBpcyBvd25lZCBieSB0aGUgcHJvdmlkZWQgRVZNIGFkZHJlc3MKLy8vCmFjY2VzcyhhbGwpIGZ1biBpc093bmVyKAogICAgXyBjb2E6IGF1dGgoRVZNLkNhbGwpICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudCwKICAgIF8gZXJjNzIxQWRkcmVzczogRVZNLkVWTUFkZHJlc3MsCiAgICBfIG5mdElEOiBVSW50NjQsCiAgICBfIG93bmVyVG9DaGVjazogRVZNLkVWTUFkZHJlc3MKKTogQm9vbCB7CiAgICBsZXQgcmVzID0gY29hLmNhbGwoCiAgICAgICAgdG86IGVyYzcyMUFkZHJlc3MsCiAgICAgICAgZGF0YTogRVZNLmVuY29kZUFCSVdpdGhTaWduYXR1cmUoIm93bmVyT2YodWludDI1NikiLCBbbmZ0SURdKSwKICAgICAgICBnYXNMaW1pdDogMTAwXzAwMCwKICAgICAgICB2YWx1ZTogRVZNLkJhbGFuY2UoYXR0b2Zsb3c6IDApCiAgICApCiAgICBhc3NlcnQocmVzLnN0YXR1cyA9PSBFVk0uU3RhdHVzLnN1Y2Nlc3NmdWwsIG1lc3NhZ2U6ICJDYWxsIHRvIEVSQzcyMS5vd25lck9mKHVpbnQyNTYpIGZhaWxlZCIpCiAgICBsZXQgZGVjb2RlZFJlcyA9IEVWTS5kZWNvZGVBQkkodHlwZXM6IFtUeXBlPEVWTS5FVk1BZGRyZXNzPigpXSwgZGF0YTogcmVzLmRhdGEpCiAgICBpZiBkZWNvZGVkUmVzLmxlbmd0aCA9PSAxIHsKICAgICAgICBsZXQgYWN0dWFsT3duZXIgPSBkZWNvZGVkUmVzWzBdIGFzISBFVk0uRVZNQWRkcmVzcwogICAgICAgIHJldHVybiBhY3R1YWxPd25lci5lcXVhbHMob3duZXJUb0NoZWNrKQogICAgfQogICAgcmV0dXJuIGZhbHNlCn0KCi8vLyBUcmFuc2ZlcnMgTkZUcyBmcm9tIHRoZSBwcm92aWRlZCBDT0EgdG8gdGhlIHByb3ZpZGVkIEVWTSBhZGRyZXNzCi8vLwphY2Nlc3MoYWxsKSBmdW4gbXVzdFRyYW5zZmVyTkZUcygKICAgIF8gY29hOiBhdXRoKEVWTS5DYWxsKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQsCiAgICBfIGVyYzcyMUFkZHJlc3M6IEVWTS5FVk1BZGRyZXNzLAogICAgbmZ0SURzOiBbVUludDY0XSwKICAgIHRvOiBFVk0uRVZNQWRkcmVzcwopIHsKICAgIGZvciBpZCBpbiBuZnRJRHMgewogICAgICAgIGFzc2VydChpc093bmVyKGNvYSwgZXJjNzIxQWRkcmVzcywgaWQsIGNvYS5hZGRyZXNzKCkpLCBtZXNzYWdlOiAiTkZUIG5vdCBvd25lZCBieSBzaWduZXIncyBDT0EiKQogICAgICAgIG11c3RDYWxsKGNvYSwgZXJjNzIxQWRkcmVzcywKICAgICAgICAgICAgZnVuY3Rpb25TaWc6ICJzYWZlVHJhbnNmZXJGcm9tKGFkZHJlc3MsYWRkcmVzcyx1aW50MjU2KSIsCiAgICAgICAgICAgIGFyZ3M6IFtjb2EuYWRkcmVzcygpLCB0bywgaWRdCiAgICAgICAgKQogICAgICAgIGFzc2VydChpc093bmVyKGNvYSwgZXJjNzIxQWRkcmVzcywgaWQsIHRvKSwgbWVzc2FnZTogIk5GVCBub3QgdHJhbnNmZXJyZWQgdG8gcmVjaXBpZW50IikKICAgIH0KfQoKLy8vIENhbGxzIGEgZnVuY3Rpb24gb24gYW4gRVZNIGNvbnRyYWN0IGZyb20gcHJvdmlkZWQgY29hCi8vLwphY2Nlc3MoYWxsKSBmdW4gbXVzdENhbGwoCiAgICBfIGNvYTogYXV0aChFVk0uQ2FsbCkgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50LAogICAgXyBjb250cmFjdEFkZHI6IEVWTS5FVk1BZGRyZXNzLAogICAgZnVuY3Rpb25TaWc6IFN0cmluZywKICAgIGFyZ3M6IFtBbnlTdHJ1Y3RdCik6IEVWTS5SZXN1bHQgewogICAgbGV0IHJlcyA9IGNvYS5jYWxsKAogICAgICAgIHRvOiBjb250cmFjdEFkZHIsCiAgICAgICAgZGF0YTogRVZNLmVuY29kZUFCSVdpdGhTaWduYXR1cmUoZnVuY3Rpb25TaWcsIGFyZ3MpLAogICAgICAgIGdhc0xpbWl0OiA0XzAwMF8wMDAsCiAgICAgICAgdmFsdWU6IEVWTS5CYWxhbmNlKGF0dG9mbG93OiAwKQogICAgKQoKICAgIGFzc2VydChyZXMuc3RhdHVzID09IEVWTS5TdGF0dXMuc3VjY2Vzc2Z1bCwKICAgICAgICBtZXNzYWdlOiAiRmFpbGVkIHRvIGNhbGwgJyIuY29uY2F0KGZ1bmN0aW9uU2lnKQogICAgICAgICAgICAuY29uY2F0KCJcblx0IGVycm9yIGNvZGU6ICIpLmNvbmNhdChyZXMuZXJyb3JDb2RlLnRvU3RyaW5nKCkpCiAgICAgICAgICAgIC5jb25jYXQoIlxuXHQgZXJyb3IgbWVzc2FnZTogIikuY29uY2F0KHJlcy5lcnJvck1lc3NhZ2UpCiAgICAgICAgICAgIC5jb25jYXQoIlxuXHQgZ2FzIHVzZWQ6ICIpLmNvbmNhdChyZXMuZ2FzVXNlZC50b1N0cmluZygpKQogICAgICAgICAgICAuY29uY2F0KCJcblx0IGNhbGxlciBhZGRyZXNzOiAweCIpLmNvbmNhdChjb2EuYWRkcmVzcygpLnRvU3RyaW5nKCkpCiAgICAgICAgICAgIC5jb25jYXQoIlxuXHQgY29udHJhY3QgYWRkcmVzczogMHgiKS5jb25jYXQoY29udHJhY3RBZGRyLnRvU3RyaW5nKCkpCiAgICApCgogICAgcmV0dXJuIHJlcwp9Cg\u003d\u003d", - "batchEvmAddressRequiresOnboarding": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYmF0Y2hFdm1BZGRyZXNzUmVxdWlyZXNPbmJvYXJkaW5nIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRVZNVXRpbHMgZnJvbSAweDFlNGFhMGI4N2QxMGIxNDEKCmltcG9ydCBGbG93RVZNQnJpZGdlIGZyb20gMHgxZTRhYTBiODdkMTBiMTQxCgoKLy8vIFJldHVybnMgd2hldGhlciBhIEVWTSBjb250cmFjdCBuZWVkcyB0byBiZSBvbmJvYXJkZWQgdG8gdGhlIEZsb3dFVk1CcmlkZ2UKLy8vCi8vLyBAcGFyYW0gZXZtQWRkcmVzc2VzOiBBcnJheSBvZiBoZXgtZW5jb2RlZCBhZGRyZXNzIG9mIHRoZSBFVk0gY29udHJhY3QgYXMgYSBTdHJpbmcgd2l0aG91dCAweCBwcmVmaXggdG8gY2hlY2sgZm9yCi8vLyAgICAgb25ib2FyZGluZyBzdGF0dXMKLy8vCi8vLyBAcmV0dXJuIFdoZXRoZXIgdGhlIGNvbnRyYWN0IHJlcXVpcmVzIG9uYm9hcmRpbmcgdG8gdGhlIEZsb3dFVk1CcmlkZ2UgaWYgdGhlIHR5cGUgaXMgYnJpZGdlYWJsZSwgb3RoZXJ3aXNlIG5pbAovLy8gICAgIGluZGV4ZWQgb24gdGhlIGhleC1lbmNvZGVkIGFkZHJlc3Mgb2YgdGhlIEVWTSBjb250cmFjdCB3aXRob3V0IDB4IHByZWZpeAovLy8KYWNjZXNzKGFsbCkgZnVuIG1haW4oZXZtQWRkcmVzc2VzOiBbU3RyaW5nXSk6IHtTdHJpbmc6IEJvb2w/fSB7CiAgICBsZXQgcmVzdWx0czoge1N0cmluZzogQm9vbD99ID0ge30KICAgIGZvciBhZGRyZXNzSGV4IGluIGV2bUFkZHJlc3NlcyB7CiAgICAgICAgaWYgcmVzdWx0c1thZGRyZXNzSGV4XSAhPSBuaWwgewogICAgICAgICAgICBjb250aW51ZQogICAgICAgIH0KICAgICAgICBpZiBsZXQgYWRkcmVzcyA9IEVWTVV0aWxzLmdldEVWTUFkZHJlc3NGcm9tSGV4U3RyaW5nKGFkZHJlc3M6IGFkZHJlc3NIZXgpIHsKICAgICAgICAgICAgbGV0IHJlcXVpcmVzT25ib2FyZGluZyA9IEZsb3dFVk1CcmlkZ2UuZXZtQWRkcmVzc1JlcXVpcmVzT25ib2FyZGluZyhhZGRyZXNzKQogICAgICAgICAgICByZXN1bHRzLmluc2VydChrZXk6IGFkZHJlc3NIZXgsIHJlcXVpcmVzT25ib2FyZGluZykKICAgICAgICB9CiAgICB9CiAgICByZXR1cm4gcmVzdWx0cwp9Cg\u003d\u003d", - "batchIdentifierRequiresOnboarding": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYmF0Y2hJZGVudGlmaWVyUmVxdWlyZXNPbmJvYXJkaW5nIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd0VWTUJyaWRnZSBmcm9tIDB4MWU0YWEwYjg3ZDEwYjE0MQoKCi8vLyBSZXR1cm5zIHdoZXRoZXIgYSB0eXBlIG5lZWRzIHRvIGJlIG9uYm9hcmRlZCB0byB0aGUgRmxvd0VWTUJyaWRnZQovLy8KLy8vIEBwYXJhbSBUeXBlczogVGhlIGFycmF5IG9mIHR5cGVzIHRvIGNoZWNrIGZvciBvbmJvYXJkaW5nIHN0YXR1cwovLy8KLy8vIEByZXR1cm4gV2hldGhlciB0aGUgdHlwZSByZXF1aXJlcyBvbmJvYXJkaW5nIHRvIHRoZSBGbG93RVZNQnJpZGdlIGlmIHRoZSB0eXBlIGlzIGJyaWRnZWFibGUsIG90aGVyd2lzZSBuaWwgaW5kZXhlZAovLy8gICAgIG9uIHRoZSB0eXBlCi8vLwphY2Nlc3MoYWxsKSBmdW4gbWFpbihpZGVudGlmaWVyczogW1N0cmluZ10pOiB7U3RyaW5nOiBCb29sP30gewogICAgbGV0IHJlc3VsdHM6IHtTdHJpbmc6IEJvb2w/fSA9IHt9CgogICAgZm9yIGlkZW50aWZpZXIgaW4gaWRlbnRpZmllcnMgewogICAgICAgIGlmIHJlc3VsdHNbaWRlbnRpZmllcl0gIT0gbmlsIHsKICAgICAgICAgICAgY29udGludWUKICAgICAgICB9CiAgICAgICAgbGV0IHR5cGU6IFR5cGUgPSBDb21wb3NpdGVUeXBlKGlkZW50aWZpZXIpID8/IHBhbmljKCJJbnZhbGlkIHR5cGUgaWRlbnRpZmllciIpCiAgICAgICAgcmVzdWx0cy5pbnNlcnQoa2V5OiBpZGVudGlmaWVyLCBGbG93RVZNQnJpZGdlLnR5cGVSZXF1aXJlc09uYm9hcmRpbmcodHlwZSkpCiAgICB9CiAgICByZXR1cm4gcmVzdWx0cwp9Cg\u003d\u003d", - "batchOnboardByEvmAddress": "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\u003d", - "batchOnboardByIdentifier": "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\u003d", - "batchOnboardByType": "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\u003d\u003d", - "batchTypeRequiresOnboarding": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYmF0Y2hUeXBlUmVxdWlyZXNPbmJvYXJkaW5nIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd0VWTUJyaWRnZSBmcm9tIDB4MWU0YWEwYjg3ZDEwYjE0MQoKCi8vLyBSZXR1cm5zIHdoZXRoZXIgYSB0eXBlIG5lZWRzIHRvIGJlIG9uYm9hcmRlZCB0byB0aGUgRmxvd0VWTUJyaWRnZQovLy8KLy8vIEBwYXJhbSBUeXBlczogVGhlIGFycmF5IG9mIHR5cGVzIHRvIGNoZWNrIGZvciBvbmJvYXJkaW5nIHN0YXR1cwovLy8KLy8vIEByZXR1cm4gV2hldGhlciB0aGUgdHlwZSByZXF1aXJlcyBvbmJvYXJkaW5nIHRvIHRoZSBGbG93RVZNQnJpZGdlIGlmIHRoZSB0eXBlIGlzIGJyaWRnZWFibGUsIG90aGVyd2lzZSBuaWwgaW5kZXhlZAovLy8gICAgIG9uIHRoZSB0eXBlCi8vLwphY2Nlc3MoYWxsKSBmdW4gbWFpbih0eXBlczogW1R5cGVdKToge1R5cGU6IEJvb2w/fSB7CiAgICBsZXQgcmVzdWx0czoge1R5cGU6IEJvb2w/fSA9IHt9CiAgICBmb3IgdHlwZSBpbiB0eXBlcyB7CiAgICAgICAgaWYgcmVzdWx0c1t0eXBlXSAhPSBuaWwgewogICAgICAgICAgICBjb250aW51ZQogICAgICAgIH0KICAgICAgICByZXN1bHRzLmluc2VydChrZXk6IHR5cGUsIEZsb3dFVk1CcmlkZ2UudHlwZVJlcXVpcmVzT25ib2FyZGluZyh0eXBlKSkKICAgIH0KICAgIHJldHVybiByZXN1bHRzCn0K", - "bridgeNFTFromEvm": "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\u003d", - "bridgeNFTFromEvmToFlow": "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\u003d", - "bridgeNFTFromEvmToFlowV2": "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\u003d", - "bridgeNFTFromEvmToFlowV3": "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\u003d\u003d", - "bridgeNFTFromEvmToFlowWithPayer": "// Flow Wallet - mainnet Script  bridgeNFTFromEvmToFlowWithPayer - v2.72
// <platform_info>

import MetadataViews from 0x1d7e57aa55817448

import ViewResolver from 0x1d7e57aa55817448

import NonFungibleToken from 0x1d7e57aa55817448

import FungibleToken from 0xf233dcee88fe0abe

import FlowToken from 0x1654653399040a61

import FungibleTokenMetadataViews from 0xf233dcee88fe0abe

import ScopedFTProviders from 0x1e4aa0b87d10b141

import EVM from 0xe467b9dd11fa00df

import FlowEVMBridgeUtils from 0x1e4aa0b87d10b141

import FlowEVMBridge from 0x1e4aa0b87d10b141

import FlowEVMBridgeConfig from 0x1e4aa0b87d10b141

import StorageRent from 0x707adbad1428c624

import CrossVMMetadataViews from 0x1d7e57aa55817448


/// This transaction bridges an NFT from EVM to Cadence assuming it has already been onboarded to the FlowEVMBridge.
/// Also know that the recipient Flow account must have a Receiver capable of receiving the this bridged NFT accessible
/// via published Capability at the token's standard path.
/// NOTE: The ERC721 must have first been onboarded to the bridge. This can be checked via the method
///     FlowEVMBridge.evmAddressRequiresOnboarding(address: self.evmContractAddress)
///
/// @param nftIdentifier: The Cadence type identifier of the NFT to bridge - e.g. nft.getType().identifier
/// @param id: The ERC721 id of the NFT to bridge to Cadence from EVM
/// @param recipient: The Flow account address to receive the bridged NFT
///
transaction(nftIdentifier: String, id: UInt256, recipient: Address) {
    let nftType: Type
    let receiver: &{NonFungibleToken.Receiver}
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let coa: auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount
    let viewResolver: &{ViewResolver}

    prepare(signer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account, payer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        /* --- Construct the NFT type --- */
        //
        // Construct the NFT type from the provided identifier
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        // Parse the NFT identifier into its components
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: self.nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Reference the recipient's NFT Receiver --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: self.nftType,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        // Configure the signer's account for this NFT
        if signer.storage.borrow<&{NonFungibleToken.Collection}>(from: collectionData.storagePath) == nil {
            signer.storage.save(<-collectionData.createEmptyCollection(), to: collectionData.storagePath)
            signer.capabilities.unpublish(collectionData.publicPath)
            let collectionCap = signer.capabilities.storage.issue<&{NonFungibleToken.Collection}>(collectionData.storagePath)
            signer.capabilities.publish(collectionCap, at: collectionData.publicPath)
        }
        self.receiver = getAccount(recipient).capabilities.borrow<&{NonFungibleToken.Receiver}>(collectionData.publicPath)
            ?? panic("Could not borrow Receiver from recipient's public capability path")

        /* --- Configure a ScopedFTProvider --- */
        //
        // Calculate the bridge fee - bridging from EVM consumes no storage, so flat fee
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000)
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if payer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = payer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            payer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = payer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    execute {
        // Unwrap NFTs from project-defined ERC721 wrapper contract if applicable
        unwrapNFTsIfApplicable(self.coa, nftIDs: [id], nftType: self.nftType, viewResolver: self.viewResolver)

        // Execute the bridge
        let nft: @{NonFungibleToken.NFT} <- self.coa.withdrawNFT(
            type: self.nftType,
            id: id,
            feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        // Ensure the bridged nft is the correct type
        assert(
            nft.getType() == self.nftType,
            message: "Bridged nft type mismatch - requeswted: ".concat(self.nftType.identifier)
                .concat(", received: ").concat(nft.getType().identifier)
        )
        // Deposit the bridged NFT into the signer's collection
        self.receiver.deposit(token: <-nft)
        // Destroy the ScopedFTProvider
        destroy self.scopedProvider
        StorageRent.tryRefill(recipient)

    }
}

/// Unwraps NFTs from a project's custom ERC721 wrapper contract to bridged NFTs on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
///
access(all) fun unwrapNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt256],
    nftType: Type,
    viewResolver: &{ViewResolver}
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            for id in nftIDs {
                // Unwrap NFT if it is wrapped
                if isNFTWrapped(coa,
                    nftID: id,
                    underlying: underlyingAddress,
                    wrapper: crossVMPointer.evmContractAddress
                ) {
                    let res = mustCall(coa, crossVMPointer.evmContractAddress,
                        functionSig: "withdrawTo(address,uint256[])",
                        args: [coa.address(), [id]]
                    )
                    let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                    assert(decodedRes.length == 1, message: "Invalid response length")
                    assert(decodedRes[0] as! Bool, message: "Failed to unwrap NFT")
                }
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is wrapped in the underlying ERC721 contract
///
access(all) fun isNFTWrapped(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftID: UInt256,
    underlying: EVM.EVMAddress,
    wrapper: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: underlying,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return false
    if res.status != EVM.Status.successful || res.data.length == 0{
        return false
    }

    // Decode and compare the addresses
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")

    let owner = decodedResult[0] as! EVM.EVMAddress
    return owner.toString() == wrapper.toString()
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", - "bridgeNFTFromEvmV2": "// Flow Wallet - mainnet Script  bridgeNFTFromEvmV2 - v2.72
// <platform_info>

import MetadataViews from 0x1d7e57aa55817448

import ViewResolver from 0x1d7e57aa55817448

import NonFungibleToken from 0x1d7e57aa55817448

import FungibleToken from 0xf233dcee88fe0abe

import FlowToken from 0x1654653399040a61

import FungibleTokenMetadataViews from 0xf233dcee88fe0abe

import ScopedFTProviders from 0x1e4aa0b87d10b141

import EVM from 0xe467b9dd11fa00df

import FlowEVMBridgeUtils from 0x1e4aa0b87d10b141

import FlowEVMBridge from 0x1e4aa0b87d10b141

import FlowEVMBridgeConfig from 0x1e4aa0b87d10b141

import CrossVMMetadataViews from 0x1d7e57aa55817448


/// This transaction bridges an NFT from EVM to Cadence assuming it has already been onboarded to the FlowEVMBridge
/// NOTE: The ERC721 must have first been onboarded to the bridge. This can be checked via the method
///     FlowEVMBridge.evmAddressRequiresOnboarding(address: self.evmContractAddress)
///
/// @param nftIdentifier: The Cadence type identifier of the NFT to bridge - e.g. nft.getType().identifier
/// @param id: The ERC721 id of the NFT to bridge to Cadence from EVM
///
transaction(nftIdentifier: String, id: UInt256) {

    let nftType: Type
    let collection: &{NonFungibleToken.Collection}
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let coa: auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount
    let viewResolver: &{ViewResolver}

    prepare(signer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        /* --- Construct the NFT type --- */
        //
        // Construct the NFT type from the provided identifier
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        // Parse the NFT identifier into its components
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: self.nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Reference the signer's NFT Collection --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: self.nftType,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        if signer.storage.borrow<&{NonFungibleToken.Collection}>(from: collectionData.storagePath) == nil {
            signer.storage.save(<-collectionData.createEmptyCollection(), to: collectionData.storagePath)
            signer.capabilities.unpublish(collectionData.publicPath)
            let collectionCap = signer.capabilities.storage.issue<&{NonFungibleToken.Collection}>(collectionData.storagePath)
            signer.capabilities.publish(collectionCap, at: collectionData.publicPath)
        }
        self.collection = signer.storage.borrow<&{NonFungibleToken.Collection}>(from: collectionData.storagePath)
            ?? panic("Could not borrow collection from storage path")

        /* --- Configure a ScopedFTProvider --- */
        //
        // Calculate the bridge fee - bridging from EVM consumes no storage, so flat fee
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000)
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    execute {
        // Unwrap NFTs from project-defined ERC721 wrapper contract if applicable
        unwrapNFTsIfApplicable(self.coa, nftIDs: [id], nftType: self.nftType, viewResolver: self.viewResolver)

        // Execute the bridge
        let nft: @{NonFungibleToken.NFT} <- self.coa.withdrawNFT(
            type: self.nftType,
            id: id,
            feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        // Ensure the bridged nft is the correct type
        assert(
            nft.getType() == self.nftType,
            message: "Bridged nft type mismatch - requeswted: ".concat(self.nftType.identifier)
                .concat(", received: ").concat(nft.getType().identifier)
        )
        // Deposit the bridged NFT into the signer's collection
        self.collection.deposit(token: <-nft)
        // Destroy the ScopedFTProvider
        destroy self.scopedProvider
    }
}

/// Unwraps NFTs from a project's custom ERC721 wrapper contract to bridged NFTs on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
///
access(all) fun unwrapNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt256],
    nftType: Type,
    viewResolver: &{ViewResolver}
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            for id in nftIDs {
                // Unwrap NFT if it is wrapped
                if isNFTWrapped(coa,
                    nftID: id,
                    underlying: underlyingAddress,
                    wrapper: crossVMPointer.evmContractAddress
                ) {
                    let res = mustCall(coa, crossVMPointer.evmContractAddress,
                        functionSig: "withdrawTo(address,uint256[])",
                        args: [coa.address(), [id]]
                    )
                    let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                    assert(decodedRes.length == 1, message: "Invalid response length")
                    assert(decodedRes[0] as! Bool, message: "Failed to unwrap NFT")
                }
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is wrapped in the underlying ERC721 contract
///
access(all) fun isNFTWrapped(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftID: UInt256,
    underlying: EVM.EVMAddress,
    wrapper: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: underlying,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return false
    if res.status != EVM.Status.successful || res.data.length == 0{
        return false
    }

    // Decode and compare the addresses
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    let owner = decodedResult[0] as! EVM.EVMAddress
    return owner.toString() == wrapper.toString()
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", - "bridgeNFTFromEvmWithPayer": "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\u003d", - "bridgeNFTToEvm": "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\u003d", - "bridgeNFTToEvmAddress": "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\u003d", - "bridgeNFTToEvmAddressV2": "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\u003d", - "bridgeNFTToEvmAddressWithPayer": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYnJpZGdlTkZUVG9Fdm1BZGRyZXNzV2l0aFBheWVyIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTWV0YWRhdGFWaWV3cyBmcm9tIDB4MWQ3ZTU3YWE1NTgxNzQ0OAoKaW1wb3J0IFZpZXdSZXNvbHZlciBmcm9tIDB4MWQ3ZTU3YWE1NTgxNzQ0OAoKaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHgxNjU0NjUzMzk5MDQwYTYxCgppbXBvcnQgRnVuZ2libGVUb2tlbk1ldGFkYXRhVmlld3MgZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKCmltcG9ydCBTY29wZWRGVFByb3ZpZGVycyBmcm9tIDB4MWU0YWEwYjg3ZDEwYjE0MQoKaW1wb3J0IEVWTSBmcm9tIDB4ZTQ2N2I5ZGQxMWZhMDBkZgoKaW1wb3J0IEZsb3dFVk1CcmlkZ2VVdGlscyBmcm9tIDB4MWU0YWEwYjg3ZDEwYjE0MQoKaW1wb3J0IEZsb3dFVk1CcmlkZ2UgZnJvbSAweDFlNGFhMGI4N2QxMGIxNDEKCmltcG9ydCBGbG93RVZNQnJpZGdlQ29uZmlnIGZyb20gMHgxZTRhYTBiODdkMTBiMTQxCgppbXBvcnQgQ3Jvc3NWTU1ldGFkYXRhVmlld3MgZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCgovLy8gQnJpZGdlcyBhbiBORlQgZnJvbSB0aGUgc2lnbmVyJ3MgY29sbGVjdGlvbiBpbiBDYWRlbmNlIHRvIHRoZSBuYW1lZCByZWNpcGllbnQgaW4gRVZNLgovLy8KLy8vIE5PVEU6IFRoaXMgdHJhbnNhY3Rpb24gYWxzbyBvbmJvYXJkcyB0aGUgTkZUIHRvIHRoZSBicmlkZ2UgaWYgbmVjZXNzYXJ5IHdoaWNoIG1heSBpbmN1ciBhZGRpdGlvbmFsIGZlZXMKLy8vICAgICB0aGFuIGJyaWRnaW5nIGFuIGFzc2V0IHRoYXQgaGFzIGFscmVhZHkgYmVlbiBvbmJvYXJkZWQuCi8vLwovLy8gQHBhcmFtIG5mdElkZW50aWZpZXI6IFRoZSBDYWRlbmNlIHR5cGUgaWRlbnRpZmllciBvZiB0aGUgTkZUIHRvIGJyaWRnZSAtIGUuZy4gbmZ0LmdldFR5cGUoKS5pZGVudGlmaWVyCi8vLyBAcGFyYW0gaWQ6IFRoZSBDYWRlbmNlIE5GVC5pZCBvZiB0aGUgTkZUIHRvIGJyaWRnZSB0byBFVk0KLy8vIEBwYXJhbSByZWNpcGllbnQ6IFRoZSBoZXgtZW5jb2RlZCBFVk0gYWRkcmVzcyB0byByZWNlaXZlIHRoZSBORlQKLy8vCnRyYW5zYWN0aW9uKG5mdElkZW50aWZpZXI6IFN0cmluZywgaWQ6IFVJbnQ2NCwgcmVjaXBpZW50OiBTdHJpbmcpIHsKICAgIGxldCBuZnQ6IEB7Tm9uRnVuZ2libGVUb2tlbi5ORlR9CiAgICBsZXQgcmVxdWlyZXNPbmJvYXJkaW5nOiBCb29sCiAgICBsZXQgc2NvcGVkUHJvdmlkZXI6IEBTY29wZWRGVFByb3ZpZGVycy5TY29wZWRGVFByb3ZpZGVyCiAgICBsZXQgY29hOiBhdXRoKEVWTS5DYWxsKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQKICAgIGxldCBuZnRUeXBlOiBUeXBlCiAgICBsZXQgdmlld1Jlc29sdmVyOiAme1ZpZXdSZXNvbHZlcn0KCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChDb3B5VmFsdWUsIEJvcnJvd1ZhbHVlLCBJc3N1ZVN0b3JhZ2VDYXBhYmlsaXR5Q29udHJvbGxlciwgUHVibGlzaENhcGFiaWxpdHksIFNhdmVWYWx1ZSkgJkFjY291bnQsIHBheWVyOiBhdXRoKENvcHlWYWx1ZSwgQm9ycm93VmFsdWUsIElzc3VlU3RvcmFnZUNhcGFiaWxpdHlDb250cm9sbGVyLCBQdWJsaXNoQ2FwYWJpbGl0eSwgU2F2ZVZhbHVlKSAmQWNjb3VudCkgewogICAgICAgIC8vIFJldHJpZXZlIG9yIGNyZWF0ZSBDT0EKICAgICAgICBpZiBsZXQgY29hID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoRVZNLkNhbGwpICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oZnJvbTogL3N0b3JhZ2UvZXZtKSB7CiAgICAgICAgICAgIHNlbGYuY29hID0gY29hCiAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgc2lnbmVyLnN0b3JhZ2Uuc2F2ZTxARVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KDwtIEVWTS5jcmVhdGVDYWRlbmNlT3duZWRBY2NvdW50KCksIHRvOiAvc3RvcmFnZS9ldm0pCiAgICAgICAgICAgIHNpZ25lci5jYXBhYmlsaXRpZXMucHVibGlzaCgKICAgICAgICAgICAgICAgIHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTwmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KC9zdG9yYWdlL2V2bSksCiAgICAgICAgICAgICAgICBhdDogL3B1YmxpYy9ldm0KICAgICAgICAgICAgKQogICAgICAgICAgICBzZWxmLmNvYSA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEVWTS5DYWxsKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KGZyb206IC9zdG9yYWdlL2V2bSkhCiAgICAgICAgfQoKICAgICAgICAvKiAtLS0gQ29uc3RydWN0IHRoZSBORlQgdHlwZSAtLS0gKi8KICAgICAgICAvLwogICAgICAgIC8vIENvbnN0cnVjdCB0aGUgTkZUIHR5cGUgZnJvbSB0aGUgcHJvdmlkZWQgaWRlbnRpZmllcgogICAgICAgIHNlbGYubmZ0VHlwZSA9IENvbXBvc2l0ZVR5cGUobmZ0SWRlbnRpZmllcikKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBjb25zdHJ1Y3QgTkZUIHR5cGUgZnJvbSBpZGVudGlmaWVyOiAiLmNvbmNhdChuZnRJZGVudGlmaWVyKSkKICAgICAgICAvLyBQYXJzZSB0aGUgTkZUIGlkZW50aWZpZXIgaW50byBpdHMgY29tcG9uZW50cwogICAgICAgIGxldCBuZnRDb250cmFjdEFkZHJlc3MgPSBGbG93RVZNQnJpZGdlVXRpbHMuZ2V0Q29udHJhY3RBZGRyZXNzKGZyb21UeXBlOiBzZWxmLm5mdFR5cGUpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgZ2V0IGNvbnRyYWN0IGFkZHJlc3MgZnJvbSBpZGVudGlmaWVyOiAiLmNvbmNhdChuZnRJZGVudGlmaWVyKSkKICAgICAgICBsZXQgbmZ0Q29udHJhY3ROYW1lID0gRmxvd0VWTUJyaWRnZVV0aWxzLmdldENvbnRyYWN0TmFtZShmcm9tVHlwZTogc2VsZi5uZnRUeXBlKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGdldCBjb250cmFjdCBuYW1lIGZyb20gaWRlbnRpZmllcjogIi5jb25jYXQobmZ0SWRlbnRpZmllcikpCgogICAgICAgIC8qIC0tLSBSZXRyaWV2ZSB0aGUgTkZUIC0tLSAqLwogICAgICAgIC8vCiAgICAgICAgLy8gQm9ycm93IGEgcmVmZXJlbmNlIHRvIHRoZSBORlQgY29sbGVjdGlvbiwgY29uZmlndXJpbmcgaWYgbmVjZXNzYXJ5CiAgICAgICAgc2VsZi52aWV3UmVzb2x2ZXIgPSBnZXRBY2NvdW50KG5mdENvbnRyYWN0QWRkcmVzcykuY29udHJhY3RzLmJvcnJvdzwme1ZpZXdSZXNvbHZlcn0+KG5hbWU6IG5mdENvbnRyYWN0TmFtZSkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgVmlld1Jlc29sdmVyIGZyb20gTkZUIGNvbnRyYWN0IikKICAgICAgICBsZXQgY29sbGVjdGlvbkRhdGEgPSBzZWxmLnZpZXdSZXNvbHZlci5yZXNvbHZlQ29udHJhY3RWaWV3KAogICAgICAgICAgICAgICAgcmVzb3VyY2VUeXBlOiBuaWwsCiAgICAgICAgICAgICAgICB2aWV3VHlwZTogVHlwZTxNZXRhZGF0YVZpZXdzLk5GVENvbGxlY3Rpb25EYXRhPigpCiAgICAgICAgICAgICkgYXMhIE1ldGFkYXRhVmlld3MuTkZUQ29sbGVjdGlvbkRhdGE/ID8/IHBhbmljKCJDb3VsZCBub3QgcmVzb2x2ZSBORlRDb2xsZWN0aW9uRGF0YSB2aWV3IikKICAgICAgICBsZXQgY29sbGVjdGlvbiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKE5vbkZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7Tm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9ufT4oCiAgICAgICAgICAgICAgICBmcm9tOiBjb2xsZWN0aW9uRGF0YS5zdG9yYWdlUGF0aAogICAgICAgICAgICApID8/IHBhbmljKCJDb3VsZCBub3QgYWNjZXNzIHNpZ25lcidzIE5GVCBDb2xsZWN0aW9uIikKCiAgICAgICAgLy8gV2l0aGRyYXcgdGhlIHJlcXVlc3RlZCBORlQgJiBjYWxjdWxhdGUgdGhlIGFwcHJveGltYXRlIGJyaWRnZSBmZWUgYmFzZWQgb24gTkZUIHN0b3JhZ2UgdXNhZ2UKICAgICAgICBsZXQgY3VycmVudFN0b3JhZ2VVc2FnZSA9IHNpZ25lci5zdG9yYWdlLnVzZWQKICAgICAgICBzZWxmLm5mdCA8LSBjb2xsZWN0aW9uLndpdGhkcmF3KHdpdGhkcmF3SUQ6IGlkKQogICAgICAgIGxldCB3aXRoZHJhd25TdG9yYWdlVXNhZ2UgPSBzaWduZXIuc3RvcmFnZS51c2VkCiAgICAgICAgdmFyIGFwcHJveEZlZSA9IEZsb3dFVk1CcmlkZ2VVdGlscy5jYWxjdWxhdGVCcmlkZ2VGZWUoYnl0ZXM6IDQwMF8wMDApICsgRmxvd0VWTUJyaWRnZUNvbmZpZy5iYXNlRmVlCiAgICAgICAgLy8gRGV0ZXJtaW5lIGlmIHRoZSBORlQgcmVxdWlyZXMgb25ib2FyZGluZyAtIHRoaXMgaW1wYWN0cyB0aGUgZmVlIHJlcXVpcmVkCiAgICAgICAgc2VsZi5yZXF1aXJlc09uYm9hcmRpbmcgPSBGbG93RVZNQnJpZGdlLnR5cGVSZXF1aXJlc09uYm9hcmRpbmcoc2VsZi5uZnQuZ2V0VHlwZSgpKQogICAgICAgICAgICA/PyBwYW5pYygiQnJpZGdlIGRvZXMgbm90IHN1cHBvcnQgdGhpcyBhc3NldCB0eXBlIikKICAgICAgICBpZiBzZWxmLnJlcXVpcmVzT25ib2FyZGluZyB7CiAgICAgICAgICAgIGFwcHJveEZlZSA9IGFwcHJveEZlZSArIEZsb3dFVk1CcmlkZ2VDb25maWcub25ib2FyZEZlZQogICAgICAgIH0KCiAgICAgICAgLyogLS0tIENvbmZpZ3VyZSBhIFNjb3BlZEZUUHJvdmlkZXIgLS0tICovCiAgICAgICAgLy8KICAgICAgICAvLyBJc3N1ZSBhbmQgc3RvcmUgYnJpZGdlLWRlZGljYXRlZCBQcm92aWRlciBDYXBhYmlsaXR5IGluIHN0b3JhZ2UgaWYgbmVjZXNzYXJ5CiAgICAgICAgaWYgcGF5ZXIuc3RvcmFnZS50eXBlKGF0OiBGbG93RVZNQnJpZGdlQ29uZmlnLnByb3ZpZGVyQ2FwYWJpbGl0eVN0b3JhZ2VQYXRoKSA9PSBuaWwgewogICAgICAgICAgICBsZXQgcHJvdmlkZXJDYXAgPSBwYXllci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+KAogICAgICAgICAgICAgICAgL3N0b3JhZ2UvZmxvd1Rva2VuVmF1bHQKICAgICAgICAgICAgKQogICAgICAgICAgICBwYXllci5zdG9yYWdlLnNhdmUocHJvdmlkZXJDYXAsIHRvOiBGbG93RVZNQnJpZGdlQ29uZmlnLnByb3ZpZGVyQ2FwYWJpbGl0eVN0b3JhZ2VQYXRoKQogICAgICAgIH0KICAgICAgICAvLyBDb3B5IHRoZSBzdG9yZWQgUHJvdmlkZXIgY2FwYWJpbGl0eSBhbmQgY3JlYXRlIGEgU2NvcGVkRlRQcm92aWRlcgogICAgICAgIGxldCBwcm92aWRlckNhcENvcHkgPSBwYXllci5zdG9yYWdlLmNvcHk8Q2FwYWJpbGl0eTxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+PigKICAgICAgICAgICAgICAgIGZyb206IEZsb3dFVk1CcmlkZ2VDb25maWcucHJvdmlkZXJDYXBhYmlsaXR5U3RvcmFnZVBhdGgKICAgICAgICAgICAgKSA/PyBwYW5pYygiSW52YWxpZCBQcm92aWRlciBDYXBhYmlsaXR5IGZvdW5kIGluIHN0b3JhZ2UuIikKICAgICAgICBsZXQgcHJvdmlkZXJGaWx0ZXIgPSBTY29wZWRGVFByb3ZpZGVycy5BbGxvd2FuY2VGaWx0ZXIoYXBwcm94RmVlKQogICAgICAgIHNlbGYuc2NvcGVkUHJvdmlkZXIgPC0gU2NvcGVkRlRQcm92aWRlcnMuY3JlYXRlU2NvcGVkRlRQcm92aWRlcigKICAgICAgICAgICAgICAgIHByb3ZpZGVyOiBwcm92aWRlckNhcENvcHksCiAgICAgICAgICAgICAgICBmaWx0ZXJzOiBbIHByb3ZpZGVyRmlsdGVyIF0sCiAgICAgICAgICAgICAgICBleHBpcmF0aW9uOiBnZXRDdXJyZW50QmxvY2soKS50aW1lc3RhbXAgKyAxLjAKICAgICAgICAgICAgKQogICAgfQoKICAgIHByZSB7CiAgICAgICAgc2VsZi5uZnQuZ2V0VHlwZSgpLmlkZW50aWZpZXIgPT0gbmZ0SWRlbnRpZmllcjoKICAgICAgICAgICAgIkF0dGVtcHRpbmcgdG8gc2VuZCBpbnZhbGlkIG5mdCB0eXBlIC0gcmVxdWVzdGVkOiAiLmNvbmNhdChuZnRJZGVudGlmaWVyKQogICAgICAgICAgICAuY29uY2F0KCIsIHNlbmRpbmc6ICIpLmNvbmNhdChzZWxmLm5mdC5nZXRUeXBlKCkuaWRlbnRpZmllcikKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBpZiBzZWxmLnJlcXVpcmVzT25ib2FyZGluZyB7CiAgICAgICAgICAgIC8vIE9uYm9hcmQgdGhlIE5GVCB0byB0aGUgYnJpZGdlCiAgICAgICAgICAgIEZsb3dFVk1CcmlkZ2Uub25ib2FyZEJ5VHlwZSgKICAgICAgICAgICAgICAgIHNlbGYubmZ0LmdldFR5cGUoKSwKICAgICAgICAgICAgICAgIGZlZVByb3ZpZGVyOiAmc2VsZi5zY29wZWRQcm92aWRlciBhcyBhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0KICAgICAgICAgICAgKQogICAgICAgIH0KCiAgICAgICAgLy8gRXhlY3V0ZSB0aGUgYnJpZGdlIHRyYW5zYWN0aW9uCiAgICAgICAgc2VsZi5jb2EuZGVwb3NpdE5GVCgKICAgICAgICAgICAgbmZ0OiA8LXNlbGYubmZ0LAogICAgICAgICAgICBmZWVQcm92aWRlcjogJnNlbGYuc2NvcGVkUHJvdmlkZXIgYXMgYXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAme0Z1bmdpYmxlVG9rZW4uUHJvdmlkZXJ9CiAgICAgICAgKQoKICAgICAgICAvLyBEZXN0cm95IHRoZSBTY29wZWRGVFByb3ZpZGVyCiAgICAgICAgZGVzdHJveSBzZWxmLnNjb3BlZFByb3ZpZGVyCgogICAgICAgIC8vIFdyYXAgTkZUcyBpZiBhcHBsaWNhYmxlCiAgICAgICAgd3JhcEFuZFRyYW5zZmVyTkZUc0lmQXBwbGljYWJsZShzZWxmLmNvYSwKICAgICAgICAgICAgbmZ0SURzOiBbaWRdLAogICAgICAgICAgICBuZnRUeXBlOiBzZWxmLm5mdFR5cGUsCiAgICAgICAgICAgIHZpZXdSZXNvbHZlcjogc2VsZi52aWV3UmVzb2x2ZXIsCiAgICAgICAgICAgIHJlY2lwaWVudElmTm90Q29hOiBFVk0uYWRkcmVzc0Zyb21TdHJpbmcocmVjaXBpZW50KQogICAgICAgICkKICAgIH0KfQoKLy8vIFdyYXBzIGFuZCB0cmFuc2ZlcnMgYnJpZGdlZCBORlRzIGludG8gYSBwcm9qZWN0J3MgY3VzdG9tIEVSQzcyMSB3cmFwcGVyIGNvbnRyYWN0IG9uIEVWTSwgaWYgYXBwbGljYWJsZS4KLy8vIEVuYWJsZXMgcHJvamVjdHMgdG8gdXNlIHRoZWlyIG93biBFUkM3MjEgY29udHJhY3Qgd2hpbGUgbGV2ZXJhZ2luZyB0aGUgYnJpZGdlJ3MgdW5kZXJseWluZyBjb250cmFjdCwKLy8vIHVudGlsIGRpcmVjdCBjdXN0b20gY29udHJhY3Qgc3VwcG9ydCBpcyBhZGRlZCB0byB0aGUgYnJpZGdlLgovLy8KLy8vIEBwYXJhbSBjb2E6IFRoZSBDT0Egb2YgdGhlIHNpZ25lcgovLy8gQHBhcmFtIG5mdElEczogVGhlIElEcyBvZiB0aGUgTkZUcyB0byB3cmFwCi8vLyBAcGFyYW0gbmZ0VHlwZTogVGhlIHR5cGUgb2YgdGhlIE5GVHMgdG8gd3JhcAovLy8gQHBhcmFtIHZpZXdSZXNvbHZlcjogVGhlIFZpZXdSZXNvbHZlciBvZiB0aGUgTkZUIGNvbnRyYWN0Ci8vLyBAcGFyYW0gcmVjaXBpZW50SWZOb3RDb2E6IFRoZSBFVk0gYWRkcmVzcyB0byB0cmFuc2ZlciB0aGUgd3JhcHBlZCBORlRzIHRvLCBuaWwgaWYgdGhlIE5GVHMgc2hvdWxkIHN0YXkgaW4gc2lnbmVyJ3MgQ09BCi8vLwphY2Nlc3MoYWxsKSBmdW4gd3JhcEFuZFRyYW5zZmVyTkZUc0lmQXBwbGljYWJsZSgKICAgIF8gY29hOiBhdXRoKEVWTS5DYWxsKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQsCiAgICBuZnRJRHM6IFtVSW50NjRdLAogICAgbmZ0VHlwZTogVHlwZSwKICAgIHZpZXdSZXNvbHZlcjogJntWaWV3UmVzb2x2ZXJ9LAogICAgcmVjaXBpZW50SWZOb3RDb2E6IEVWTS5FVk1BZGRyZXNzPwopIHsKICAgIC8vIEdldCB0aGUgcHJvamVjdC1kZWZpbmVkIEVSQzcyMSBhZGRyZXNzIGlmIGl0IGV4aXN0cwogICAgaWYgbGV0IGNyb3NzVk1Qb2ludGVyID0gdmlld1Jlc29sdmVyLnJlc29sdmVDb250cmFjdFZpZXcoCiAgICAgICAgICAgIHJlc291cmNlVHlwZTogbmZ0VHlwZSwKICAgICAgICAgICAgdmlld1R5cGU6IFR5cGU8Q3Jvc3NWTU1ldGFkYXRhVmlld3MuRVZNUG9pbnRlcj4oKQogICAgKSBhcyEgQ3Jvc3NWTU1ldGFkYXRhVmlld3MuRVZNUG9pbnRlcj8gewogICAgICAgIC8vIEdldCB0aGUgdW5kZXJseWluZyBFUkM3MjEgYWRkcmVzcyBpZiBpdCBleGlzdHMKICAgICAgICBpZiBsZXQgdW5kZXJseWluZ0FkZHJlc3MgPSBnZXRVbmRlcmx5aW5nRVJDNzIxQWRkcmVzcyhjb2EsIGNyb3NzVk1Qb2ludGVyLmV2bUNvbnRyYWN0QWRkcmVzcykgewogICAgICAgICAgICAvLyBXcmFwIE5GVHMgaWYgdW5kZXJseWluZyBFUkM3MjEgYWRkcmVzcyBtYXRjaGVzIGJyaWRnZSdzIGFzc29jaWF0ZWQgYWRkcmVzcyBmb3IgTkZUIHR5cGUKICAgICAgICAgICAgaWYgdW5kZXJseWluZ0FkZHJlc3MuZXF1YWxzKEZsb3dFVk1CcmlkZ2VDb25maWcuZ2V0RVZNQWRkcmVzc0Fzc29jaWF0ZWQod2l0aDogbmZ0VHlwZSkhKSB7CiAgICAgICAgICAgICAgICAvLyBBcHByb3ZlIGNvbnRyYWN0IHRvIHdpdGhkcmF3IHVuZGVybHlpbmcgTkZUcyBmcm9tIHNpZ25lcidzIGNvYQogICAgICAgICAgICAgICAgbXVzdENhbGwoY29hLCB1bmRlcmx5aW5nQWRkcmVzcywKICAgICAgICAgICAgICAgICAgICBmdW5jdGlvblNpZzogInNldEFwcHJvdmFsRm9yQWxsKGFkZHJlc3MsYm9vbCkiLAogICAgICAgICAgICAgICAgICAgIGFyZ3M6IFtjcm9zc1ZNUG9pbnRlci5ldm1Db250cmFjdEFkZHJlc3MsIHRydWVdCiAgICAgICAgICAgICAgICApCgogICAgICAgICAgICAgICAgLy8gV3JhcCBORlRzIHdpdGggcHJvdmlkZWQgSURzLCBhbmQgY2hlY2sgaWYgdGhlIGNhbGwgd2FzIHN1Y2Nlc3NmdWwKICAgICAgICAgICAgICAgIGxldCByZXMgPSBtdXN0Q2FsbChjb2EsIGNyb3NzVk1Qb2ludGVyLmV2bUNvbnRyYWN0QWRkcmVzcywKICAgICAgICAgICAgICAgICAgICBmdW5jdGlvblNpZzogImRlcG9zaXRGb3IoYWRkcmVzcyx1aW50MjU2W10pIiwKICAgICAgICAgICAgICAgICAgICBhcmdzOiBbY29hLmFkZHJlc3MoKSwgbmZ0SURzXQogICAgICAgICAgICAgICAgKQogICAgICAgICAgICAgICAgbGV0IGRlY29kZWRSZXMgPSBFVk0uZGVjb2RlQUJJKHR5cGVzOiBbVHlwZTxCb29sPigpXSwgZGF0YTogcmVzLmRhdGEpCiAgICAgICAgICAgICAgICBhc3NlcnQoZGVjb2RlZFJlcy5sZW5ndGggPT0gMSwgbWVzc2FnZTogIkludmFsaWQgcmVzcG9uc2UgbGVuZ3RoIikKICAgICAgICAgICAgICAgIGFzc2VydChkZWNvZGVkUmVzWzBdIGFzISBCb29sLCBtZXNzYWdlOiAiRmFpbGVkIHRvIHdyYXAgTkZUcyIpCgogICAgICAgICAgICAgICAgLy8gVHJhbnNmZXIgTkZUcyB0byByZWNpcGllbnQgaWYgcHJvdmlkZWQKICAgICAgICAgICAgICAgIGlmIGxldCB0byA9IHJlY2lwaWVudElmTm90Q29hIHsKICAgICAgICAgICAgICAgICAgICBtdXN0VHJhbnNmZXJORlRzKGNvYSwgY3Jvc3NWTVBvaW50ZXIuZXZtQ29udHJhY3RBZGRyZXNzLCBuZnRJRHM6IG5mdElEcywgdG86IHRvKQogICAgICAgICAgICAgICAgfQoKICAgICAgICAgICAgICAgIC8vIFJldm9rZSBhcHByb3ZhbCBmb3IgY29udHJhY3QgdG8gd2l0aGRyYXcgdW5kZXJseWluZyBORlRzIGZyb20gc2lnbmVyJ3MgY29hCiAgICAgICAgICAgICAgICBtdXN0Q2FsbChjb2EsIHVuZGVybHlpbmdBZGRyZXNzLAogICAgICAgICAgICAgICAgICAgIGZ1bmN0aW9uU2lnOiAic2V0QXBwcm92YWxGb3JBbGwoYWRkcmVzcyxib29sKSIsCiAgICAgICAgICAgICAgICAgICAgYXJnczogW2Nyb3NzVk1Qb2ludGVyLmV2bUNvbnRyYWN0QWRkcmVzcywgZmFsc2VdCiAgICAgICAgICAgICAgICApCiAgICAgICAgICAgIH0KICAgICAgICB9CiAgICB9Cn0KCi8vLyBHZXRzIHRoZSB1bmRlcmx5aW5nIEVSQzcyMSBhZGRyZXNzIGlmIGl0IGV4aXN0cyAoaS5lLiBpZiB0aGUgRVJDNzIxIGlzIGEgd3JhcHBlcikKLy8vCmFjY2VzcyhhbGwpIGZ1biBnZXRVbmRlcmx5aW5nRVJDNzIxQWRkcmVzcygKICAgIF8gY29hOiBhdXRoKEVWTS5DYWxsKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQsCiAgICBfIHdyYXBwZXJBZGRyZXNzOiBFVk0uRVZNQWRkcmVzcwopOiBFVk0uRVZNQWRkcmVzcz8gewogICAgbGV0IHJlcyA9IGNvYS5jYWxsKAogICAgICAgIHRvOiB3cmFwcGVyQWRkcmVzcywKICAgICAgICBkYXRhOiBFVk0uZW5jb2RlQUJJV2l0aFNpZ25hdHVyZSgidW5kZXJseWluZygpIiwgW10pLAogICAgICAgIGdhc0xpbWl0OiAxMDBfMDAwLAogICAgICAgIHZhbHVlOiBFVk0uQmFsYW5jZShhdHRvZmxvdzogMCkKICAgICkKCiAgICAvLyBJZiB0aGUgY2FsbCBmYWlscywgcmV0dXJuIG5pbAogICAgaWYgcmVzLnN0YXR1cyAhPSBFVk0uU3RhdHVzLnN1Y2Nlc3NmdWwgfHwgcmVzLmRhdGEubGVuZ3RoID09IDAgewogICAgICAgIHJldHVybiBuaWwKICAgIH0KCiAgICAvLyBEZWNvZGUgYW5kIHJldHVybiB0aGUgdW5kZXJseWluZyBFUkM3MjEgYWRkcmVzcwogICAgbGV0IGRlY29kZWRSZXN1bHQgPSBFVk0uZGVjb2RlQUJJKAogICAgICAgIHR5cGVzOiBbVHlwZTxFVk0uRVZNQWRkcmVzcz4oKV0sCiAgICAgICAgZGF0YTogcmVzLmRhdGEKICAgICkKICAgIGFzc2VydChkZWNvZGVkUmVzdWx0Lmxlbmd0aCA9PSAxLCBtZXNzYWdlOiAiSW52YWxpZCByZXNwb25zZSBsZW5ndGgiKQogICAgcmV0dXJuIGRlY29kZWRSZXN1bHRbMF0gYXMhIEVWTS5FVk1BZGRyZXNzCn0KCi8vLyBDaGVja3MgaWYgdGhlIHByb3ZpZGVkIE5GVCBpcyBvd25lZCBieSB0aGUgcHJvdmlkZWQgRVZNIGFkZHJlc3MKLy8vCmFjY2VzcyhhbGwpIGZ1biBpc093bmVyKAogICAgXyBjb2E6IGF1dGgoRVZNLkNhbGwpICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudCwKICAgIF8gZXJjNzIxQWRkcmVzczogRVZNLkVWTUFkZHJlc3MsCiAgICBfIG5mdElEOiBVSW50NjQsCiAgICBfIG93bmVyVG9DaGVjazogRVZNLkVWTUFkZHJlc3MKKTogQm9vbCB7CiAgICBsZXQgcmVzID0gY29hLmNhbGwoCiAgICAgICAgdG86IGVyYzcyMUFkZHJlc3MsCiAgICAgICAgZGF0YTogRVZNLmVuY29kZUFCSVdpdGhTaWduYXR1cmUoIm93bmVyT2YodWludDI1NikiLCBbbmZ0SURdKSwKICAgICAgICBnYXNMaW1pdDogMTAwXzAwMCwKICAgICAgICB2YWx1ZTogRVZNLkJhbGFuY2UoYXR0b2Zsb3c6IDApCiAgICApCiAgICBhc3NlcnQocmVzLnN0YXR1cyA9PSBFVk0uU3RhdHVzLnN1Y2Nlc3NmdWwsIG1lc3NhZ2U6ICJDYWxsIHRvIEVSQzcyMS5vd25lck9mKHVpbnQyNTYpIGZhaWxlZCIpCiAgICBsZXQgZGVjb2RlZFJlcyA9IEVWTS5kZWNvZGVBQkkodHlwZXM6IFtUeXBlPEVWTS5FVk1BZGRyZXNzPigpXSwgZGF0YTogcmVzLmRhdGEpCiAgICBpZiBkZWNvZGVkUmVzLmxlbmd0aCA9PSAxIHsKICAgICAgICBsZXQgYWN0dWFsT3duZXIgPSBkZWNvZGVkUmVzWzBdIGFzISBFVk0uRVZNQWRkcmVzcwogICAgICAgIHJldHVybiBhY3R1YWxPd25lci5lcXVhbHMob3duZXJUb0NoZWNrKQogICAgfQogICAgcmV0dXJuIGZhbHNlCn0KCi8vLyBUcmFuc2ZlcnMgTkZUcyBmcm9tIHRoZSBwcm92aWRlZCBDT0EgdG8gdGhlIHByb3ZpZGVkIEVWTSBhZGRyZXNzCi8vLwphY2Nlc3MoYWxsKSBmdW4gbXVzdFRyYW5zZmVyTkZUcygKICAgIF8gY29hOiBhdXRoKEVWTS5DYWxsKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQsCiAgICBfIGVyYzcyMUFkZHJlc3M6IEVWTS5FVk1BZGRyZXNzLAogICAgbmZ0SURzOiBbVUludDY0XSwKICAgIHRvOiBFVk0uRVZNQWRkcmVzcwopIHsKICAgIGZvciBpZCBpbiBuZnRJRHMgewogICAgICAgIGFzc2VydChpc093bmVyKGNvYSwgZXJjNzIxQWRkcmVzcywgaWQsIGNvYS5hZGRyZXNzKCkpLCBtZXNzYWdlOiAiTkZUIG5vdCBvd25lZCBieSBzaWduZXIncyBDT0EiKQogICAgICAgIG11c3RDYWxsKGNvYSwgZXJjNzIxQWRkcmVzcywKICAgICAgICAgICAgZnVuY3Rpb25TaWc6ICJzYWZlVHJhbnNmZXJGcm9tKGFkZHJlc3MsYWRkcmVzcyx1aW50MjU2KSIsCiAgICAgICAgICAgIGFyZ3M6IFtjb2EuYWRkcmVzcygpLCB0bywgaWRdCiAgICAgICAgKQogICAgICAgIGFzc2VydChpc093bmVyKGNvYSwgZXJjNzIxQWRkcmVzcywgaWQsIHRvKSwgbWVzc2FnZTogIk5GVCBub3QgdHJhbnNmZXJyZWQgdG8gcmVjaXBpZW50IikKICAgIH0KfQoKLy8vIENhbGxzIGEgZnVuY3Rpb24gb24gYW4gRVZNIGNvbnRyYWN0IGZyb20gcHJvdmlkZWQgY29hCi8vLwphY2Nlc3MoYWxsKSBmdW4gbXVzdENhbGwoCiAgICBfIGNvYTogYXV0aChFVk0uQ2FsbCkgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50LAogICAgXyBjb250cmFjdEFkZHI6IEVWTS5FVk1BZGRyZXNzLAogICAgZnVuY3Rpb25TaWc6IFN0cmluZywKICAgIGFyZ3M6IFtBbnlTdHJ1Y3RdCik6IEVWTS5SZXN1bHQgewogICAgbGV0IHJlcyA9IGNvYS5jYWxsKAogICAgICAgIHRvOiBjb250cmFjdEFkZHIsCiAgICAgICAgZGF0YTogRVZNLmVuY29kZUFCSVdpdGhTaWduYXR1cmUoZnVuY3Rpb25TaWcsIGFyZ3MpLAogICAgICAgIGdhc0xpbWl0OiA0XzAwMF8wMDAsCiAgICAgICAgdmFsdWU6IEVWTS5CYWxhbmNlKGF0dG9mbG93OiAwKQogICAgKQoKICAgIGFzc2VydChyZXMuc3RhdHVzID09IEVWTS5TdGF0dXMuc3VjY2Vzc2Z1bCwKICAgICAgICBtZXNzYWdlOiAiRmFpbGVkIHRvIGNhbGwgJyIuY29uY2F0KGZ1bmN0aW9uU2lnKQogICAgICAgICAgICAuY29uY2F0KCJcblx0IGVycm9yIGNvZGU6ICIpLmNvbmNhdChyZXMuZXJyb3JDb2RlLnRvU3RyaW5nKCkpCiAgICAgICAgICAgIC5jb25jYXQoIlxuXHQgZXJyb3IgbWVzc2FnZTogIikuY29uY2F0KHJlcy5lcnJvck1lc3NhZ2UpCiAgICAgICAgICAgIC5jb25jYXQoIlxuXHQgZ2FzIHVzZWQ6ICIpLmNvbmNhdChyZXMuZ2FzVXNlZC50b1N0cmluZygpKQogICAgICAgICAgICAuY29uY2F0KCJcblx0IGNhbGxlciBhZGRyZXNzOiAweCIpLmNvbmNhdChjb2EuYWRkcmVzcygpLnRvU3RyaW5nKCkpCiAgICAgICAgICAgIC5jb25jYXQoIlxuXHQgY29udHJhY3QgYWRkcmVzczogMHgiKS5jb25jYXQoY29udHJhY3RBZGRyLnRvU3RyaW5nKCkpCiAgICApCgogICAgcmV0dXJuIHJlcwp9Cg\u003d\u003d", - "bridgeNFTToEvmV2": "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\u003d\u003d", - "bridgeNFTToEvmWithPayer": "// Flow Wallet - mainnet Script  bridgeNFTToEvmWithPayer - v2.72
// <platform_info>

import MetadataViews from 0x1d7e57aa55817448

import ViewResolver from 0x1d7e57aa55817448

import NonFungibleToken from 0x1d7e57aa55817448

import FungibleToken from 0xf233dcee88fe0abe

import FlowToken from 0x1654653399040a61

import FungibleTokenMetadataViews from 0xf233dcee88fe0abe

import ScopedFTProviders from 0x1e4aa0b87d10b141

import EVM from 0xe467b9dd11fa00df

import FlowEVMBridgeUtils from 0x1e4aa0b87d10b141

import FlowEVMBridge from 0x1e4aa0b87d10b141

import FlowEVMBridgeConfig from 0x1e4aa0b87d10b141

import CrossVMMetadataViews from 0x1d7e57aa55817448


/// Bridges an NFT from the signer's collection in Cadence to the signer's COA in FlowEVM
///
/// NOTE: This transaction also onboards the NFT to the bridge if necessary which may incur additional fees
///     than bridging an asset that has already been onboarded.
///
/// @param nftIdentifier: The Cadence type identifier of the NFT to bridge - e.g. nft.getType().identifier
/// @param id: The Cadence NFT.id of the NFT to bridge to EVM
///
transaction(nftIdentifier: String, id: UInt64) {

    let nft: @{NonFungibleToken.NFT}
    let coa: auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount
    let requiresOnboarding: Bool
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let nftType: Type
    let viewResolver: &{ViewResolver}

    prepare(signer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account, payer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        /* --- Construct the NFT type --- */
        //
        // Construct the NFT type from the provided identifier
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        // Parse the NFT identifier into its components
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: self.nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Retrieve the NFT --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: self.nftType,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        let collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            ) ?? panic("Could not access signer's NFT Collection")

        // Withdraw the requested NFT & calculate the approximate bridge fee based on NFT storage usage
        let currentStorageUsage = signer.storage.used
        self.nft <- collection.withdraw(withdrawID: id)
        let withdrawnStorageUsage = signer.storage.used
        var approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000) + FlowEVMBridgeConfig.baseFee
        // Determine if the NFT requires onboarding - this impacts the fee required
        self.requiresOnboarding = FlowEVMBridge.typeRequiresOnboarding(self.nft.getType())
            ?? panic("Bridge does not support this asset type")
        if self.requiresOnboarding {
            approxFee = approxFee + FlowEVMBridgeConfig.onboardFee
        }

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if payer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = payer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            payer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = payer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    pre {
        self.nft.getType().identifier == nftIdentifier:
            "Attempting to send invalid nft type - requested: ".concat(nftIdentifier)
            .concat(", sending: ").concat(self.nft.getType().identifier)
    }

    execute {
        if self.requiresOnboarding {
            // Onboard the NFT to the bridge
            FlowEVMBridge.onboardByType(
                self.nft.getType(),
                feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
        }

        // Execute the bridge
        self.coa.depositNFT(
            nft: <-self.nft,
            feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        // Destroy the ScopedFTProvider
        destroy self.scopedProvider

        // Wrap NFTs if applicable
        wrapAndTransferNFTsIfApplicable(self.coa,
            nftIDs: [id],
            nftType: self.nftType,
            viewResolver: self.viewResolver,
            recipientIfNotCoa: nil
        )
    }
}

/// Wraps and transfers bridged NFTs into a project's custom ERC721 wrapper contract on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
/// @param recipientIfNotCoa: The EVM address to transfer the wrapped NFTs to, nil if the NFTs should stay in signer's COA
///
access(all) fun wrapAndTransferNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt64],
    nftType: Type,
    viewResolver: &{ViewResolver},
    recipientIfNotCoa: EVM.EVMAddress?
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            // Wrap NFTs if underlying ERC721 address matches bridge's associated address for NFT type
            if underlyingAddress.equals(FlowEVMBridgeConfig.getEVMAddressAssociated(with: nftType)!) {
                // Approve contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, true]
                )

                // Wrap NFTs with provided IDs, and check if the call was successful
                let res = mustCall(coa, crossVMPointer.evmContractAddress,
                    functionSig: "depositFor(address,uint256[])",
                    args: [coa.address(), nftIDs]
                )
                let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                assert(decodedRes.length == 1, message: "Invalid response length")
                assert(decodedRes[0] as! Bool, message: "Failed to wrap NFTs")

                // Transfer NFTs to recipient if provided
                if let to = recipientIfNotCoa {
                    mustTransferNFTs(coa, crossVMPointer.evmContractAddress, nftIDs: nftIDs, to: to)
                }

                // Revoke approval for contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, false]
                )
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is owned by the provided EVM address
///
access(all) fun isOwner(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    _ nftID: UInt64,
    _ ownerToCheck: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: erc721Address,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )
    assert(res.status == EVM.Status.successful, message: "Call to ERC721.ownerOf(uint256) failed")
    let decodedRes = EVM.decodeABI(types: [Type<EVM.EVMAddress>()], data: res.data)
    if decodedRes.length == 1 {
        let actualOwner = decodedRes[0] as! EVM.EVMAddress
        return actualOwner.equals(ownerToCheck)
    }
    return false
}

/// Transfers NFTs from the provided COA to the provided EVM address
///
access(all) fun mustTransferNFTs(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    nftIDs: [UInt64],
    to: EVM.EVMAddress
) {
    for id in nftIDs {
        assert(isOwner(coa, erc721Address, id, coa.address()), message: "NFT not owned by signer's COA")
        mustCall(coa, erc721Address,
            functionSig: "safeTransferFrom(address,address,uint256)",
            args: [coa.address(), to, id]
        )
        assert(isOwner(coa, erc721Address, id, to), message: "NFT not transferred to recipient")
    }
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", - "bridgeTokensFromEvm": "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\u003d\u003d", - "bridgeTokensFromEvmToFlow": "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\u003d", - "bridgeTokensFromEvmToFlowV2": "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\u003d\u003d", - "bridgeTokensFromEvmToFlowV3": "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\u003d\u003d", - "bridgeTokensFromEvmV2": "// Flow Wallet - mainnet Script  bridgeTokensFromEvmV2 - v2.72
// <platform_info>

import MetadataViews from 0x1d7e57aa55817448

import ViewResolver from 0x1d7e57aa55817448

import NonFungibleToken from 0x1d7e57aa55817448


import FungibleToken from 0xf233dcee88fe0abe

import FlowToken from 0x1654653399040a61

import FungibleTokenMetadataViews from 0xf233dcee88fe0abe


import ScopedFTProviders from 0x1e4aa0b87d10b141


import EVM from 0xe467b9dd11fa00df


import FlowEVMBridgeUtils from 0x1e4aa0b87d10b141

import FlowEVMBridge from 0x1e4aa0b87d10b141

import FlowEVMBridgeConfig from 0x1e4aa0b87d10b141


/// This transaction bridges fungible tokens from EVM to Cadence assuming it has already been onboarded to the
/// FlowEVMBridge.
///
/// NOTE: The ERC20 must have first been onboarded to the bridge. This can be checked via the method
///     FlowEVMBridge.evmAddressRequiresOnboarding(address: self.evmContractAddress)
///
/// @param vaultIdentifier: The Cadence type identifier of the FungibleToken Vault to bridge
///     - e.g. vault.getType().identifier
/// @param amount: The amount of tokens to bridge from EVM
///
transaction(vaultIdentifier: String, amount: UInt256) {
    let vaultType: Type
    let receiver: &{FungibleToken.Vault}
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let coa: auth(EVM.Bridge) &EVM.CadenceOwnedAccount

    prepare(signer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        /* --- Construct the Vault type --- */
        //
        // Construct the Vault type from the provided identifier
        self.vaultType = CompositeType(vaultIdentifier)
            ?? panic("Could not construct Vault type from identifier: ".concat(vaultIdentifier))
        // Parse the Vault identifier into its components
        let tokenContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.vaultType)
            ?? panic("Could not get contract address from identifier: ".concat(vaultIdentifier))
        let tokenContractName = FlowEVMBridgeUtils.getContractName(fromType: self.vaultType)
            ?? panic("Could not get contract name from identifier: ".concat(vaultIdentifier))

        /* --- Reference the signer's Vault --- */
        //
        // Borrow a reference to the FungibleToken Vault, configuring if necessary
        let viewResolver = getAccount(tokenContractAddress).contracts.borrow<&{ViewResolver}>(name: tokenContractName)
            ?? panic("Could not borrow ViewResolver from FungibleToken contract")
        let vaultData = viewResolver.resolveContractView(
                resourceType: self.vaultType,
                viewType: Type<FungibleTokenMetadataViews.FTVaultData>()
            ) as! FungibleTokenMetadataViews.FTVaultData? ?? panic("Could not resolve FTVaultData view")
        // If the vault does not exist, create it and publish according to the contract's defined configuration
        if signer.storage.borrow<&{FungibleToken.Vault}>(from: vaultData.storagePath) == nil {
            signer.storage.save(<-vaultData.createEmptyVault(), to: vaultData.storagePath)

            signer.capabilities.unpublish(vaultData.receiverPath)
            signer.capabilities.unpublish(vaultData.metadataPath)

            let receiverCap = signer.capabilities.storage.issue<&{FungibleToken.Vault}>(vaultData.storagePath)
            let metadataCap = signer.capabilities.storage.issue<&{FungibleToken.Vault}>(vaultData.storagePath)

            signer.capabilities.publish(receiverCap, at: vaultData.receiverPath)
            signer.capabilities.publish(metadataCap, at: vaultData.metadataPath)
        }
        self.receiver = signer.storage.borrow<&{FungibleToken.Vault}>(from: vaultData.storagePath)
            ?? panic("Could not borrow Vault from storage path")

        /* --- Configure a ScopedFTProvider --- */
        //
        // Calculate the bridge fee - bridging from EVM consumes no storage, so flat fee
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000)
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    execute {
        // Execute the bridge request
        let vault: @{FungibleToken.Vault} <- self.coa.withdrawTokens(
            type: self.vaultType,
            amount: amount,
            feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        // Ensure the bridged vault is the correct type
        assert(vault.getType() == self.vaultType, message: "Bridged vault type mismatch")
        // Deposit the bridged token into the signer's vault
        self.receiver.deposit(from: <-vault)
        // Destroy the ScopedFTProvider
        destroy self.scopedProvider
    }
}", - "bridgeTokensToEvm": "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", - "bridgeTokensToEvmAddress": "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", - "bridgeTokensToEvmAddressV2": "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\u003d\u003d", - "bridgeTokensToEvmV2": "// Flow Wallet - mainnet Script  bridgeTokensToEvmV2 - v2.72
// <platform_info>

import MetadataViews from 0x1d7e57aa55817448

import ViewResolver from 0x1d7e57aa55817448

import NonFungibleToken from 0x1d7e57aa55817448


import FungibleToken from 0xf233dcee88fe0abe

import FlowToken from 0x1654653399040a61

import FungibleTokenMetadataViews from 0xf233dcee88fe0abe


import ScopedFTProviders from 0x1e4aa0b87d10b141


import EVM from 0xe467b9dd11fa00df


import FlowEVMBridgeUtils from 0x1e4aa0b87d10b141

import FlowEVMBridge from 0x1e4aa0b87d10b141

import FlowEVMBridgeConfig from 0x1e4aa0b87d10b141

/// Bridges a Vault from the signer's storage to the signer's COA in EVM.Account.
///
/// NOTE: This transaction also onboards the Vault to the bridge if necessary which may incur additional fees
///     than bridging an asset that has already been onboarded.
///
/// @param vaultIdentifier: The Cadence type identifier of the FungibleToken Vault to bridge
///     - e.g. vault.getType().identifier
/// @param amount: The amount of tokens to bridge from EVM
///
transaction(vaultIdentifier: String, amount: UFix64) {
    let sentVault: @{FungibleToken.Vault}
    let coa: auth(EVM.Bridge) &EVM.CadenceOwnedAccount
    let requiresOnboarding: Bool
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider

    prepare(signer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        /* --- Construct the Vault type --- */
        //
        // Construct the Vault type from the provided identifier
        let vaultType = CompositeType(vaultIdentifier)
            ?? panic("Could not construct Vault type from identifier: ".concat(vaultIdentifier))
        // Parse the Vault identifier into its components
        let tokenContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: vaultType)
            ?? panic("Could not get contract address from identifier: ".concat(vaultIdentifier))
        let tokenContractName = FlowEVMBridgeUtils.getContractName(fromType: vaultType)
            ?? panic("Could not get contract name from identifier: ".concat(vaultIdentifier))

        /* --- Retrieve the funds --- */
        //
        // Borrow a reference to the FungibleToken Vault
        let viewResolver = getAccount(tokenContractAddress).contracts.borrow<&{ViewResolver}>(name: tokenContractName)
            ?? panic("Could not borrow ViewResolver from FungibleToken contract")
        let vaultData = viewResolver.resolveContractView(
                resourceType: vaultType,
                viewType: Type<FungibleTokenMetadataViews.FTVaultData>()
            ) as! FungibleTokenMetadataViews.FTVaultData? ?? panic("Could not resolve FTVaultData view")
        let vault = signer.storage.borrow<auth(FungibleToken.Withdraw) &{FungibleToken.Vault}>(
                from: vaultData.storagePath
            ) ?? panic("Could not access signer's FungibleToken Vault")

        // Withdraw the requested balance & calculate the approximate bridge fee based on storage usage
        let currentStorageUsage = signer.storage.used
        self.sentVault <- vault.withdraw(amount: amount)
        let withdrawnStorageUsage = signer.storage.used
        // Approximate the bridge fee based on the difference in storage usage with some buffer
        var approxFee = FlowEVMBridgeUtils.calculateBridgeFee(
                bytes: currentStorageUsage - withdrawnStorageUsage
            ) * 1.10
        // Determine if the Vault requires onboarding - this impacts the fee required
        self.requiresOnboarding = FlowEVMBridge.typeRequiresOnboarding(self.sentVault.getType())
            ?? panic("Bridge does not support this asset type")
        if self.requiresOnboarding {
            approxFee = approxFee + FlowEVMBridgeConfig.onboardFee
        }

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    pre {
        self.sentVault.getType().identifier == vaultIdentifier:
            "Attempting to send invalid vault type - requested: ".concat(vaultIdentifier)
            .concat(", sending: ").concat(self.sentVault.getType().identifier)
    }

    execute {
        if self.requiresOnboarding {
            // Onboard the Vault to the bridge
            FlowEVMBridge.onboardByType(
                self.sentVault.getType(),
                feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
        }
        // Execute the bridge
        self.coa.depositTokens(
            vault: <-self.sentVault,
            feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        // Destroy the ScopedFTProvider
        destroy self.scopedProvider
    }
}", - "calculateBridgeFee": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY2FsY3VsYXRlQnJpZGdlRmVlIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd0VWTUJyaWRnZVV0aWxzIGZyb20gMHgxZTRhYTBiODdkMTBiMTQxCgoKLy8vIFJldHVybnMgdGhlIGNhbGN1bGF0ZWQgZmVlIGJhc2VkIG9uIHRoZSBudW1iZXIgb2YgYnl0ZXMgdXNlZCB0byBlc2Nyb3cgYW4gYXNzZXQgcGx1cyB0aGUgYmFzZSBmZWUuCi8vLwovLy8gQHBhcmFtIGJ5dGVzOiBUaGUgbnVtYmVyIG9mIGJ5dGVzIHVzZWQgdG8gZXNjcm93IGFuIGFzc2V0LgovLy8KLy8vIEByZXR1cm4gVGhlIGNhbGN1bGF0ZWQgZmVlIHRvIGJlIHBhaWQgaW4gRmxvd1Rva2VuCi8vLwphY2Nlc3MoYWxsKQpmdW4gbWFpbihieXRlcyB1c2VkOiBVSW50NjQpOiBVRml4NjQgewogICAgcmV0dXJuIEZsb3dFVk1CcmlkZ2VVdGlscy5jYWxjdWxhdGVCcmlkZ2VGZWUoYnl0ZXM6IHVzZWQpCn0K", - "evmAddressRequiresOnboarding": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZXZtQWRkcmVzc1JlcXVpcmVzT25ib2FyZGluZyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTVV0aWxzIGZyb20gMHgxZTRhYTBiODdkMTBiMTQxCgppbXBvcnQgRmxvd0VWTUJyaWRnZSBmcm9tIDB4MWU0YWEwYjg3ZDEwYjE0MQoKCi8vLyBSZXR1cm5zIHdoZXRoZXIgYSBFVk0gY29udHJhY3QgbmVlZHMgdG8gYmUgb25ib2FyZGVkIHRvIHRoZSBGbG93RVZNQnJpZGdlCi8vLwovLy8gQHBhcmFtIGV2bUFkZHJlc3NIZXg6IFRoZSBoZXgtZW5jb2RlZCBhZGRyZXNzIG9mIHRoZSBFVk0gY29udHJhY3QgYXMgYSBTdHJpbmcgd2l0aG91dCAweCBwcmVmaXgKLy8vCi8vLyBAcmV0dXJuIFdoZXRoZXIgdGhlIGNvbnRyYWN0IHJlcXVpcmVzIG9uYm9hcmRpbmcgdG8gdGhlIEZsb3dFVk1CcmlkZ2UgaWYgdGhlIHR5cGUgaXMgYnJpZGdlYWJsZSwgb3RoZXJ3aXNlIG5pbAovLy8KYWNjZXNzKGFsbCkgZnVuIG1haW4oZXZtQWRkcmVzc0hleDogU3RyaW5nKTogQm9vbD8gewogICAgaWYgbGV0IGFkZHJlc3MgPSBFVk1VdGlscy5nZXRFVk1BZGRyZXNzRnJvbUhleFN0cmluZyhhZGRyZXNzOiBldm1BZGRyZXNzSGV4KSB7CiAgICAgICAgcmV0dXJuIEZsb3dFVk1CcmlkZ2UuZXZtQWRkcmVzc1JlcXVpcmVzT25ib2FyZGluZyhhZGRyZXNzKQogICAgfQogICAgcmV0dXJuIG5pbAp9Cg\u003d\u003d", - "getAssociatedEvmAddress": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QXNzb2NpYXRlZEV2bUFkZHJlc3MgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBFVk0gZnJvbSAweGU0NjdiOWRkMTFmYTAwZGYKCgppbXBvcnQgRVZNVXRpbHMgZnJvbSAweDFlNGFhMGI4N2QxMGIxNDEKCmltcG9ydCBGbG93RVZNQnJpZGdlQ29uZmlnIGZyb20gMHgxZTRhYTBiODdkMTBiMTQxCgoKLy8vIFJldHVybnMgdGhlIEVWTSBhZGRyZXNzIGFzc29jaWF0ZWQgd2l0aCB0aGUgZ2l2ZW4gQ2FkZW5jZSB0eXBlIChhcyBpdHMgaWRlbnRpZmllciBTdHJpbmcpCi8vLwovLy8gQHBhcmFtIHR5cGVJZGVudGlmaWVyIFRoZSBDYWRlbmNlIHR5cGUgaWRlbnRpZmllciBTdHJpbmcKLy8vCi8vLyBAcmV0dXJuIFRoZSBFVk0gYWRkcmVzcyBhcyBhIGhleCBzdHJpbmcgaWYgdGhlIHR5cGUgaGFzIGFuIGFzc29jaWF0ZWQgRVZNQWRkcmVzcywgb3RoZXJ3aXNlIG5pbAovLy8KYWNjZXNzKGFsbCkKZnVuIG1haW4oaWRlbnRpZmllcjogU3RyaW5nKTogU3RyaW5nPyB7CiAgICBpZiBsZXQgdHlwZSA9IENvbXBvc2l0ZVR5cGUoaWRlbnRpZmllcikgewogICAgICAgIGlmIGxldCBhZGRyZXNzID0gRmxvd0VWTUJyaWRnZUNvbmZpZy5nZXRFVk1BZGRyZXNzQXNzb2NpYXRlZCh3aXRoOiB0eXBlKSB7CiAgICAgICAgICAgIHJldHVybiBFVk1VdGlscy5nZXRFVk1BZGRyZXNzQXNIZXhTdHJpbmcoYWRkcmVzczogYWRkcmVzcykKICAgICAgICB9CiAgICB9CiAgICByZXR1cm4gbmlsCn0\u003d", - "getAssociatedFlowIdentifier": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QXNzb2NpYXRlZEZsb3dJZGVudGlmaWVyIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRVZNIGZyb20gMHhlNDY3YjlkZDExZmEwMGRmCgppbXBvcnQgRmxvd0VWTUJyaWRnZUNvbmZpZyBmcm9tIDB4MWU0YWEwYjg3ZDEwYjE0MQoKCmFjY2VzcyhhbGwpCmZ1biBtYWluKGFkZHJlc3M6IFN0cmluZyk6IFN0cmluZz8gewogICAgaWYgbGV0IHR5cGVJbmZvID0gRmxvd0VWTUJyaWRnZUNvbmZpZy5nZXRUeXBlQXNzb2NpYXRlZCh3aXRoOiBFVk0uYWRkcmVzc0Zyb21TdHJpbmcoYWRkcmVzcykpIHsKICAgICAgICByZXR1cm4gdHlwZUluZm8uaWRlbnRpZmllcgogICAgfQogICAgcmV0dXJuIG5pbAp9", - "getBridgeCoaAddress": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QnJpZGdlQ29hQWRkcmVzcyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4ZTQ2N2I5ZGQxMWZhMDBkZgoKCmltcG9ydCBFVk1VdGlscyBmcm9tIDB4MWU0YWEwYjg3ZDEwYjE0MQoKaW1wb3J0IEZsb3dFVk1CcmlkZ2VDb25maWcgZnJvbSAweDFlNGFhMGI4N2QxMGIxNDEKCgovLy8gUmV0dXJucyB0aGUgRVZNIGFkZHJlc3MgYXNzb2NpYXRlZCB3aXRoIHRoZSBGbG93RVZNQnJpZGdlCi8vLwovLy8gQHJldHVybiBUaGUgRVZNIGFkZHJlc3MgYXNzb2NpYXRlZCB3aXRoIHRoZSBGbG93RVZNQnJpZGdlJ3MgY29vcmRpbmF0aW5nIENhZGVuY2VPd25lZEFjY291bnQKLy8vCmFjY2VzcyhhbGwpIGZ1biBtYWluKCk6IFN0cmluZyB7CiAgICBsZXQgYWRkcmVzczogRVZNLkVWTUFkZHJlc3MgPSBGbG93RVZNQnJpZGdlLmdldEJyaWRnZUNPQUVWTUFkZHJlc3MoKQogICAgcmV0dXJuIEVWTVV0aWxzLmdldEVWTUFkZHJlc3NBc0hleFN0cmluZyhhZGRyZXNzOiBhZGRyZXNzKQp9", - "onboardByEvmAddress": "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\u003d", - "onboardByType": "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\u003d\u003d", - "onboardByTypeIdentifier": "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\u003d\u003d", - "typeRequiresOnboarding": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgdHlwZVJlcXVpcmVzT25ib2FyZGluZyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dFVk1CcmlkZ2UgZnJvbSAweDFlNGFhMGI4N2QxMGIxNDEKCgovLy8gUmV0dXJucyB3aGV0aGVyIGEgdHlwZSBuZWVkcyB0byBiZSBvbmJvYXJkZWQgdG8gdGhlIEZsb3dFVk1CcmlkZ2UKLy8vCi8vLyBAcGFyYW0gdHlwZTogVGhlIENhZGVuY2UgVHlwZSBpbiBxdWVzdGlvbgovLy8KLy8vIEByZXR1cm4gV2hldGhlciB0aGUgdHlwZSByZXF1aXJlcyBvbmJvYXJkaW5nIHRvIHRoZSBGbG93RVZNQnJpZGdlIGlmIHRoZSB0eXBlIGlzIGJyaWRnZWFibGUsIG90aGVyd2lzZSBuaWwKLy8vCmFjY2VzcyhhbGwpIGZ1biBtYWluKHR5cGU6IFR5cGUpOiBCb29sPyB7CiAgICByZXR1cm4gRmxvd0VWTUJyaWRnZS50eXBlUmVxdWlyZXNPbmJvYXJkaW5nKHR5cGUpCn0K", - "typeRequiresOnboardingByIdentifier": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgdHlwZVJlcXVpcmVzT25ib2FyZGluZ0J5SWRlbnRpZmllciAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dFVk1CcmlkZ2UgZnJvbSAweDFlNGFhMGI4N2QxMGIxNDEKCgovLy8gUmV0dXJucyB3aGV0aGVyIGEgdHlwZSBuZWVkcyB0byBiZSBvbmJvYXJkZWQgdG8gdGhlIEZsb3dFVk1CcmlkZ2UKLy8vCi8vLyBAcGFyYW0gaWRlbnRpZmllcjogVGhlIGlkZW50aWZpZXIgb2YgdGhlIENhZGVuY2UgVHlwZSBpbiBxdWVzdGlvbgovLy8KLy8vIEByZXR1cm4gV2hldGhlciB0aGUgdHlwZSByZXF1aXJlcyBvbmJvYXJkaW5nIHRvIHRoZSBGbG93RVZNQnJpZGdlIGlmIHRoZSB0eXBlIGlzIGJyaWRnZWFibGUsIG90aGVyd2lzZSBuaWwKLy8vCmFjY2VzcyhhbGwpIGZ1biBtYWluKGlkZW50aWZpZXI6IFN0cmluZyk6IEJvb2w/IHsKICAgIGlmIGxldCB0eXBlID0gQ29tcG9zaXRlVHlwZShpZGVudGlmaWVyKSB7CiAgICAgICAgcmV0dXJuIEZsb3dFVk1CcmlkZ2UudHlwZVJlcXVpcmVzT25ib2FyZGluZyh0eXBlKQogICAgfQogICAgcmV0dXJuIG5pbAp9Cg\u003d\u003d" - }, - "collection": { - "checkNFTCollection": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY2hlY2tORlRDb2xsZWN0aW9uIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgogICAgaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCiAgICBpbXBvcnQgPE5GVD4gZnJvbSA8TkZUQWRkcmVzcz4KCiAgICAvLyBUaGlzIHRyYW5zYWN0aW9uIGlzIGZvciB0cmFuc2ZlcnJpbmcgYW5kIE5GVCBmcm9tCiAgICAvLyBvbmUgYWNjb3VudCB0byBhbm90aGVyCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrPFRva2VuPlZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAgbGV0IHZhdWx0UmVmID0gYWNjb3VudC5jYXBhYmlsaXRpZXMuZXhpc3QoPFRva2VuQ29sbGVjdGlvblB1YmxpY1BhdGg+KQogICAgICAgIHJldHVybiB2YXVsdFJlZgogICAgfQoKICAgIGFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgICAgcmV0dXJuIGNoZWNrPFRva2VuPlZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICB9", - "enableNFTStorage": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZW5hYmxlTkZUU3RvcmFnZSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgPE5GVD4gZnJvbSA8TkZUQWRkcmVzcz4KCnRyYW5zYWN0aW9uIHsKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChDYXBhYmlsaXRpZXMsIFNhdmVWYWx1ZSkgJkFjY291bnQpIHsKICAgICAgICBpZiBzaWduZXIuY2FwYWJpbGl0aWVzLmJvcnJvdzwmPE5GVD4uQ29sbGVjdGlvbj4oPENvbGxlY3Rpb25QdWJsaWNQYXRoPikgPT0gbmlsIHsKICAgICAgICAgICAgbGV0IGNvbGxlY3Rpb24gPC0gPE5GVD4uY3JlYXRlRW1wdHlDb2xsZWN0aW9uKG5mdFR5cGU6IFR5cGU8QDxORlQ+Lk5GVD4oKSkKICAgICAgICAgICAgc2lnbmVyLnN0b3JhZ2Uuc2F2ZSg8LWNvbGxlY3Rpb24sIHRvOiA8Q29sbGVjdGlvblN0b3JhZ2VQYXRoPikKICAgICAgICB9CiAgICAgICAgaWYgKHNpZ25lci5jYXBhYmlsaXRpZXMuYm9ycm93PCY8TkZUPi5Db2xsZWN0aW9uPig8Q29sbGVjdGlvblB1YmxpY1BhdGg+KSA9PSBuaWwpIHsKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy51bnB1Ymxpc2goPENvbGxlY3Rpb25QdWJsaWNQYXRoPikKICAgICAgICAgICAgbGV0IGNhcCA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTwmPE5GVD4uQ29sbGVjdGlvbj4oPENvbGxlY3Rpb25TdG9yYWdlUGF0aD4pICAgICAgICAgICAgCiAgICAgICAgICAgIHNpZ25lci5jYXBhYmlsaXRpZXMucHVibGlzaChjYXAsIGF0OiA8Q29sbGVjdGlvblB1YmxpY1BhdGg+KQoKICAgICAgICB9CiAgICB9Cn0\u003d", - "enableNFTStorageV2": "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", - "getCatalogTypeData": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Q2F0YWxvZ1R5cGVEYXRhIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTkZUQ2F0YWxvZyBmcm9tIDB4TkZUQ2F0YWxvZwoKYWNjZXNzKGFsbCkgZnVuIG1haW4oKToge1N0cmluZyA6IHtTdHJpbmcgOiBCb29sfX0gewogIGxldCBjYXRhbG9nID0gTkZUQ2F0YWxvZy5nZXRDYXRhbG9nVHlwZURhdGEoKQogIHJldHVybiBjYXRhbG9nCn0\u003d", - "getNFT": "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", - "getNFTBalanceStorage": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0TkZUQmFsYW5jZVN0b3JhZ2UgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBOb25GdW5naWJsZVRva2VuIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgoKLy8vIEhlbHBlciBmdW5jdGlvbiB0aGF0IHJldHJpZXZlcyBkYXRhIGFib3V0IGFsbCBwdWJsaWNseSBhY2Nlc3NpYmxlIE5GVHMgY291bnQgIGFuIGFjY291bnQKLy8vCmFjY2VzcyhhbGwpIGZ1biBtYWluKF8gYWRkcmVzczogQWRkcmVzcyk6IHtTdHJpbmc6IEludH0gewogICAgbGV0IGFjY291bnQgPSBnZXRBdXRoQWNjb3VudDxhdXRoKEJvcnJvd1ZhbHVlKSAmQWNjb3VudD4oYWRkcmVzcykKICAgIGxldCBkYXRhOiB7U3RyaW5nOiBJbnR9ID0ge30KICAgIGxldCBjb2xsZWN0aW9uVHlwZTogVHlwZSA9IFR5cGU8QHtOb25GdW5naWJsZVRva2VuLkNvbGxlY3Rpb259PigpCgogICAgLy8gSXRlcmF0ZSBvdmVyIGVhY2ggcHVibGljIHBhdGgKICAgIGFjY291bnQuc3RvcmFnZS5mb3JFYWNoU3RvcmVkKGZ1biAocGF0aDogU3RvcmFnZVBhdGgsIHR5cGU6IFR5cGUpOiBCb29sIHsKICAgICAgICAvLyBSZXR1cm4gZWFybHkgaWYgdGhlIGNvbGxlY3Rpb24gaXMgYnJva2VuIG9yIGlzIG5vdCB0aGUgdHlwZSB3ZSdyZSBsb29raW5nIGZvcgogICAgICAgIGlmIHR5cGUuaXNSZWNvdmVyZWQgfHwgKCF0eXBlLmlzSW5zdGFuY2UoY29sbGVjdGlvblR5cGUpICYmICF0eXBlLmlzU3VidHlwZShvZjogY29sbGVjdGlvblR5cGUpKSB7CiAgICAgICAgICAgIHJldHVybiB0cnVlCiAgICAgICAgfQogICAgICAgIGlmIGxldCBjb2xsZWN0aW9uUmVmID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzwme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0+KGZyb206IHBhdGgpIHsKICAgICAgICAgICAgLy8gUmV0dXJuIGVhcmx5IGlmIG5vIFJlc29sdmVyIGZvdW5kIGluIHRoZSBDb2xsZWN0aW9uCiAgICAgICAgICAgIGxldCBpZHM6IFtVSW50NjRdPSBjb2xsZWN0aW9uUmVmLmdldElEcygpCiAgICAgICAgICAgIGRhdGEuaW5zZXJ0KGtleTogdHlwZS5pZGVudGlmaWVyLCBpZHMubGVuZ3RoKQogICAgICAgIH0KICAgICAgICByZXR1cm4gdHJ1ZQogICAgfSkKICAgIHJldHVybiBkYXRhCn0\u003d", - "getNFTCollection": "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\u003d\u003d", - "getNFTDisplays": "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", - "getNFTMetadataViews": "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\u003d\u003d", - "getUserCollections": "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\u003d", - "getUserCollectionsPage": "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", - "sendNbaNFT": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgc2VuZE5iYU5GVCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCgppbXBvcnQgPE5GVD4gZnJvbSA8TkZUQWRkcmVzcz4KCnRyYW5zYWN0aW9uKHJlY2lwaWVudEFkZHI6IEFkZHJlc3MsIHdpdGhkcmF3SUQ6IFVJbnQ2NCkgewogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSwgQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgLy8gZ2V0IHRoZSByZWNpcGllbnRzIHB1YmxpYyBhY2NvdW50IG9iamVjdAogICAgICAgIGxldCByZWNpcGllbnQgPSBnZXRBY2NvdW50KHJlY2lwaWVudEFkZHIpCiAgICAgICAgLy8gYm9ycm93IGEgcmVmZXJlbmNlIHRvIHRoZSBzaWduZXInJ3MgTkZUIGNvbGxlY3Rpb24KICAgICAgICBsZXQgY29sbGVjdGlvblJlZiA9IHNpZ25lci5zdG9yYWdlCiAgICAgICAgLmJvcnJvdzxhdXRoKE5vbkZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7Tm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9ufT4oZnJvbTogL3N0b3JhZ2UvTW9tZW50Q29sbGVjdGlvbikKICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgb3duZXInJ3MgY29sbGVjdGlvbiIpCiAgICAgICAgbGV0IHNlbmRlclJlZiA9IHNpZ25lcgogICAgICAgIC5jYXBhYmlsaXRpZXMKICAgICAgICAuYm9ycm93PCZ7Tm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9uUHVibGljfT4oL3B1YmxpYy9Nb21lbnRDb2xsZWN0aW9uKQogICAgICAgIC8vIGJvcnJvdyBhIHB1YmxpYyByZWZlcmVuY2UgdG8gdGhlIHJlY2VpdmVycyBjb2xsZWN0aW9uCiAgICAgICAgbGV0IHJlY2lwaWVudFJlZiA9IHJlY2lwaWVudAogICAgICAgIC5jYXBhYmlsaXRpZXMKICAgICAgICAuYm9ycm93PCZ7VG9wU2hvdC5Nb21lbnRDb2xsZWN0aW9uUHVibGljfT4oL3B1YmxpYy9Nb21lbnRDb2xsZWN0aW9uKSA/PyBwYW5pYygiVW5hYmxlIHRvIGJvcnJvdyByZWNlaXZlciByZWZlcmVuY2UiKQogICAgICAgIAogICAgICAgIC8vIHdpdGhkcmF3IHRoZSBORlQgZnJvbSB0aGUgb3duZXInJ3MgY29sbGVjdGlvbgogICAgICAgIGxldCBuZnQgPC0gY29sbGVjdGlvblJlZi53aXRoZHJhdyh3aXRoZHJhd0lEOiB3aXRoZHJhd0lEKQogICAgICAgIC8vIERlcG9zaXQgdGhlIE5GVCBpbiB0aGUgcmVjaXBpZW50JydzIGNvbGxlY3Rpb24KICAgICAgICByZWNpcGllbnRSZWYhLmRlcG9zaXQodG9rZW46IDwtbmZ0KQogICAgfQp9", - "sendNbaNFTV3": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgc2VuZE5iYU5GVFYzIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4MWQ3ZTU3YWE1NTgxNzQ0OAoKaW1wb3J0IFN0b3JhZ2VSZW50IGZyb20gMHg3MDdhZGJhZDE0MjhjNjI0CgoKaW1wb3J0IDxORlQ+IGZyb20gPE5GVEFkZHJlc3M+Cgp0cmFuc2FjdGlvbihyZWNpcGllbnRBZGRyOiBBZGRyZXNzLCB3aXRoZHJhd0lEOiBVSW50NjQpIHsKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgIC8vIGdldCB0aGUgcmVjaXBpZW50cyBwdWJsaWMgYWNjb3VudCBvYmplY3QKICAgICAgICBsZXQgcmVjaXBpZW50ID0gZ2V0QWNjb3VudChyZWNpcGllbnRBZGRyKQogICAgICAgIC8vIGJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgc2lnbmVyJydzIE5GVCBjb2xsZWN0aW9uCiAgICAgICAgbGV0IGNvbGxlY3Rpb25SZWYgPSBzaWduZXIuc3RvcmFnZQogICAgICAgIC5ib3Jyb3c8YXV0aChOb25GdW5naWJsZVRva2VuLldpdGhkcmF3KSAme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0+KGZyb206IC9zdG9yYWdlL01vbWVudENvbGxlY3Rpb24pCiAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgYSByZWZlcmVuY2UgdG8gdGhlIG93bmVyJydzIGNvbGxlY3Rpb24iKQogICAgICAgIGxldCBzZW5kZXJSZWYgPSBzaWduZXIKICAgICAgICAuY2FwYWJpbGl0aWVzCiAgICAgICAgLmJvcnJvdzwme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvblB1YmxpY30+KC9wdWJsaWMvTW9tZW50Q29sbGVjdGlvbikKICAgICAgICAvLyBib3Jyb3cgYSBwdWJsaWMgcmVmZXJlbmNlIHRvIHRoZSByZWNlaXZlcnMgY29sbGVjdGlvbgogICAgICAgIGxldCByZWNpcGllbnRSZWYgPSByZWNpcGllbnQKICAgICAgICAuY2FwYWJpbGl0aWVzCiAgICAgICAgLmJvcnJvdzwme1RvcFNob3QuTW9tZW50Q29sbGVjdGlvblB1YmxpY30+KC9wdWJsaWMvTW9tZW50Q29sbGVjdGlvbikgPz8gcGFuaWMoIlVuYWJsZSB0byBib3Jyb3cgcmVjZWl2ZXIgcmVmZXJlbmNlIikKICAgICAgICAKICAgICAgICAvLyB3aXRoZHJhdyB0aGUgTkZUIGZyb20gdGhlIG93bmVyJydzIGNvbGxlY3Rpb24KICAgICAgICBsZXQgbmZ0IDwtIGNvbGxlY3Rpb25SZWYud2l0aGRyYXcod2l0aGRyYXdJRDogd2l0aGRyYXdJRCkKICAgICAgICAvLyBEZXBvc2l0IHRoZSBORlQgaW4gdGhlIHJlY2lwaWVudCcncyBjb2xsZWN0aW9uCiAgICAgICAgcmVjaXBpZW50UmVmIS5kZXBvc2l0KHRva2VuOiA8LW5mdCkKICAgICAgICBTdG9yYWdlUmVudC50cnlSZWZpbGwocmVjaXBpZW50QWRkcikKICAgIH0KfQ\u003d\u003d", - "sendNFT": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgc2VuZE5GVCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCmltcG9ydCA8TkZUPiBmcm9tIDxORlRBZGRyZXNzPgoKLy8gVGhpcyB0cmFuc2FjdGlvbiBpcyBmb3IgdHJhbnNmZXJyaW5nIGFuZCBORlQgZnJvbQovLyBvbmUgYWNjb3VudCB0byBhbm90aGVyCgp0cmFuc2FjdGlvbihyZWNpcGllbnRBZGRyOiBBZGRyZXNzLCB3aXRoZHJhd0lEOiBVSW50NjQpIHsKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChTdG9yYWdlLCBCb3Jyb3dWYWx1ZSkgJkFjY291bnQpIHsKICAgICAgICAvLyBnZXQgdGhlIHJlY2lwaWVudHMgcHVibGljIGFjY291bnQgb2JqZWN0CiAgICAgICAgbGV0IHJlY2lwaWVudCA9IGdldEFjY291bnQocmVjaXBpZW50QWRkcikKCiAgICAgICAgLy8gYm9ycm93IGEgcmVmZXJlbmNlIHRvIHRoZSBzaWduZXIncyBORlQgY29sbGVjdGlvbgogICAgICAgIGxldCBjb2xsZWN0aW9uUmVmID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoTm9uRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntOb25GdW5naWJsZVRva2VuLlByb3ZpZGVyfT4oZnJvbTogPENvbGxlY3Rpb25TdG9yYWdlUGF0aD4pCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IGEgcmVmZXJlbmNlIHRvIHRoZSBvd25lcidzIGNvbGxlY3Rpb24iKQoKICAgICAgICAvLyBib3Jyb3cgYSBwdWJsaWMgcmVmZXJlbmNlIHRvIHRoZSByZWNlaXZlcnMgY29sbGVjdGlvbgogICAgICAgIGxldCBkZXBvc2l0UmVmID0gcmVjaXBpZW50CiAgICAgICAgICAgIC5jYXBhYmlsaXRpZXMKICAgICAgICAgICAgLmJvcnJvdzwme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0+KDxDb2xsZWN0aW9uUHVibGljUGF0aD4pCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IGEgcmVmZXJlbmNlIHRvIHRoZSByZWNlaXZlcidzIGNvbGxlY3Rpb24iKQoKICAgICAgICAvLyB3aXRoZHJhdyB0aGUgTkZUIGZyb20gdGhlIG93bmVyJ3MgY29sbGVjdGlvbgogICAgICAgIGxldCBuZnQgPC0gY29sbGVjdGlvblJlZi53aXRoZHJhdyh3aXRoZHJhd0lEOiB3aXRoZHJhd0lEKQoKICAgICAgICAvLyBEZXBvc2l0IHRoZSBORlQgaW4gdGhlIHJlY2lwaWVudCdzIGNvbGxlY3Rpb24KICAgICAgICBkZXBvc2l0UmVmLmRlcG9zaXQodG9rZW46IDwtbmZ0KQoKICAgIH0KfQ\u003d\u003d", - "sendNFTV3": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgc2VuZE5GVFYzIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4MWQ3ZTU3YWE1NTgxNzQ0OAoKaW1wb3J0IFN0b3JhZ2VSZW50IGZyb20gMHg3MDdhZGJhZDE0MjhjNjI0CgppbXBvcnQgPE5GVD4gZnJvbSA8TkZUQWRkcmVzcz4KCi8vIFRoaXMgdHJhbnNhY3Rpb24gaXMgZm9yIHRyYW5zZmVycmluZyBhbmQgTkZUIGZyb20KLy8gb25lIGFjY291bnQgdG8gYW5vdGhlcgoKdHJhbnNhY3Rpb24ocmVjaXBpZW50QWRkcjogQWRkcmVzcywgd2l0aGRyYXdJRDogVUludDY0KSB7CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSwgQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgLy8gZ2V0IHRoZSByZWNpcGllbnRzIHB1YmxpYyBhY2NvdW50IG9iamVjdAogICAgICAgIGxldCByZWNpcGllbnQgPSBnZXRBY2NvdW50KHJlY2lwaWVudEFkZHIpCgogICAgICAgIC8vIGJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgc2lnbmVyJ3MgTkZUIGNvbGxlY3Rpb24KICAgICAgICBsZXQgY29sbGVjdGlvblJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKE5vbkZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7Tm9uRnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+KGZyb206IDxDb2xsZWN0aW9uU3RvcmFnZVBhdGg+KQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgb3duZXIncyBjb2xsZWN0aW9uIikKCiAgICAgICAgLy8gYm9ycm93IGEgcHVibGljIHJlZmVyZW5jZSB0byB0aGUgcmVjZWl2ZXJzIGNvbGxlY3Rpb24KICAgICAgICBsZXQgZGVwb3NpdFJlZiA9IHJlY2lwaWVudAogICAgICAgICAgICAuY2FwYWJpbGl0aWVzCiAgICAgICAgICAgIC5ib3Jyb3c8JntOb25GdW5naWJsZVRva2VuLkNvbGxlY3Rpb259Pig8Q29sbGVjdGlvblB1YmxpY1BhdGg+KQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgcmVjZWl2ZXIncyBjb2xsZWN0aW9uIikKCiAgICAgICAgLy8gd2l0aGRyYXcgdGhlIE5GVCBmcm9tIHRoZSBvd25lcidzIGNvbGxlY3Rpb24KICAgICAgICBsZXQgbmZ0IDwtIGNvbGxlY3Rpb25SZWYud2l0aGRyYXcod2l0aGRyYXdJRDogd2l0aGRyYXdJRCkKCiAgICAgICAgLy8gRGVwb3NpdCB0aGUgTkZUIGluIHRoZSByZWNpcGllbnQncyBjb2xsZWN0aW9uCiAgICAgICAgZGVwb3NpdFJlZi5kZXBvc2l0KHRva2VuOiA8LW5mdCkKICAgICAgICBTdG9yYWdlUmVudC50cnlSZWZpbGwocmVjaXBpZW50QWRkcikKCiAgICB9Cn0\u003d" - }, - "contract": { - "getContractByName": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Q29udHJhY3RCeU5hbWUgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MsIGNvbnRyYWN0TmFtZTogU3RyaW5nKTogU3RyaW5nPyB7CiAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgbGV0IGRlcGxveWVkQ29udHJhY3QgPSBhY2NvdW50LmNvbnRyYWN0cy5nZXQobmFtZTogY29udHJhY3ROYW1lKQoKICByZXR1cm4gU3RyaW5nLmZyb21VVEY4KGRlcGxveWVkQ29udHJhY3Q/LmNvZGUhKQp9", - "getContractNames": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Q29udHJhY3ROYW1lcyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6ICZbU3RyaW5nXSB7CiAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgcmV0dXJuIGFjY291bnQuY29udHJhY3RzLm5hbWVzCn0\u003d" - }, - "evm": { - "call": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY2FsbCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4ZTQ2N2I5ZGQxMWZhMDBkZgoKCmFjY2VzcyhhbGwpCmZ1biBtYWluKGhleEVuY29kZWREYXRhOiBTdHJpbmcsIGhleEVuY29kZWRBZGRyZXNzOiBTdHJpbmcpOiBTdHJpbmcgewogICAgbGV0IGFjY291bnQgPSBnZXRBdXRoQWNjb3VudDxhdXRoKFN0b3JhZ2UpICZBY2NvdW50PihBZGRyZXNzKDB4Q09BKSkKCiAgICBsZXQgY29hID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzxhdXRoKEVWTS5DYWxsKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KAogICAgICAgIGZyb206IC9zdG9yYWdlL2V2bQogICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQogICAgbGV0IGFkZHJlc3NCeXRlcyA9IGhleEVuY29kZWRBZGRyZXNzLmRlY29kZUhleCgpLnRvQ29uc3RhbnRTaXplZDxbVUludDg7IDIwXT4oKSEKCiAgICBsZXQgdHhSZXN1bHQgPSBjb2EuY2FsbCgKICAgICAgICB0bzogRVZNLkVWTUFkZHJlc3MoYnl0ZXM6IGFkZHJlc3NCeXRlcyksCiAgICAgICAgZGF0YTogaGV4RW5jb2RlZERhdGEuZGVjb2RlSGV4KCksCiAgICAgICAgZ2FzTGltaXQ6IDE1MDAwMDAwLCAvLyB0b2RvIG1ha2UgaXQgY29uZmlndXJhYmxlLCBtYXggZm9yIG5vdwogICAgICAgIHZhbHVlOiBFVk0uQmFsYW5jZShhdHRvZmxvdzogMCkKICAgICkKCiAgICBhc3NlcnQoCiAgICAgICAgdHhSZXN1bHQuc3RhdHVzID09IEVWTS5TdGF0dXMuZmFpbGVkIHx8IHR4UmVzdWx0LnN0YXR1cyA9PSBFVk0uU3RhdHVzLnN1Y2Nlc3NmdWwsCiAgICAgICAgbWVzc2FnZTogImV2bV9lcnJvcj0iLmNvbmNhdCh0eFJlc3VsdC5lcnJvck1lc3NhZ2UpLmNvbmNhdCgiXG4iKQogICAgKQoKICAgIHJldHVybiBTdHJpbmcuZW5jb2RlSGV4KGNhbGxSZXN1bHQuZGF0YSkKfQo\u003d", - "callContract": "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\u003d\u003d", - "callContractV2": "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", - "checkCoaLink": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY2hlY2tDb2FMaW5rIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRVZNIGZyb20gMHhlNDY3YjlkZDExZmEwMGRmCgoKLy8vIFJldHVybnMgd2hldGhlciBhIENPQSBpcyBzdG9yZWQgYW5kIGl0cyBwdWJsaWMgY2FwYWJpbGl0eSBpcyBwdWJsaXNoZWQKLy8vCi8vLyBAcGFyYW0gZmxvd0FkZHJlc3M6IFRoZSBGbG93IGFkZHJlc3MgdG8gY2hlY2sgZm9yIGEgQ09BCi8vLwovLy8gQHJldHVybiBCb29sOiBXaGV0aGVyIGEgQ09BIGlzIHN0b3JlZCBhbmQgaXRzIHB1YmxpYyBjYXBhYmlsaXR5IGlzIHB1Ymxpc2hlZCwgbmlsIGlmIG5vIENPQSBpcyBzdG9yZWQKLy8vCmFjY2VzcyhhbGwpIGZ1biBtYWluKGZsb3dBZGRyZXNzOiBBZGRyZXNzKTogQm9vbD8gewogICAgLy8gQm9ycm93IHRoZSBDT0EgdG8gY2hlY2sgaWYgb25lIGlzIHN0b3JlZAogICAgaWYgbGV0IGFkZHJlc3M6IEVWTS5FVk1BZGRyZXNzID0gZ2V0QXV0aEFjY291bnQ8YXV0aChCb3Jyb3dWYWx1ZSkgJkFjY291bnQ+KGZsb3dBZGRyZXNzKQogICAgICAgIC5zdG9yYWdlLmJvcnJvdzwmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KGZyb206IC9zdG9yYWdlL2V2bSk/LmFkZHJlc3MoKSB7CiAgICAgICAgLy8gQ09BIGZvdW5kIC0gY2hlY2sgaWYgdGhlIHB1YmxpYyBjYXBhYmlsaXR5IGlzIHB1Ymxpc2hlZAogICAgICAgIHJldHVybiBnZXRBY2NvdW50KGZsb3dBZGRyZXNzKS5jYXBhYmlsaXRpZXMuYm9ycm93PCZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oL3B1YmxpYy9ldm0pICE9IG5pbAogICAgfQogICAgLy8gTm8gQ09BIGZvdW5kIC0gcmV0dXJuIG5pbAogICAgcmV0dXJuIG5pbAp9", - "coaLink": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY29hTGluayAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IENyeXB0bwppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKaW1wb3J0IEZsb3dUb2tlbiBmcm9tIDB4MTY1NDY1MzM5OTA0MGE2MQoKaW1wb3J0IEVWTSBmcm9tIDB4ZTQ2N2I5ZGQxMWZhMDBkZgoKCi8vLyBUaGlzIHRyYW5zYWN0aW9uIHB1Ymxpc2hlcyBhIHB1YmxpYyAqKnVuZW50aXRsZWQqKiBjYXBhYmlsaXR5IGZvciB0aGUgQ09BIHN0b3JlZCBpbiB0aGUgc2lnbmluZyBhY2NvdW50J3Mgc3RvcmFnZQovLy8gd2hlcmUgYSBDT0EgaGFzIGFscmVhZHkgYmVlbiBzdG9yZWQuCi8vLwp0cmFuc2FjdGlvbiB7CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoQm9ycm93VmFsdWUsIFN0b3JhZ2VDYXBhYmlsaXRpZXMsIFB1Ymxpc2hDYXBhYmlsaXR5LCBVbnB1Ymxpc2hDYXBhYmlsaXR5KSAmQWNjb3VudCkgewogICAgICAgIC8vIEVuc3VyZSBhIENPQSBpcyBzdG9yZWQKICAgICAgICBsZXQgY29hUGF0aCA9IC9zdG9yYWdlL2V2bQogICAgICAgIGxldCBjb2EgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChFVk0uQ2FsbCkgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50Pihmcm9tOiAvc3RvcmFnZS9ldm0pCiAgICAgICAgICAgID8/IHBhbmljKAogICAgICAgICAgICAgICAgIkNvdWxkIG5vdCBmaW5kIENPQSBpbiBzdG9yYWdlIGF0IHBhdGggIi5jb25jYXQoY29hUGF0aC50b1N0cmluZygpKQogICAgICAgICAgICAgICAgLmNvbmNhdCgiLiBNYWtlIHN1cmUgdGhlIHNpZ25pbmcgYWNjb3VudCBoYXMgaW5pdGlhbGl6ZWQgYSBDT0EgYXQgdGhlIGV4cGVjdGVkIHBhdGguIikKICAgICAgICAgICAgKQoKICAgICAgICAvLyBQdWJsaXNoIGEgcHVibGljICoqdW5lbnRpdGxlZCoqIGNhcGFiaWxpdHkKICAgICAgICBsZXQgY29hUHVibGljUGF0aCA9IC9wdWJsaWMvZXZtCiAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy51bnB1Ymxpc2goY29hUHVibGljUGF0aCkKICAgICAgICBsZXQgY29hQ2FwYWJpbGl0eSA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTwmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KGNvYVBhdGgpCiAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5wdWJsaXNoKGNvYUNhcGFiaWxpdHksIGF0OiBjb2FQdWJsaWNQYXRoKQogICAgfQp9", - "createCoa": "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", - "createCoaEmpty": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY3JlYXRlQ29hRW1wdHkgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHgxNjU0NjUzMzk5MDQwYTYxCgppbXBvcnQgRVZNIGZyb20gMHhlNDY3YjlkZDExZmEwMGRmCgoKCi8vLyBDcmVhdGVzIGEgQ09BIGFuZCBzYXZlcyBpdCBpbiB0aGUgc2lnbmVyJ3MgRmxvdyBhY2NvdW50ICYgcGFzc2luZyB0aGUgZ2l2ZW4gdmFsdWUgb2YgRmxvdyBpbnRvIEZsb3dFVk0KdHJhbnNhY3Rpb24oKSB7CiAgICBsZXQgYXV0aDogYXV0aChJc3N1ZVN0b3JhZ2VDYXBhYmlsaXR5Q29udHJvbGxlciwgSXNzdWVTdG9yYWdlQ2FwYWJpbGl0eUNvbnRyb2xsZXIsIFB1Ymxpc2hDYXBhYmlsaXR5LCBTYXZlVmFsdWUsIFVucHVibGlzaENhcGFiaWxpdHkpICZBY2NvdW50CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoQm9ycm93VmFsdWUsIElzc3VlU3RvcmFnZUNhcGFiaWxpdHlDb250cm9sbGVyLCBQdWJsaXNoQ2FwYWJpbGl0eSwgU2F2ZVZhbHVlLCBVbnB1Ymxpc2hDYXBhYmlsaXR5KSAmQWNjb3VudCkgewogICAgICAgIGxldCB2YXVsdFJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZGbG93VG9rZW4uVmF1bHQ+KAogICAgICAgICAgICAgICAgZnJvbTogL3N0b3JhZ2UvZmxvd1Rva2VuVmF1bHQKICAgICAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIG93bmVyJ3MgVmF1bHQhIikKICAgICAgICBzZWxmLmF1dGggPSBzaWduZXIKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBsZXQgY29hIDwtIEVWTS5jcmVhdGVDYWRlbmNlT3duZWRBY2NvdW50KCkKICAgICAgICBsZXQgc3RvcmFnZVBhdGggPSBTdG9yYWdlUGF0aChpZGVudGlmaWVyOiAiZXZtIikhCiAgICAgICAgbGV0IHB1YmxpY1BhdGggPSBQdWJsaWNQYXRoKGlkZW50aWZpZXI6ICJldm0iKSEKICAgICAgICBzZWxmLmF1dGguc3RvcmFnZS5zYXZlPEBFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oPC1jb2EsIHRvOiBzdG9yYWdlUGF0aCkKICAgICAgICBsZXQgYWRkcmVzc2FibGVDYXAgPSBzZWxmLmF1dGguY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8JkVWTS5DYWRlbmNlT3duZWRBY2NvdW50PihzdG9yYWdlUGF0aCkKICAgICAgICBzZWxmLmF1dGguY2FwYWJpbGl0aWVzLnVucHVibGlzaChwdWJsaWNQYXRoKQogICAgICAgIHNlbGYuYXV0aC5jYXBhYmlsaXRpZXMucHVibGlzaChhZGRyZXNzYWJsZUNhcCwgYXQ6IHB1YmxpY1BhdGgpCiAgICB9Cn0\u003d", - "deployContract": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZGVwbG95Q29udHJhY3QgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBFVk0gZnJvbSAweGU0NjdiOWRkMTFmYTAwZGYKCgoKdHJhbnNhY3Rpb24oY29kZTogU3RyaW5nKSB7CiAgICBsZXQgY29hOiBhdXRoKEVWTS5EZXBsb3kpICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudAoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgc2VsZi5jb2EgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChFVk0uRGVwbG95KSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KAogICAgICAgIGZyb206IC9zdG9yYWdlL2V2bSkgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgcmVmZXJlbmNlIHRvIHRoZSBDT0EhIikKCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgIHNlbGYuY29hLmRlcGxveShjb2RlOiBjb2RlLmRlY29kZUhleCgpLCAgZ2FzTGltaXQ6IDE1MDAwMDAwLCB2YWx1ZTogRVZNLkJhbGFuY2UoYXR0b2Zsb3c6IDApKQogICAgfQp9Cg\u003d\u003d", - "estimateGas": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZXN0aW1hdGVHYXMgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBFVk0gZnJvbSAweGU0NjdiOWRkMTFmYTAwZGYKCgphY2Nlc3MoYWxsKQpmdW4gbWFpbihoZXhFbmNvZGVkVHg6IFN0cmluZywgYWRkcmVzczogQWRkcmVzcyk6IFtVSW50NjQ7IDJdIHsKICAgIGxldCBhY2NvdW50ID0gZ2V0QXV0aEFjY291bnQ8YXV0aChTdG9yYWdlKSAmQWNjb3VudD4oYWRkcmVzcykKCiAgICBsZXQgY29hID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzwmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KAogICAgICAgIGZyb206IC9zdG9yYWdlL2V2bQogICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQogICAgbGV0IHR4UmVzdWx0ID0gRVZNLnJ1bih0eDogaGV4RW5jb2RlZFR4LmRlY29kZUhleCgpLCBjb2luYmFzZTogY29hLmFkZHJlc3MoKSkKCiAgICBhc3NlcnQoCiAgICAgICAgdHhSZXN1bHQuc3RhdHVzID09IEVWTS5TdGF0dXMuZmFpbGVkIHx8IHR4UmVzdWx0LnN0YXR1cyA9PSBFVk0uU3RhdHVzLnN1Y2Nlc3NmdWwsCiAgICAgICAgbWVzc2FnZTogImV2bV9lcnJvcj0iLmNvbmNhdCh0eFJlc3VsdC5lcnJvck1lc3NhZ2UpLmNvbmNhdCgiXG4iKQogICAgKQoKICAgIHJldHVybiBbdHhSZXN1bHQuZXJyb3JDb2RlLCB0eFJlc3VsdC5nYXNVc2VkXQp9Cg\u003d\u003d", - "fundCoa": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZnVuZENvYSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDE2NTQ2NTMzOTkwNDBhNjEKCmltcG9ydCBFVk0gZnJvbSAweGU0NjdiOWRkMTFmYTAwZGYKCgp0cmFuc2FjdGlvbihhbW91bnQ6IFVGaXg2NCkgewogICAgbGV0IHNlbnRWYXVsdDogQEZsb3dUb2tlbi5WYXVsdAogICAgbGV0IGF1dGg6IGF1dGgoU3RvcmFnZSkgJkFjY291bnQKICAgIGxldCBjb2E6ICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudAoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IHZhdWx0UmVmID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJkZsb3dUb2tlbi5WYXVsdD4oCiAgICAgICAgICAgIGZyb206IC9zdG9yYWdlL2Zsb3dUb2tlblZhdWx0CiAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIG93bmVyJ3MgVmF1bHQhIikKCgogICAgICAgIGxldCBjb2EgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8JkVWTS5DYWRlbmNlT3duZWRBY2NvdW50PigKICAgICAgICAgICAgZnJvbTogL3N0b3JhZ2UvZXZtCiAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQoKICAgICAgICBzZWxmLnNlbnRWYXVsdCA8LSB2YXVsdFJlZi53aXRoZHJhdyhhbW91bnQ6IGFtb3VudCkgYXMhIEBGbG93VG9rZW4uVmF1bHQKICAgICAgICBzZWxmLmF1dGggPSBzaWduZXIKICAgICAgICBzZWxmLmNvYSA9IGNvYQogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIHNlbGYuY29hLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKICAgIH0KfQo\u003d", - "fundEvmAddr": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZnVuZEV2bUFkZHIgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHgxNjU0NjUzMzk5MDQwYTYxCgppbXBvcnQgRVZNIGZyb20gMHhlNDY3YjlkZDExZmEwMGRmCgoKdHJhbnNhY3Rpb24oZXZtQWRkcjogU3RyaW5nLCBhbW91bnQ6IFVGaXg2NCkgewoKICAgIC8vIFRoZSBWYXVsdCByZXNvdXJjZSB0aGF0IGhvbGRzIHRoZSB0b2tlbnMgdGhhdCBhcmUgYmVpbmcgdHJhbnNmZXJlZAogICAgbGV0IHNlbnRWYXVsdDogQHtGdW5naWJsZVRva2VuLlZhdWx0fQoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgICAvLyBHZXQgYSByZWZlcmVuY2UgdG8gdGhlIHNpZ25lcidzIHN0b3JlZCB2YXVsdAogICAgICAgIGxldCB2YXVsdFJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICY8VG9rZW4+LlZhdWx0Pihmcm9tOiA8VG9rZW5TdG9yYWdlUGF0aD4pCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IHJlZmVyZW5jZSB0byB0aGUgb3duZXIncyBWYXVsdCEiKQoKICAgICAgICAvLyBXaXRoZHJhdyB0b2tlbnMgZnJvbSB0aGUgc2lnbmVyJ3Mgc3RvcmVkIHZhdWx0CiAgICAgICAgc2VsZi5zZW50VmF1bHQgPC0gdmF1bHRSZWYud2l0aGRyYXcoYW1vdW50OiBhbW91bnQpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgLy8gR2V0IHRoZSByZWNpcGllbnQncyBwdWJsaWMgYWNjb3VudCBvYmplY3QKICAgICAgICBsZXQgcmVjaXBpZW50QWNjb3VudCA9IGdldEFjY291bnQocmVjaXBpZW50KQoKICAgICAgICAvLyBHZXQgYSByZWZlcmVuY2UgdG8gdGhlIHJlY2lwaWVudCdzIFJlY2VpdmVyCiAgICAgICAgbGV0IHJlY2VpdmVyUmVmID0gcmVjaXBpZW50QWNjb3VudC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5SZWNlaXZlcn0+KDxUb2tlblJlY2VpdmVyUGF0aD4pIQogICAgICAgICAgICAKICAgICAgICAvLyBEZXBvc2l0IHRoZSB3aXRoZHJhd24gdG9rZW5zIGluIHRoZSByZWNpcGllbnQncyByZWNlaXZlcgogICAgICAgIHJlY2VpdmVyUmVmLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKICAgIH0KfQ\u003d\u003d", - "getAddr": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QWRkciAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4ZTQ2N2I5ZGQxMWZhMDBkZgoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGZsb3dBZGRyZXNzOiBBZGRyZXNzKTogU3RyaW5nPyB7CiAgICBpZiBsZXQgYWRkcmVzczogRVZNLkVWTUFkZHJlc3MgPSBnZXRBdXRoQWNjb3VudDxhdXRoKEJvcnJvd1ZhbHVlKSAmQWNjb3VudD4oZmxvd0FkZHJlc3MpCiAgICAgICAgLnN0b3JhZ2UuYm9ycm93PCZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oZnJvbTogL3N0b3JhZ2UvZXZtKT8uYWRkcmVzcygpIHsKICAgICAgICBsZXQgYnl0ZXM6IFtVSW50OF0gPSBbXQogICAgICAgIGZvciBieXRlIGluIGFkZHJlc3MuYnl0ZXMgewogICAgICAgICAgICBieXRlcy5hcHBlbmQoYnl0ZSkKICAgICAgICB9CiAgICAgICAgcmV0dXJuIFN0cmluZy5lbmNvZGVIZXgoYnl0ZXMpCiAgICB9CiAgICByZXR1cm4gbmlsCn0\u003d", - "getBalance": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QmFsYW5jZSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4ZTQ2N2I5ZGQxMWZhMDBkZgoKCmFjY2VzcyhhbGwpCmZ1biBtYWluKGhleEVuY29kZWRBZGRyZXNzOiBTdHJpbmcpOiBVSW50IHsKICAgIGxldCBhZGRyZXNzQnl0ZXMgPSBoZXhFbmNvZGVkQWRkcmVzcy5kZWNvZGVIZXgoKS50b0NvbnN0YW50U2l6ZWQ8W1VJbnQ4OyAyMF0+KCkhCiAgICBsZXQgYWRkcmVzcyA9IEVWTS5FVk1BZGRyZXNzKGJ5dGVzOiBhZGRyZXNzQnl0ZXMpCgogICAgcmV0dXJuIGFkZHJlc3MuYmFsYW5jZSgpLmluQXR0b0ZMT1coKQp9Cg\u003d\u003d", - "getCoaAddr": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Q29hQWRkciAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4ZTQ2N2I5ZGQxMWZhMDBkZgoKCmFjY2VzcyhhbGwpCmZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBTdHJpbmcgewogICAgbGV0IGFjY291bnQgPSBnZXRBdXRoQWNjb3VudDxhdXRoKFN0b3JhZ2UpICZBY2NvdW50PihhZGRyZXNzKQoKICAgIGxldCBjb2EgPSBhY2NvdW50LnN0b3JhZ2UuYm9ycm93PCZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oCiAgICAgICAgZnJvbTogL3N0b3JhZ2UvZXZtCiAgICApCgogICAgaWYgY29hID09IG5pbCB7IAogICAgICAgIHJldHVybiAiIgogICAgfSBlbHNlIHsKICAgICAgICBsZXQgY29hQWRkciA9IGNvYT8uYWRkcmVzcygpIAoKICAgICAgICBsZXQgYWRkckJ5dGU6IFtVSW50OF0gPSBbXQoKICAgICAgICBmb3IgYnl0ZSBpbiBjb2FBZGRyPy5ieXRlcyEgewogICAgICAgICAgICBhZGRyQnl0ZS5hcHBlbmQoYnl0ZSkKICAgICAgICB9CgogICAgICAgIHJldHVybiBTdHJpbmcuZW5jb2RlSGV4KGFkZHJCeXRlKQogICAgfQp9Cg\u003d\u003d", - "getCoaBalance": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Q29hQmFsYW5jZSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4ZTQ2N2I5ZGQxMWZhMDBkZgoKCmFjY2VzcyhhbGwpCmZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBVRml4NjQgewogICAgIGxldCBhY2NvdW50ID0gZ2V0QXV0aEFjY291bnQ8YXV0aChTdG9yYWdlKSAmQWNjb3VudD4oYWRkcmVzcykKCiAgICBsZXQgY29hID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzwmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KAogICAgICAgIGZyb206IC9zdG9yYWdlL2V2bQogICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQogICAgCiAgICByZXR1cm4gY29hLmJhbGFuY2UoKS5pbkZMT1coKQp9Cg\u003d\u003d", - "getCode": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Q29kZSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4ZTQ2N2I5ZGQxMWZhMDBkZgoKCmFjY2VzcyhhbGwpCmZ1biBtYWluKGhleEVuY29kZWRBZGRyZXNzOiBTdHJpbmcpOiBTdHJpbmcgewogICAgbGV0IGFkZHJlc3NCeXRlcyA9IGhleEVuY29kZWRBZGRyZXNzLmRlY29kZUhleCgpLnRvQ29uc3RhbnRTaXplZDxbVUludDg7IDIwXT4oKSEKICAgIGxldCBhZGRyZXNzID0gRVZNLkVWTUFkZHJlc3MoYnl0ZXM6IGFkZHJlc3NCeXRlcykKCiAgICByZXR1cm4gU3RyaW5nLmVuY29kZUhleChhZGRyZXNzLmNvZGUoKSkKfQo\u003d", - "getNonce": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Tm9uY2UgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBFVk0gZnJvbSAweGU0NjdiOWRkMTFmYTAwZGYKCgphY2Nlc3MoYWxsKQpmdW4gbWFpbihoZXhFbmNvZGVkQWRkcmVzczogU3RyaW5nKTogVUludDY0IHsKICAgIGxldCBhZGRyZXNzQnl0ZXMgPSBoZXhFbmNvZGVkQWRkcmVzcy5kZWNvZGVIZXgoKS50b0NvbnN0YW50U2l6ZWQ8W1VJbnQ4OyAyMF0+KCkhCiAgICBsZXQgYWRkcmVzcyA9IEVWTS5FVk1BZGRyZXNzKGJ5dGVzOiBhZGRyZXNzQnl0ZXMpCgogICAgcmV0dXJuIGFkZHJlc3Mubm9uY2UoKQp9Cg\u003d\u003d", - "newAccountAndCoa": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgbmV3QWNjb3VudEFuZENvYSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IENyeXB0bwppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKaW1wb3J0IEZsb3dUb2tlbiBmcm9tIDB4MTY1NDY1MzM5OTA0MGE2MQoKaW1wb3J0IEVWTSBmcm9tIDB4ZTQ2N2I5ZGQxMWZhMDBkZgoKCnRyYW5zYWN0aW9uKHB1YmxpY0tleTogU3RyaW5nLCBzaWduYXR1cmVBbGdvcml0aG06IFVJbnQ4LCBoYXNoQWxnb3JpdGhtOiBVSW50OCwgd2VpZ2h0OiBVRml4NjQpIHsKICAgIGxldCBzZW50VmF1bHQ6IEBGbG93VG9rZW4uVmF1bHQKICAgIGxldCBhdXRoOiBhdXRoKFN0b3JhZ2UpICZBY2NvdW50CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSkgJkFjY291bnQpIHsKCiAgICAgICAgbGV0IGFjY291bnQgPSBBY2NvdW50KHBheWVyOiBzaWduZXIpCgogICAgICAgIGxldCBrZXkgPSBQdWJsaWNLZXkoCiAgICAgICAgICAgIHB1YmxpY0tleTogcHVibGljS2V5LmRlY29kZUhleCgpLAogICAgICAgICAgICBzaWduYXR1cmVBbGdvcml0aG06IFNpZ25hdHVyZUFsZ29yaXRobShyYXdWYWx1ZTogc2lnbmF0dXJlQWxnb3JpdGhtKSEKICAgICAgICApCgogICAgICAgIGFjY291bnQua2V5cy5hZGQocHVibGljS2V5OiBrZXksIGhhc2hBbGdvcml0aG06IEhhc2hBbGdvcml0aG0ocmF3VmFsdWU6IGhhc2hBbGdvcml0aG0pISwgd2VpZ2h0OiB3ZWlnaHQpCgkJCiAgICAgICAgbGV0IHZhdWx0UmVmID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZGbG93VG9rZW4uVmF1bHQ+KAogICAgICAgICAgICBmcm9tOiAvc3RvcmFnZS9mbG93VG9rZW5WYXVsdAogICAgICAgICkgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgcmVmZXJlbmNlIHRvIHRoZSBvd25lcidzIFZhdWx0ISIpCgogICAgICAgIHNlbGYuc2VudFZhdWx0IDwtIHZhdWx0UmVmLndpdGhkcmF3KGFtb3VudDogMC4wKSBhcyEgQEZsb3dUb2tlbi5WYXVsdAogICAgICAgIHNlbGYuYXV0aCA9IGFjY291bnQKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBsZXQgYWNjb3VudCA8LSBFVk0uY3JlYXRlQ2FkZW5jZU93bmVkQWNjb3VudCgpCiAgICAgICAgbG9nKGFjY291bnQuYWRkcmVzcygpKQogICAgICAgIGFjY291bnQuZGVwb3NpdChmcm9tOiA8LXNlbGYuc2VudFZhdWx0KQoKICAgICAgICBsb2coYWNjb3VudC5iYWxhbmNlKCkpCiAgICAgICAgc2VsZi5hdXRoLnN0b3JhZ2Uuc2F2ZTxARVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KDwtYWNjb3VudCwgdG86IFN0b3JhZ2VQYXRoKGlkZW50aWZpZXI6ICJldm0iKSEpCiAgICB9Cn0K", - "removeCoa": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcmVtb3ZlQ29hIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRVZNIGZyb20gMHhlNDY3YjlkZDExZmEwMGRmCgoKdHJhbnNhY3Rpb24oKSB7CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSwgVW5wdWJsaXNoQ2FwYWJpbGl0eSkgJkFjY291bnQpIHsKICAgICAgICBsZXQgY29hUmVmID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PCZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oCiAgICAgICAgICAgIGZyb206IC9zdG9yYWdlL2V2bQogICAgICAgICkgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgcmVmZXJlbmNlIHRvIHRoZSBDT0EhIikKICAgICAgICBpZiBjb2FSZWYgIT0gbmlsIHsKICAgICAgICAgICAgbGV0IGNvYSA8LSBzaWduZXIuc3RvcmFnZS5sb2FkPEBFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oZnJvbTogL3N0b3JhZ2UvZXZtKSAKICAgICAgICAgICAgbGV0IHB1YmxpY1BhdGggPSBQdWJsaWNQYXRoKGlkZW50aWZpZXI6ICJldm0iKSEKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy51bnB1Ymxpc2gocHVibGljUGF0aCkKICAgICAgICAgICAgZGVzdHJveSBjb2EKICAgICAgICB9CiAgICB9Cn0K", - "run": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcnVuIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRVZNIGZyb20gMHhlNDY3YjlkZDExZmEwMGRmCgoKdHJhbnNhY3Rpb24oaGV4RW5jb2RlZFR4OiBTdHJpbmcpIHsKICAgIGxldCBjb2E6ICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudAoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgc2VsZi5jb2EgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8JkVWTS5DYWRlbmNlT3duZWRBY2NvdW50PigKICAgICAgICAgICAgZnJvbTogL3N0b3JhZ2UvZXZtCiAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIGxldCB0eFJlc3VsdCA9IEVWTS5ydW4odHg6IGhleEVuY29kZWRUeC5kZWNvZGVIZXgoKSwgY29pbmJhc2U6IHNlbGYuY29hLmFkZHJlc3MoKSkKICAgICAgICAvLyB0b2RvIG9ubHkgdGVtcG9yYXJ5IHVudGlsIHdlIGNvcnJlY3RseSBoYW5kbGUgZmFpbHVyZSBldmVudHMKICAgICAgICBhc3NlcnQoCiAgICAgICAgICAgIHR4UmVzdWx0LnN0YXR1cyA9PSBFVk0uU3RhdHVzLmZhaWxlZCB8fCB0eFJlc3VsdC5zdGF0dXMgPT0gRVZNLlN0YXR1cy5zdWNjZXNzZnVsLAogICAgICAgICAgICBtZXNzYWdlOiAiZXZtX2Vycm9yPSIuY29uY2F0KHR4UmVzdWx0LmVycm9yTWVzc2FnZSkuY29uY2F0KCJcbiIpCiAgICAgICAgKQogICAgfQp9Cg\u003d\u003d", - "transferCoa": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgdHJhbnNmZXJDb2EgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHgxNjU0NjUzMzk5MDQwYTYxCgppbXBvcnQgRVZNIGZyb20gMHhlNDY3YjlkZDExZmEwMGRmCgoKdHJhbnNhY3Rpb24oYW1vdW50OiBVRml4NjQsIGFkZHJlc3M6IEFkZHJlc3MpIHsKICAgIGxldCBzZW50VmF1bHQ6IEBGbG93VG9rZW4uVmF1bHQKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChTdG9yYWdlLCBFVk0uV2l0aGRyYXcpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IGNvYSA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEVWTS5XaXRoZHJhdykgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50PigKICAgICAgICAgICAgZnJvbTogL3N0b3JhZ2UvZXZtCiAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQoKICAgICAgICBzZWxmLnNlbnRWYXVsdCA8LSBjb2Eud2l0aGRyYXcoYmFsYW5jZTogRVZNLkJhbGFuY2UoYXR0b2Zsb3c6IFVJbnQoYW1vdW50KSAqIDEwMDAwMDAwMDAwMDAwMDAwMCkpIGFzISBARmxvd1Rva2VuLlZhdWx0CiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAgbGV0IHJlY2VpdmVyID0gYWNjb3VudC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5SZWNlaXZlcn0+KC9wdWJsaWMvZmxvd1Rva2VuUmVjZWl2ZXIpIQogICAgICAgIHJlY2VpdmVyLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKICAgIH0KfQo\u003d", - "transferFlowFromCoaToFlow": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgdHJhbnNmZXJGbG93RnJvbUNvYVRvRmxvdyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDE2NTQ2NTMzOTkwNDBhNjEKCmltcG9ydCBFVk0gZnJvbSAweGU0NjdiOWRkMTFmYTAwZGYKCgp0cmFuc2FjdGlvbihhbW91bnQ6IFVGaXg2NCwgYWRkcmVzczogQWRkcmVzcykgewogICAgbGV0IHNlbnRWYXVsdDogQEZsb3dUb2tlbi5WYXVsdAoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIEVWTS5XaXRoZHJhdykgJkFjY291bnQpIHsKICAgICAgICBsZXQgY29hID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoRVZNLldpdGhkcmF3KSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KAogICAgICAgICAgICBmcm9tOiAvc3RvcmFnZS9ldm0KICAgICAgICApID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IHJlZmVyZW5jZSB0byB0aGUgQ09BISIpCiAgICAgICAgbGV0IHdpdGhkcmF3QmFsYW5jZSA9IEVWTS5CYWxhbmNlKGF0dG9mbG93OiAwKQogICAgICAgIHdpdGhkcmF3QmFsYW5jZS5zZXRGTE9XKGZsb3c6IGFtb3VudCkKICAgICAgICBzZWxmLnNlbnRWYXVsdCA8LSBjb2Eud2l0aGRyYXcoYmFsYW5jZTogd2l0aGRyYXdCYWxhbmNlKSBhcyEgQEZsb3dUb2tlbi5WYXVsdAogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgIGxldCByZWNlaXZlciA9IGFjY291bnQuY2FwYWJpbGl0aWVzLmJvcnJvdzwme0Z1bmdpYmxlVG9rZW4uUmVjZWl2ZXJ9PigvcHVibGljL2Zsb3dUb2tlblJlY2VpdmVyKSEKICAgICAgICByZWNlaXZlci5kZXBvc2l0KGZyb206IDwtc2VsZi5zZW50VmF1bHQpCiAgICB9Cn0K", - "transferFlowToEvmAddress": "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", - "withdrawCoa": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgd2l0aGRyYXdDb2EgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHgxNjU0NjUzMzk5MDQwYTYxCgppbXBvcnQgRVZNIGZyb20gMHhlNDY3YjlkZDExZmEwMGRmCgoKdHJhbnNhY3Rpb24oYW1vdW50OiBVRml4NjQsIGFkZHJlc3M6IEFkZHJlc3MpIHsKICAgIGxldCBzZW50VmF1bHQ6IEBGbG93VG9rZW4uVmF1bHQKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChTdG9yYWdlLCBFVk0uV2l0aGRyYXcpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IGNvYSA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEVWTS5XaXRoZHJhdykgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50PigKICAgICAgICAgICAgZnJvbTogL3N0b3JhZ2UvZXZtCiAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQogICAgICAgIGxldCB3aXRoZHJhd0JhbGFuY2UgPSBFVk0uQmFsYW5jZShhdHRvZmxvdzogMCkKICAgICAgICB3aXRoZHJhd0JhbGFuY2Uuc2V0RkxPVyhmbG93OiBhbW91bnQpCiAgICAgICAgc2VsZi5zZW50VmF1bHQgPC0gY29hLndpdGhkcmF3KGJhbGFuY2U6IHdpdGhkcmF3QmFsYW5jZSkgYXMhIEBGbG93VG9rZW4uVmF1bHQKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBsZXQgYWNjb3VudCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgICBsZXQgcmVjZWl2ZXIgPSBhY2NvdW50LmNhcGFiaWxpdGllcy5ib3Jyb3c8JntGdW5naWJsZVRva2VuLlJlY2VpdmVyfT4oL3B1YmxpYy9mbG93VG9rZW5SZWNlaXZlcikhCiAgICAgICAgcmVjZWl2ZXIuZGVwb3NpdChmcm9tOiA8LXNlbGYuc2VudFZhdWx0KQogICAgfQp9Cg\u003d\u003d" - }, - "hybridCustody": { - "addNFTCollectionToDelegator": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYWRkTkZUQ29sbGVjdGlvblRvRGVsZWdhdG9yIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgSHlicmlkQ3VzdG9keSBmcm9tIDB4ZDhhN2UwNWE3YWM2NzBjMAoKCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4MWQ3ZTU3YWE1NTgxNzQ0OAoKaW1wb3J0IDxUb2tlbj4gZnJvbSA8VG9rZW5BZGRyZXNzPgoKdHJhbnNhY3Rpb24ocGFyZW50OiBBZGRyZXNzLCBpc1B1YmxpYzogQm9vbCkgewogICAgcHJlcGFyZShhY2N0OiBhdXRoKFN0b3JhZ2UsIENhcGFiaWxpdGllcykgJkFjY291bnQpIHsKICAgICAgICBsZXQgbyA9IGFjY3Quc3RvcmFnZS5ib3Jyb3c8YXV0aChIeWJyaWRDdXN0b2R5Lk93bmVyKSAmSHlicmlkQ3VzdG9keS5Pd25lZEFjY291bnQ+KGZyb206IEh5YnJpZEN1c3RvZHkuT3duZWRBY2NvdW50U3RvcmFnZVBhdGgpCiAgICAgICAgICAgID8/IHBhbmljKCJvd25lZCBhY2NvdW50IG5vdCBmb3VuZCIpCiAgICAgICAgbGV0IGNoaWxkOiAmSHlicmlkQ3VzdG9keS5DaGlsZEFjY291bnQgPSBvLmJvcnJvd0NoaWxkQWNjb3VudChwYXJlbnQ6IHBhcmVudCkKICAgICAgICAgICAgPz8gcGFuaWMoImNoaWxkIGFjY291bnQgbm90IGZvdW5kIikKCiAgICAgICAgbGV0IGNhcCA9IGFjY3QuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8JkV4YW1wbGVORlQuQ29sbGVjdGlvbj4oRXhhbXBsZU5GVC5Db2xsZWN0aW9uU3RvcmFnZVBhdGgpCiAgICAgICAgby5hZGRDYXBhYmlsaXR5VG9EZWxlZ2F0b3IocGFyZW50OiBwYXJlbnQsIGNhcDogY2FwLCBpc1B1YmxpYzogaXNQdWJsaWMpCiAgICB9Cn0\u003d", - "batchBridgeChildNFTFromEvm": "// Flow Wallet - mainnet Script  batchBridgeChildNFTFromEvm - v2.72
// <platform_info>

import MetadataViews from 0x1d7e57aa55817448

import ViewResolver from 0x1d7e57aa55817448

import NonFungibleToken from 0x1d7e57aa55817448

import FungibleToken from 0xf233dcee88fe0abe

import FlowToken from 0x1654653399040a61

import FungibleTokenMetadataViews from 0xf233dcee88fe0abe

import ScopedFTProviders from 0x1e4aa0b87d10b141

import EVM from 0xe467b9dd11fa00df

import FlowEVMBridgeUtils from 0x1e4aa0b87d10b141

import FlowEVMBridge from 0x1e4aa0b87d10b141

import FlowEVMBridgeConfig from 0x1e4aa0b87d10b141

import HybridCustody from 0xd8a7e05a7ac670c0

import CapabilityFilter from 0xd8a7e05a7ac670c0

import CrossVMMetadataViews from 0x1d7e57aa55817448


transaction(nftIdentifier: String, child: Address, ids: [UInt256]) {

    prepare(signer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        let coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        // Construct the NFT type from the provided identifier
        let nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        let m = signer.storage.borrow<auth(HybridCustody.Manage) &HybridCustody.Manager>(from: HybridCustody.ManagerStoragePath)
            ?? panic("manager does not exist")
        let childAcct = m.borrowAccount(addr: child) ?? panic("child account not found")

        /* --- Retrieve the NFT --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        let viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = viewResolver.resolveContractView(
                resourceType: nil,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")

        let capType = Type<&{NonFungibleToken.CollectionPublic}>()
        let controllerID = childAcct.getControllerIDForType(type: capType, forPath: collectionData.storagePath)
            ?? panic("no controller found for capType")

        let cap = childAcct.getCapability(controllerID: controllerID, type: capType) ?? panic("no cap found")
        let publicCap = cap as! Capability<&{NonFungibleToken.CollectionPublic}>
        assert(publicCap.check(), message: "invalid public capability")

        // Get a reference to the child's stored vault
        let collectionRef = publicCap.borrow()!

        // Calculate the approximate fee for the bridge
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000) + (FlowEVMBridgeConfig.baseFee * UFix64(ids.length))

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        let scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )

        // Unwrap NFTs if applicable
        unwrapNFTsIfApplicable(coa, nftIDs: ids, nftType: nftType, viewResolver: viewResolver)

        // Bridge NFTs from EVM to child flow account
        for id in ids {
            let nft: @{NonFungibleToken.NFT} <- coa.withdrawNFT(
                type: nftType,
                id: id,
                feeProvider: &scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )

            assert(
                nft.getType() == nftType,
                message: "Bridged nft type mismatch - requeswted: ".concat(nftType.identifier)
                    .concat(", received: ").concat(nft.getType().identifier)
            )

            collectionRef.deposit(token: <- nft)
        }

        // Destroy the ScopedFTProvider
        destroy scopedProvider
    }
}

/// Unwraps NFTs from a project's custom ERC721 wrapper contract to bridged NFTs on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
///
access(all) fun unwrapNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt256],
    nftType: Type,
    viewResolver: &{ViewResolver}
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            for id in nftIDs {
                // Unwrap NFT if it is wrapped
                if isNFTWrapped(coa,
                    nftID: id,
                    underlying: underlyingAddress,
                    wrapper: crossVMPointer.evmContractAddress
                ) {
                    let res = mustCall(coa, crossVMPointer.evmContractAddress,
                        functionSig: "withdrawTo(address,uint256[])",
                        args: [coa.address(), [id]]
                    )
                    let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                    assert(decodedRes.length == 1, message: "Invalid response length")
                    assert(decodedRes[0] as! Bool, message: "Failed to unwrap NFT")
                }
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is wrapped in the underlying ERC721 contract
///
access(all) fun isNFTWrapped(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftID: UInt256,
    underlying: EVM.EVMAddress,
    wrapper: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: underlying,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return false
    if res.status != EVM.Status.successful || res.data.length == 0{
        return false
    }

    // Decode and compare the addresses
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    let owner = decodedResult[0] as! EVM.EVMAddress
    return owner.toString() == wrapper.toString()
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", - "batchBridgeChildNFTToEvm": "// Flow Wallet - mainnet Script  batchBridgeChildNFTToEvm - v2.72
// <platform_info>

import MetadataViews from 0x1d7e57aa55817448

import ViewResolver from 0x1d7e57aa55817448

import NonFungibleToken from 0x1d7e57aa55817448

import FungibleToken from 0xf233dcee88fe0abe

import FlowToken from 0x1654653399040a61

import FungibleTokenMetadataViews from 0xf233dcee88fe0abe

import ScopedFTProviders from 0x1e4aa0b87d10b141

import EVM from 0xe467b9dd11fa00df

import FlowEVMBridgeUtils from 0x1e4aa0b87d10b141

import FlowEVMBridge from 0x1e4aa0b87d10b141

import FlowEVMBridgeConfig from 0x1e4aa0b87d10b141

import HybridCustody from 0xd8a7e05a7ac670c0

import CapabilityFilter from 0xd8a7e05a7ac670c0

import CrossVMMetadataViews from 0x1d7e57aa55817448


transaction(nftIdentifier: String, child: Address, ids: [UInt64]) {
    prepare(signer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, Capabilities, SaveValue) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        let coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        let m = signer.storage.borrow<auth(HybridCustody.Manage) &HybridCustody.Manager>(from: HybridCustody.ManagerStoragePath)
            ?? panic("manager does not exist")
        let childAcct = m.borrowAccount(addr: child) ?? panic("child account not found")

         // Construct the NFT type from the provided identifier
        let nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Retrieve the NFT --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        let viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = viewResolver.resolveContractView(
                resourceType: nil,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        var collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            )

        // Create collection if it doesn't exist
        if collection == nil {
            signer.storage.save(<- collectionData.createEmptyCollection(), to: collectionData.storagePath)
            signer.capabilities.unpublish(collectionData.publicPath)
            signer.capabilities.publish(
                signer.capabilities.storage.issue<&{NonFungibleToken.Collection}>(collectionData.storagePath),
                at: collectionData.publicPath
            )

            // Borrow authorized withdraw reference to the signer's collection
            collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            )!
        }

        let capType = Type<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider}>()
        let controllerID = childAcct.getControllerIDForType(type: capType, forPath: collectionData.storagePath)
            ?? panic("no controller found for capType")

        let cap = childAcct.getCapability(controllerID: controllerID, type: capType) ?? panic("no cap found")
        let providerCap = cap as! Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider}>
        assert(providerCap.check(), message: "invalid provider capability")

        let id = ids[0]
        // Get a reference to the child's stored vault
        let collectionRef = providerCap.borrow()!
        let childNft <- collectionRef.withdraw(withdrawID: id)
        collection!.deposit(token: <-childNft)
        // // Withdraw tokens from the signer's stored vault
        let currentStorageUsage = signer.storage.used
        let nft <- collection!.withdraw(withdrawID: id)
        let withdrawnStorageUsage = signer.storage.used
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(
                bytes: 400_000
            ) + (FlowEVMBridgeConfig.baseFee * UFix64(ids.length))

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        let scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )

        // Execute the bridge
        coa.depositNFT(
            nft: <- nft,
            feeProvider: &scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        var idx = 0
        for nftId in ids {
            if idx == 0 {
                idx = idx + 1
                continue
            }

            let nft <- collectionRef.withdraw(withdrawID: nftId)
            coa.depositNFT(
                nft: <- nft,
                feeProvider: &scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
            idx = idx + 1
        }
        // Destroy the ScopedFTProvider
        destroy scopedProvider

        // Wrap NFTs if applicable
        wrapAndTransferNFTsIfApplicable(coa,
            nftIDs: ids,
            nftType: nftType,
            viewResolver: viewResolver,
            recipientIfNotCoa: nil
        )
    }
}

/// Wraps and transfers bridged NFTs into a project's custom ERC721 wrapper contract on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
/// @param recipientIfNotCoa: The EVM address to transfer the wrapped NFTs to, nil if the NFTs should stay in signer's COA
///
access(all) fun wrapAndTransferNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt64],
    nftType: Type,
    viewResolver: &{ViewResolver},
    recipientIfNotCoa: EVM.EVMAddress?
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            // Wrap NFTs if underlying ERC721 address matches bridge's associated address for NFT type
            if underlyingAddress.equals(FlowEVMBridgeConfig.getEVMAddressAssociated(with: nftType)!) {
                // Approve contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, true]
                )

                // Wrap NFTs with provided IDs, and check if the call was successful
                let res = mustCall(coa, crossVMPointer.evmContractAddress,
                    functionSig: "depositFor(address,uint256[])",
                    args: [coa.address(), nftIDs]
                )
                let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                assert(decodedRes.length == 1, message: "Invalid response length")
                assert(decodedRes[0] as! Bool, message: "Failed to wrap NFTs")

                // Transfer NFTs to recipient if provided
                if let to = recipientIfNotCoa {
                    mustTransferNFTs(coa, crossVMPointer.evmContractAddress, nftIDs: nftIDs, to: to)
                }

                // Revoke approval for contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, false]
                )
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is owned by the provided EVM address
///
access(all) fun isOwner(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    _ nftID: UInt64,
    _ ownerToCheck: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: erc721Address,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )
    assert(res.status == EVM.Status.successful, message: "Call to ERC721.ownerOf(uint256) failed")
    let decodedRes = EVM.decodeABI(types: [Type<EVM.EVMAddress>()], data: res.data)
    if decodedRes.length == 1 {
        let actualOwner = decodedRes[0] as! EVM.EVMAddress
        return actualOwner.equals(ownerToCheck)
    }
    return false
}

/// Transfers NFTs from the provided COA to the provided EVM address
///
access(all) fun mustTransferNFTs(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    nftIDs: [UInt64],
    to: EVM.EVMAddress
) {
    for id in nftIDs {
        assert(isOwner(coa, erc721Address, id, coa.address()), message: "NFT not owned by signer's COA")
        mustCall(coa, erc721Address,
            functionSig: "safeTransferFrom(address,address,uint256)",
            args: [coa.address(), to, id]
        )
        assert(isOwner(coa, erc721Address, id, to), message: "NFT not transferred to recipient")
    }
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", - "batchBridgeChildNFTToEvmAddress": "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\u003d\u003d", - "batchSendChildNFT": "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\u003d", - "batchSendChildNFTToChild": "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\u003d\u003d", - "batchTransferChildNFT": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYmF0Y2hUcmFuc2ZlckNoaWxkTkZUIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgSHlicmlkQ3VzdG9keSBmcm9tIDB4ZDhhN2UwNWE3YWM2NzBjMAoKaW1wb3J0IENhcGFiaWxpdHlGaWx0ZXIgZnJvbSAweGQ4YTdlMDVhN2FjNjcwYzAKCmltcG9ydCBOb25GdW5naWJsZVRva2VuIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgTWV0YWRhdGFWaWV3cyBmcm9tIDB4MWQ3ZTU3YWE1NTgxNzQ0OAoKaW1wb3J0IDxORlQ+IGZyb20gPE5GVEFkZHJlc3M+CgovLy8gVHJhbnNmZXIgbXVsdGlwbGUgTkZUcyBmcm9tIHByb3ZpZGVkIGNoaWxkIGFjY291bnQgYWRkcmVzcyB0byBwYXJlbnQgYWNjb3VudCAoc2lnbmVyKQovLy8KdHJhbnNhY3Rpb24oYWRkcmVzczogQWRkcmVzcywgcGF0aDogU3RyaW5nLCBpZHM6IFtVSW50NjRdKSB7CgogIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIENhcGFiaWxpdGllcykgJkFjY291bnQpIHsKICAgIC8vIEdldCB0aGUgbWFuYWdlciByZXNvdXJjZSBhbmQgYm9ycm93IGNoaWxkQWNjb3VudAogICAgbGV0IG0gPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChIeWJyaWRDdXN0b2R5Lk1hbmFnZSkgJkh5YnJpZEN1c3RvZHkuTWFuYWdlcj4oZnJvbTogSHlicmlkQ3VzdG9keS5NYW5hZ2VyU3RvcmFnZVBhdGgpCiAgICAgICAgPz8gcGFuaWMoIm1hbmFnZXIgZG9lcyBub3QgZXhpc3QiKQogICAgbGV0IGNoaWxkQWNjdCA9IG0uYm9ycm93QWNjb3VudChhZGRyOiBhZGRyZXNzKSA/PyBwYW5pYygiY2hpbGQgYWNjb3VudCBub3QgZm91bmQiKQoKICAgIC8vIEdldCB0aGUgY29sbGVjdGlvbiBkYXRhIHZpZXcgZm9yIHRoZSBORlQKICAgIGxldCBjb2xsZWN0aW9uRGF0YSA9IDxORlQ+LnJlc29sdmVDb250cmFjdFZpZXcocmVzb3VyY2VUeXBlOiBuaWwsIHZpZXdUeXBlOiBUeXBlPE1ldGFkYXRhVmlld3MuTkZUQ29sbGVjdGlvbkRhdGE+KCkpIGFzISBNZXRhZGF0YVZpZXdzLk5GVENvbGxlY3Rpb25EYXRhPwogICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgZ2V0IHRoZSB2YXVsdCBkYXRhIHZpZXcgZm9yIDxORlQ+ICIpCgogICAgLy8gUmV0cmlldmUgYSBwcm92aWRlciBjYXBhYmlsaXR5IGZyb20gdGhlIGNoaWxkIGFjY291bnQgYW5kIGJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgY2hpbGQncyBjb2xsZWN0aW9uCiAgICBsZXQgY2FwVHlwZSA9IFR5cGU8YXV0aChOb25GdW5naWJsZVRva2VuLldpdGhkcmF3KSAme05vbkZ1bmdpYmxlVG9rZW4uUHJvdmlkZXJ9PigpCiAgICBsZXQgY29udHJvbGxlcklEID0gY2hpbGRBY2N0LmdldENvbnRyb2xsZXJJREZvclR5cGUodHlwZTogY2FwVHlwZSwgZm9yUGF0aDogY29sbGVjdGlvbkRhdGEuc3RvcmFnZVBhdGgpCiAgICAgICAgPz8gcGFuaWMoIm5vIGNvbnRyb2xsZXIgZm91bmQgZm9yIGNhcFR5cGUiKQoKICAgIGxldCBjYXAgPSBjaGlsZEFjY3QuZ2V0Q2FwYWJpbGl0eShjb250cm9sbGVySUQ6IGNvbnRyb2xsZXJJRCwgdHlwZTogY2FwVHlwZSkgPz8gcGFuaWMoIm5vIGNhcCBmb3VuZCIpCiAgICBsZXQgcHJvdmlkZXJDYXAgPSBjYXAgYXMhIENhcGFiaWxpdHk8YXV0aChOb25GdW5naWJsZVRva2VuLldpdGhkcmF3KSAme05vbkZ1bmdpYmxlVG9rZW4uUHJvdmlkZXJ9PgogICAgYXNzZXJ0KHByb3ZpZGVyQ2FwLmNoZWNrKCksIG1lc3NhZ2U6ICJpbnZhbGlkIHByb3ZpZGVyIGNhcGFiaWxpdHkiKQogICAgbGV0IGNoaWxkQ29sbGVjdGlvblJlZiA9IHByb3ZpZGVyQ2FwLmJvcnJvdygpIQoKICAgIC8vIEJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgc2lnbmVyJ3MgY29sbGVjdGlvbiBvciBjcmVhdGUgYSBjb2xsZWN0aW9uIGlmIGl0IGRvZXNuJ3QgZXhpc3QKICAgIHZhciByZWNlaXZlclJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzwme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0+KGZyb206IGNvbGxlY3Rpb25EYXRhLnN0b3JhZ2VQYXRoKQogICAgaWYgcmVjZWl2ZXJSZWYgPT0gbmlsIHsKICAgICAgc2lnbmVyLnN0b3JhZ2Uuc2F2ZSg8LSA8TkZUPi5jcmVhdGVFbXB0eUNvbGxlY3Rpb24obmZ0VHlwZTogVHlwZTxAPE5GVD4uTkZUPigpKSwgdG86IGNvbGxlY3Rpb25EYXRhLnN0b3JhZ2VQYXRoKQogICAgICBzaWduZXIuY2FwYWJpbGl0aWVzLnVucHVibGlzaChjb2xsZWN0aW9uRGF0YS5wdWJsaWNQYXRoKQogICAgICBsZXQgY29sbGVjdGlvbkNhcCA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTwmPE5GVD4uQ29sbGVjdGlvbj4oY29sbGVjdGlvbkRhdGEuc3RvcmFnZVBhdGgpCiAgICAgIHNpZ25lci5jYXBhYmlsaXRpZXMucHVibGlzaChjb2xsZWN0aW9uQ2FwLCBhdDogY29sbGVjdGlvbkRhdGEucHVibGljUGF0aCkKICAgICAgcmVjZWl2ZXJSZWYgPSBjb2xsZWN0aW9uQ2FwLmJvcnJvdygpIQogICAgfQoKICAgIC8vIFRyYW5zZmVyIE5GVHMgZnJvbSBjaGlsZCBhY2NvdW50J3MgY29sbGVjdGlvbiB0byBzaWduZXIncyBjb2xsZWN0aW9uCiAgICBmb3IgaWQgaW4gaWRzIHsKICAgICAgICByZWNlaXZlclJlZiEuZGVwb3NpdCh0b2tlbjogPC0gY2hpbGRDb2xsZWN0aW9uUmVmLndpdGhkcmF3KHdpdGhkcmF3SUQ6IGlkKSkKICAgIH0KICB9Cn0K", - "batchTransferNFTToChild": "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\u003d\u003d", - "bridgeChildFTFromEvm": "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\u003d", - "bridgeChildFTToEvm": "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\u003d\u003d", - "bridgeChildFTToEvmAddress": "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\u003d", - "bridgeChildNFTFromEvm": "// Flow Wallet - mainnet Script  bridgeChildNFTFromEvm - v2.72
// <platform_info>

import MetadataViews from 0x1d7e57aa55817448

import ViewResolver from 0x1d7e57aa55817448

import NonFungibleToken from 0x1d7e57aa55817448

import FungibleToken from 0xf233dcee88fe0abe

import FlowToken from 0x1654653399040a61

import FungibleTokenMetadataViews from 0xf233dcee88fe0abe

import ScopedFTProviders from 0x1e4aa0b87d10b141

import EVM from 0xe467b9dd11fa00df

import FlowEVMBridgeUtils from 0x1e4aa0b87d10b141

import FlowEVMBridge from 0x1e4aa0b87d10b141

import FlowEVMBridgeConfig from 0x1e4aa0b87d10b141

import HybridCustody from 0xd8a7e05a7ac670c0

import CapabilityFilter from 0xd8a7e05a7ac670c0

import CrossVMMetadataViews from 0x1d7e57aa55817448


transaction(nftIdentifier: String, child: Address, id: UInt256) {

    prepare(signer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        let coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        // Construct the NFT type from the provided identifier
        let nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        let m = signer.storage.borrow<auth(HybridCustody.Manage) &HybridCustody.Manager>(from: HybridCustody.ManagerStoragePath)
            ?? panic("manager does not exist")
        let childAcct = m.borrowAccount(addr: child) ?? panic("child account not found")

        /* --- Retrieve the NFT --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        let viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = viewResolver.resolveContractView(
                resourceType: nil,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")

        let capType = Type<&{NonFungibleToken.CollectionPublic}>()
        let controllerID = childAcct.getControllerIDForType(type: capType, forPath: collectionData.storagePath)
            ?? panic("no controller found for capType")

        let cap = childAcct.getCapability(controllerID: controllerID, type: capType) ?? panic("no cap found")
        let publicCap = cap as! Capability<&{NonFungibleToken.CollectionPublic}>
        assert(publicCap.check(), message: "invalid public capability")

        // Get a reference to the child's stored vault
        let collectionRef = publicCap.borrow()!

        // Calculate the approximate fee for the bridge
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000)

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        let scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )

        // Unwrap NFTs if applicable
        unwrapNFTsIfApplicable(coa as auth(EVM.Call) &EVM.CadenceOwnedAccount, nftIDs: [id], nftType: nftType, viewResolver: viewResolver)

        let nft: @{NonFungibleToken.NFT} <- coa.withdrawNFT(
            type: nftType,
            id: id,
            feeProvider: &scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )

        assert(
            nft.getType() == nftType,
            message: "Bridged nft type mismatch - requeswted: ".concat(nftType.identifier)
                .concat(", received: ").concat(nft.getType().identifier)
        )

        collectionRef.deposit(token: <- nft)
        // Destroy the ScopedFTProvider
        destroy scopedProvider
    }
}

/// Unwraps NFTs from a project's custom ERC721 wrapper contract to bridged NFTs on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
///
access(all) fun unwrapNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt256],
    nftType: Type,
    viewResolver: &{ViewResolver}
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            for id in nftIDs {
                // Unwrap NFT if it is wrapped
                if isNFTWrapped(coa,
                    nftID: id,
                    underlying: underlyingAddress,
                    wrapper: crossVMPointer.evmContractAddress
                ) {
                    let res = mustCall(coa, crossVMPointer.evmContractAddress,
                        functionSig: "withdrawTo(address,uint256[])",
                        args: [coa.address(), [id]]
                    )
                    let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                    assert(decodedRes.length == 1, message: "Invalid response length")
                    assert(decodedRes[0] as! Bool, message: "Failed to unwrap NFT")
                }
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is wrapped in the underlying ERC721 contract
///
access(all) fun isNFTWrapped(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftID: UInt256,
    underlying: EVM.EVMAddress,
    wrapper: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: underlying,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return false
    if res.status != EVM.Status.successful || res.data.length == 0{
        return false
    }

    // Decode and compare the addresses
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    let owner = decodedResult[0] as! EVM.EVMAddress
    return owner.toString() == wrapper.toString()
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", - "bridgeChildNFTToEvm": "// Flow Wallet - mainnet Script  bridgeChildNFTToEvm - v2.72
// <platform_info>

import MetadataViews from 0x1d7e57aa55817448

import ViewResolver from 0x1d7e57aa55817448

import NonFungibleToken from 0x1d7e57aa55817448

import FungibleToken from 0xf233dcee88fe0abe

import FlowToken from 0x1654653399040a61

import FungibleTokenMetadataViews from 0xf233dcee88fe0abe

import ScopedFTProviders from 0x1e4aa0b87d10b141

import EVM from 0xe467b9dd11fa00df

import FlowEVMBridgeUtils from 0x1e4aa0b87d10b141

import FlowEVMBridge from 0x1e4aa0b87d10b141

import FlowEVMBridgeConfig from 0x1e4aa0b87d10b141

import HybridCustody from 0xd8a7e05a7ac670c0

import CapabilityFilter from 0xd8a7e05a7ac670c0

import CrossVMMetadataViews from 0x1d7e57aa55817448


transaction(nftIdentifier: String, id: UInt64, child: Address) {

    let nft: @{NonFungibleToken.NFT}
    let coa: auth(EVM.Bridge, EVM.Call) &EVM.CadenceOwnedAccount
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let nftType: Type
    let viewResolver: &{ViewResolver}
    prepare(signer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, Capabilities, SaveValue) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        let m = signer.storage.borrow<auth(HybridCustody.Manage) &HybridCustody.Manager>(from: HybridCustody.ManagerStoragePath)
            ?? panic("manager does not exist")
        let childAcct = m.borrowAccount(addr: child) ?? panic("child account not found")

         // Construct the NFT type from the provided identifier
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: self.nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Retrieve the NFT --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: nil,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        var collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            )

        // Create collection if it doesn't exist
        if collection == nil {
            signer.storage.save(<- collectionData.createEmptyCollection(), to: collectionData.storagePath)
            signer.capabilities.unpublish(collectionData.publicPath)
            signer.capabilities.publish(
                signer.capabilities.storage.issue<&{NonFungibleToken.Collection}>(collectionData.storagePath),
                at: collectionData.publicPath
            )

            // Borrow authorized withdraw reference to the signer's collection
            collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            )!
        }

        let capType = Type<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider}>()
        let controllerID = childAcct.getControllerIDForType(type: capType, forPath: collectionData.storagePath)
            ?? panic("no controller found for capType")

        let cap = childAcct.getCapability(controllerID: controllerID, type: capType) ?? panic("no cap found")
        let providerCap = cap as! Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider}>
        assert(providerCap.check(), message: "invalid provider capability")

        // Get a reference to the child's stored vault
        let collectionRef = providerCap.borrow()!
        let childNft <- collectionRef.withdraw(withdrawID: id)
        collection!.deposit(token: <-childNft)
        // // Withdraw tokens from the signer's stored vault
        let currentStorageUsage = signer.storage.used
        self.nft <- collection!.withdraw(withdrawID: id)
        let withdrawnStorageUsage = signer.storage.used
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(
                bytes: 400_000
            )

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    execute {
        // Execute the bridge
        self.coa.depositNFT(
            nft: <-self.nft,
            feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        // Destroy the ScopedFTProvider
        destroy self.scopedProvider

        // Wrap NFTs if applicable
        wrapAndTransferNFTsIfApplicable(
            self.coa,
            nftIDs: [id],
            nftType: self.nftType,
            viewResolver: self.viewResolver,
            recipientIfNotCoa: nil
        )
    }
}

/// Wraps and transfers bridged NFTs into a project's custom ERC721 wrapper contract on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
/// @param recipientIfNotCoa: The EVM address to transfer the wrapped NFTs to, nil if the NFTs should stay in signer's COA
///
access(all) fun wrapAndTransferNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt64],
    nftType: Type,
    viewResolver: &{ViewResolver},
    recipientIfNotCoa: EVM.EVMAddress?
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            // Wrap NFTs if underlying ERC721 address matches bridge's associated address for NFT type
            if underlyingAddress.equals(FlowEVMBridgeConfig.getEVMAddressAssociated(with: nftType)!) {
                // Approve contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, true]
                )

                // Wrap NFTs with provided IDs, and check if the call was successful
                let res = mustCall(coa, crossVMPointer.evmContractAddress,
                    functionSig: "depositFor(address,uint256[])",
                    args: [coa.address(), nftIDs]
                )
                let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                assert(decodedRes.length == 1, message: "Invalid response length")
                assert(decodedRes[0] as! Bool, message: "Failed to wrap NFTs")

                // Transfer NFTs to recipient if provided
                if let to = recipientIfNotCoa {
                    mustTransferNFTs(coa, crossVMPointer.evmContractAddress, nftIDs: nftIDs, to: to)
                }

                // Revoke approval for contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, false]
                )
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is owned by the provided EVM address
///
access(all) fun isOwner(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    _ nftID: UInt64,
    _ ownerToCheck: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: erc721Address,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )
    assert(res.status == EVM.Status.successful, message: "Call to ERC721.ownerOf(uint256) failed")
    let decodedRes = EVM.decodeABI(types: [Type<EVM.EVMAddress>()], data: res.data)
    if decodedRes.length == 1 {
        let actualOwner = decodedRes[0] as! EVM.EVMAddress
        return actualOwner.equals(ownerToCheck)
    }
    return false
}

/// Transfers NFTs from the provided COA to the provided EVM address
///
access(all) fun mustTransferNFTs(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    nftIDs: [UInt64],
    to: EVM.EVMAddress
) {
    for id in nftIDs {
        assert(isOwner(coa, erc721Address, id, coa.address()), message: "NFT not owned by signer's COA")
        mustCall(coa, erc721Address,
            functionSig: "safeTransferFrom(address,address,uint256)",
            args: [coa.address(), to, id]
        )
        assert(isOwner(coa, erc721Address, id, to), message: "NFT not transferred to recipient")
    }
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", - "bridgeChildNFTToEvmAddress": "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\u003d\u003d", - "checkChildLinkedCollections": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY2hlY2tDaGlsZExpbmtlZENvbGxlY3Rpb25zIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgSHlicmlkQ3VzdG9keSBmcm9tIDB4ZDhhN2UwNWE3YWM2NzBjMAoKaW1wb3J0IENhcGFiaWxpdHlGaWx0ZXIgZnJvbSAweGQ4YTdlMDVhN2FjNjcwYzAKCmltcG9ydCBOb25GdW5naWJsZVRva2VuIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgoKYWNjZXNzKGFsbCkgZnVuIG1haW4ocGFyZW50OiBBZGRyZXNzLCBjaGlsZDogQWRkcmVzcywgaWRlbnRpZmllcjogU3RyaW5nKTogQm9vbCB7CiAgICBsZXQgbWdyID0gZ2V0QXV0aEFjY291bnQocGFyZW50KS5ib3Jyb3c8Jkh5YnJpZEN1c3RvZHkuTWFuYWdlcj4oZnJvbTogSHlicmlkQ3VzdG9keS5NYW5hZ2VyU3RvcmFnZVBhdGgpCiAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgbWFuYWdlciBmcm9tIHBhcmVudCIpCiAgICBsZXQgY2hpbGQgPSBtZ3IuYm9ycm93QWNjb3VudChhZGRyOiBjaGlsZCkgPz8gcGFuaWMoIkNoaWxkIGFjY291bnQgbm90IGZvdW5kIikKCiAgICBsZXQgY2FwID0gY2hpbGQuZ2V0Q2FwYWJpbGl0eSgKICAgICAgICAgICAgcGF0aDogUHJpdmF0ZVBhdGgoaWRlbnRpZmllcjogaWRlbnRpZmllcikhIGFzIENhcGFiaWxpdHlQYXRoLAogICAgICAgICAgICB0eXBlOiBUeXBlPCZ7Tm9uRnVuZ2libGVUb2tlbi5Qcm92aWRlciwgTm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9uUHVibGljfT4oKQogICAgICAgICkgYXMhIENhcGFiaWxpdHk8JntOb25GdW5naWJsZVRva2VuLlByb3ZpZGVyLCBOb25GdW5naWJsZVRva2VuLkNvbGxlY3Rpb25QdWJsaWN9Pj8KCiAgICAKICAgIHJldHVybiBjYXAgIT0gbmlsCn0gICAKICAgIA\u003d\u003d", - "checkChildLinkedVaults": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY2hlY2tDaGlsZExpbmtlZFZhdWx0cyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEh5YnJpZEN1c3RvZHkgZnJvbSAweGQ4YTdlMDVhN2FjNjcwYzAKCmltcG9ydCBDYXBhYmlsaXR5RmlsdGVyIGZyb20gMHhkOGE3ZTA1YTdhYzY3MGMwCgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKHBhcmVudDogQWRkcmVzcywgY2hpbGQ6IEFkZHJlc3MsIHBhdGg6IFN0cmluZyk6IEJvb2wgewogIGxldCBhY2NvdW50ID0gZ2V0QXV0aEFjY291bnQ8YXV0aChTdG9yYWdlKSAmQWNjb3VudD4ocGFyZW50KQogIGxldCBtYW5hZ2VyID0gZ2V0QXV0aEFjY291bnQ8YXV0aChTdG9yYWdlKSAmQWNjb3VudD4ocGFyZW50KS5zdG9yYWdlLmJvcnJvdzxhdXRoKEh5YnJpZEN1c3RvZHkuTWFuYWdlKSAmSHlicmlkQ3VzdG9keS5NYW5hZ2VyPihmcm9tOiBIeWJyaWRDdXN0b2R5Lk1hbmFnZXJTdG9yYWdlUGF0aCkgPz8gcGFuaWMgKCJtYW5hZ2VyIGRvZXMgbm90IGV4aXN0IikKICAKICBsZXQgcHJvdmlkZXJUeXBlID0gVHlwZTxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+KCkKCiAgbGV0IGFkZHIgPSBnZXRBdXRoQWNjb3VudDxhdXRoKFN0b3JhZ2UsIENhcGFiaWxpdGllcykgJkFjY291bnQ+KGNoaWxkKQogIAogIGxldCBjaGlsZEFjY3QgPSBtYW5hZ2VyLmJvcnJvd0FjY291bnQoYWRkcjogY2hpbGQpID8/IHBhbmljKCJjaGlsZCBhY2NvdW50IG5vdCBmb3VuZCIpCgogIGxldCBjb250cm9sbGVycyA9IGFkZHIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuZ2V0Q29udHJvbGxlcnMoZm9yUGF0aDogU3RvcmFnZVBhdGgoaWRlbnRpZmllcjogcGF0aCkhKQogIHZhciBmbGFnID0gZmFsc2UKCiAgZm9yIGMgaW4gY29udHJvbGxlcnMgewogICAgaWYgIWMuYm9ycm93VHlwZS5pc1N1YnR5cGUob2Y6IHByb3ZpZGVyVHlwZSkgewogICAgICBjb250aW51ZQogICAgfQoKICAgIGlmIGxldCBjYXAgPSBjaGlsZEFjY3QuZ2V0Q2FwYWJpbGl0eShjb250cm9sbGVySUQ6IGMuY2FwYWJpbGl0eUlELCB0eXBlOiBwcm92aWRlclR5cGUpIHsKICAgICAgbGV0IHByb3ZpZGVyQ2FwID0gY2FwIGFzISBDYXBhYmlsaXR5PCZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+IAoKICAgICAgaWYgIXByb3ZpZGVyQ2FwLmNoZWNrKCl7CiAgICAgICAgY29udGludWUKICAgICAgfQoKICAgICAgZmxhZyA9IHRydWUKICAgICAgYnJlYWsKICAgIH0KICB9CgogIHJldHVybiBmbGFnCn0gCiAgICA\u003d", - "checkChildRecieveVaults": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY2hlY2tDaGlsZFJlY2lldmVWYXVsdHMgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBIeWJyaWRDdXN0b2R5IGZyb20gMHhkOGE3ZTA1YTdhYzY3MGMwCgppbXBvcnQgQ2FwYWJpbGl0eUZpbHRlciBmcm9tIDB4ZDhhN2UwNWE3YWM2NzBjMAoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihwYXJlbnQ6IEFkZHJlc3MsIGNoaWxkOiBBZGRyZXNzLCBwYXRoOiBTdHJpbmcpOiBCb29sIHsKICBsZXQgYWNjb3VudCA9IGdldEF1dGhBY2NvdW50PGF1dGgoU3RvcmFnZSkgJkFjY291bnQ+KHBhcmVudCkKICBsZXQgbWFuYWdlciA9IGdldEF1dGhBY2NvdW50PGF1dGgoU3RvcmFnZSkgJkFjY291bnQ+KHBhcmVudCkuc3RvcmFnZS5ib3Jyb3c8YXV0aChIeWJyaWRDdXN0b2R5Lk1hbmFnZSkgJkh5YnJpZEN1c3RvZHkuTWFuYWdlcj4oZnJvbTogSHlicmlkQ3VzdG9keS5NYW5hZ2VyU3RvcmFnZVBhdGgpID8/IHBhbmljICgibWFuYWdlciBkb2VzIG5vdCBleGlzdCIpCiAgCiAgbGV0IHJlY2VpdmVyVHlwZSA9IFR5cGU8JntGdW5naWJsZVRva2VuLlJlY2VpdmVyfT4oKQoKICBsZXQgYWRkciA9IGdldEF1dGhBY2NvdW50PGF1dGgoU3RvcmFnZSwgQ2FwYWJpbGl0aWVzKSAmQWNjb3VudD4oY2hpbGQpCiAgCiAgbGV0IGNoaWxkQWNjdCA9IG1hbmFnZXIuYm9ycm93QWNjb3VudChhZGRyOiBjaGlsZCkgPz8gcGFuaWMoImNoaWxkIGFjY291bnQgbm90IGZvdW5kIikKCiAgbGV0IGNvbnRyb2xsZXJzID0gYWRkci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5nZXRDb250cm9sbGVycyhmb3JQYXRoOiBTdG9yYWdlUGF0aChpZGVudGlmaWVyOiBwYXRoKSEpCiAgdmFyIGZsYWcgPSBmYWxzZQoKICBmb3IgYyBpbiBjb250cm9sbGVycyB7CiAgICBpZiAhYy5ib3Jyb3dUeXBlLmlzU3VidHlwZShvZjogcmVjZWl2ZXJUeXBlKSB7CiAgICAgIGNvbnRpbnVlCiAgICB9CgogICAgaWYgbGV0IGNhcCA9IGNoaWxkQWNjdC5nZXRDYXBhYmlsaXR5KGNvbnRyb2xsZXJJRDogYy5jYXBhYmlsaXR5SUQsIHR5cGU6IHJlY2VpdmVyVHlwZSkgewogICAgICBsZXQgcHJvdmlkZXJDYXAgPSBjYXAgYXMhIENhcGFiaWxpdHk8JntGdW5naWJsZVRva2VuLlJlY2VpdmVyfT4gCgogICAgICBpZiAhcHJvdmlkZXJDYXAuY2hlY2soKXsKICAgICAgICBjb250aW51ZQogICAgICB9CgogICAgICBmbGFnID0gdHJ1ZQogICAgICBicmVhawogICAgfQogIH0KCiAgcmV0dXJuIGZsYWcKfSAKICAgIA\u003d\u003d", - "editChildAccount": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZWRpdENoaWxkQWNjb3VudCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEh5YnJpZEN1c3RvZHkgZnJvbSAweGQ4YTdlMDVhN2FjNjcwYzAKCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgoKdHJhbnNhY3Rpb24oY2hpbGRBZGRyZXNzOiBBZGRyZXNzLCBuYW1lOiBTdHJpbmcsIGRlc2NyaXB0aW9uOiBTdHJpbmcsIHRodW1ibmFpbDogU3RyaW5nKSB7CiAgICBwcmVwYXJlKGFjY3Q6IEF1dGhBY2NvdW50KSB7CiAgICAgICAgbGV0IG0gPSBhY2N0LmJvcnJvdzwmSHlicmlkQ3VzdG9keS5NYW5hZ2VyPihmcm9tOiBIeWJyaWRDdXN0b2R5Lk1hbmFnZXJTdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIm1hbmFnZXIgbm90IGZvdW5kIikKICAgICAgICAKICAgICAgICBsZXQgZCA9IE1ldGFkYXRhVmlld3MuRGlzcGxheSgKICAgICAgICAgICAgbmFtZTogbmFtZSwKICAgICAgICAgICAgZGVzY3JpcHRpb246IGRlc2NyaXB0aW9uLAogICAgICAgICAgICB0aHVtYm5haWw6IE1ldGFkYXRhVmlld3MuSFRUUEZpbGUodXJsOiB0aHVtYm5haWwpCiAgICAgICAgKQoKICAgICAgICBtLnNldENoaWxkQWNjb3VudERpc3BsYXkoYWRkcmVzczogY2hpbGRBZGRyZXNzLCBkKQogICAgfQp9", - "getAccessibleChildAccountNFTs": "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\u003d", - "getAccessibleCoinInfo": "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", - "getAccessibleCollectionAndIdsDisplay": "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\u003d\u003d", - "getChildAccountAllowTypes": "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\u003d\u003d", - "getChildAccountFTCapabilities": "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\u003d\u003d", - "getChildAccountMeta": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Q2hpbGRBY2NvdW50TWV0YSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEh5YnJpZEN1c3RvZHkgZnJvbSAweGQ4YTdlMDVhN2FjNjcwYzAKCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgoKYWNjZXNzKGFsbCkgZnVuIG1haW4ocGFyZW50OiBBZGRyZXNzKToge0FkZHJlc3M6IEFueVN0cnVjdH0gewogICAgbGV0IGFjY3QgPSBnZXRBdXRoQWNjb3VudDxhdXRoKFN0b3JhZ2UpICZBY2NvdW50PihwYXJlbnQpCiAgICBsZXQgbSA9IGFjY3Quc3RvcmFnZS5ib3Jyb3c8Jkh5YnJpZEN1c3RvZHkuTWFuYWdlcj4oZnJvbTogSHlicmlkQ3VzdG9keS5NYW5hZ2VyU3RvcmFnZVBhdGgpCgogICAgaWYgbSA9PSBuaWwgewogICAgICAgIHJldHVybiB7fQogICAgfSBlbHNlIHsKICAgICAgICB2YXIgZGF0YToge0FkZHJlc3M6IEFueVN0cnVjdH0gPSB7fQogICAgICAgIGZvciBhZGRyZXNzIGluIG0/LmdldENoaWxkQWRkcmVzc2VzKCkhIHsKICAgICAgICAgICAgbGV0IGMgPSBtPy5nZXRDaGlsZEFjY291bnREaXNwbGF5KGFkZHJlc3M6IGFkZHJlc3MpIAogICAgICAgICAgICBkYXRhLmluc2VydChrZXk6IGFkZHJlc3MsIGMpCiAgICAgICAgfQogICAgICAgIHJldHVybiBkYXRhCiAgICB9Cn0\u003d", - "getChildAddresses": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Q2hpbGRBZGRyZXNzZXMgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBIeWJyaWRDdXN0b2R5IGZyb20gMHhkOGE3ZTA1YTdhYzY3MGMwCgoKYWNjZXNzKGFsbCkgZnVuIG1haW4ocGFyZW50OiBBZGRyZXNzKTogW0FkZHJlc3NdIHsKICAgIGxldCBhY2N0ID0gZ2V0QXV0aEFjY291bnQ8YXV0aChTdG9yYWdlKSAmQWNjb3VudD4ocGFyZW50KQogICAgbGV0IG1hbmFnZXIgPSBhY2N0LnN0b3JhZ2UuYm9ycm93PCZIeWJyaWRDdXN0b2R5Lk1hbmFnZXI+KGZyb206IEh5YnJpZEN1c3RvZHkuTWFuYWdlclN0b3JhZ2VQYXRoKQogICAgICAgID8/IHBhbmljKCJtYW5hZ2VyIG5vdCBmb3VuZCIpCiAgICByZXR1cm4gIG1hbmFnZXIuZ2V0Q2hpbGRBZGRyZXNzZXMoKQp9", - "getExamplenftCollectionFromDelegator": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0RXhhbXBsZW5mdENvbGxlY3Rpb25Gcm9tRGVsZWdhdG9yIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgSHlicmlkQ3VzdG9keSBmcm9tIDB4ZDhhN2UwNWE3YWM2NzBjMAoKCmltcG9ydCBOb25GdW5naWJsZVRva2VuIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgPFRva2VuPiBmcm9tIDxUb2tlbkFkZHJlc3M+CgphY2Nlc3MoYWxsKSBmdW4gbWFpbihwYXJlbnQ6IEFkZHJlc3MsIGNoaWxkOiBBZGRyZXNzLCBpc1B1YmxpYzogQm9vbCkgewogICAgbGV0IG0gPSBnZXRBdXRoQWNjb3VudDxhdXRoKFN0b3JhZ2UpICZBY2NvdW50PihwYXJlbnQpLnN0b3JhZ2UuYm9ycm93PGF1dGgoSHlicmlkQ3VzdG9keS5NYW5hZ2UpICZIeWJyaWRDdXN0b2R5Lk1hbmFnZXI+KGZyb206IEh5YnJpZEN1c3RvZHkuTWFuYWdlclN0b3JhZ2VQYXRoKQogICAgICAgID8/IHBhbmljKCJtYW5hZ2VyIG5vdCBmb3VuZCIpCiAgICBsZXQgYWNjdCA9IG0uYm9ycm93QWNjb3VudChhZGRyOiBjaGlsZCkKICAgICAgICA/PyBwYW5pYygiY2hpbGQgYWNjb3VudCBub3QgZm91bmQgaW4gbWFuYWdlciIpCgogICAgbGV0IHQgPSBUeXBlPENhcGFiaWxpdHk8JkV4YW1wbGVORlQuQ29sbGVjdGlvbj4+KCkKCiAgICBsZXQgY2FwID0gKGlzUHVibGljID8gYWNjdC5nZXRQdWJsaWNDYXBGcm9tRGVsZWdhdG9yKHR5cGU6IHQpIDogYWNjdC5nZXRQcml2YXRlQ2FwRnJvbURlbGVnYXRvcih0eXBlOiB0KSkKICAgICAgICA/PyBwYW5pYygiY2FwYWJpbGl0eSBub3QgZm91bmQiKQogICAgCiAgICBhc3NlcnQoY2FwLmdldFR5cGUoKSA9PSB0LCBtZXNzYWdlOiAibWlzbWF0Y2hlZCBjYXBhYmlsaXR5IHR5cGVzIikKfQ\u003d\u003d", - "publishToParent": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcHVibGlzaFRvUGFyZW50IC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgojYWxsb3dBY2NvdW50TGlua2luZwoKaW1wb3J0IEh5YnJpZEN1c3RvZHkgZnJvbSAweGQ4YTdlMDVhN2FjNjcwYzAKCmltcG9ydCBDYXBhYmlsaXR5RmFjdG9yeSBmcm9tIDB4ZDhhN2UwNWE3YWM2NzBjMAoKaW1wb3J0IENhcGFiaWxpdHlGaWx0ZXIgZnJvbSAweGQ4YTdlMDVhN2FjNjcwYzAKCmltcG9ydCBDYXBhYmlsaXR5RGVsZWdhdG9yIGZyb20gMHhkOGE3ZTA1YTdhYzY3MGMwCgoKdHJhbnNhY3Rpb24ocGFyZW50OiBBZGRyZXNzLCBmYWN0b3J5QWRkcmVzczogQWRkcmVzcywgZmlsdGVyQWRkcmVzczogQWRkcmVzcykgewogICAgcHJlcGFyZShhY2N0OiBhdXRoKFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IG93bmVkID0gYWNjdC5zdG9yYWdlLmJvcnJvdzxhdXRoKEh5YnJpZEN1c3RvZHkuT3duZXIpICZIeWJyaWRDdXN0b2R5Lk93bmVkQWNjb3VudD4oZnJvbTogSHlicmlkQ3VzdG9keS5Pd25lZEFjY291bnRTdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIm93bmVkIGFjY291bnQgbm90IGZvdW5kIikKCiAgICAgICAgbGV0IGZhY3RvcnkgPSBnZXRBY2NvdW50KGZhY3RvcnlBZGRyZXNzKS5jYXBhYmlsaXRpZXMuZ2V0PCZDYXBhYmlsaXR5RmFjdG9yeS5NYW5hZ2VyPihDYXBhYmlsaXR5RmFjdG9yeS5QdWJsaWNQYXRoKQogICAgICAgIGFzc2VydChmYWN0b3J5LmNoZWNrKCksIG1lc3NhZ2U6ICJmYWN0b3J5IGFkZHJlc3MgaXMgbm90IGNvbmZpZ3VyZWQgcHJvcGVybHkiKQoKICAgICAgICBsZXQgZmlsdGVyID0gZ2V0QWNjb3VudChmaWx0ZXJBZGRyZXNzKS5jYXBhYmlsaXRpZXMuZ2V0PCZ7Q2FwYWJpbGl0eUZpbHRlci5GaWx0ZXJ9PihDYXBhYmlsaXR5RmlsdGVyLlB1YmxpY1BhdGgpCiAgICAgICAgYXNzZXJ0KGZpbHRlci5jaGVjaygpLCBtZXNzYWdlOiAiY2FwYWJpbGl0eSBmaWx0ZXIgaXMgbm90IGNvbmZpZ3VyZWQgcHJvcGVybHkiKQoKICAgICAgICBvd25lZC5wdWJsaXNoVG9QYXJlbnQocGFyZW50QWRkcmVzczogcGFyZW50LCBmYWN0b3J5OiBmYWN0b3J5LCBmaWx0ZXI6IGZpbHRlcikKICAgIH0KfQ\u003d\u003d", - "redeemAccount": "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\u003d\u003d", - "sendChildFT": "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\u003d", - "sendChildFTToChild": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgc2VuZENoaWxkRlRUb0NoaWxkIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgSHlicmlkQ3VzdG9keSBmcm9tIDB4ZDhhN2UwNWE3YWM2NzBjMAoKCi8vIEhDLW93bmVkIGltcG9ydHMKaW1wb3J0IENhcGFiaWxpdHlGYWN0b3J5IGZyb20gMHhkOGE3ZTA1YTdhYzY3MGMwCgppbXBvcnQgQ2FwYWJpbGl0eUZpbHRlciBmcm9tIDB4ZDhhN2UwNWE3YWM2NzBjMAoKCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgppbXBvcnQgPFRva2VuPiBmcm9tIDxUb2tlbkFkZHJlc3M+CgoKdHJhbnNhY3Rpb24oYWRkcmVzczogQWRkcmVzcywgcmVjZWl2ZXI6IEFkZHJlc3MsIHBhdGg6IFN0cmluZywgYW1vdW50OiBVRml4NjQgKSB7CgogIC8vIFRoZSBWYXVsdCByZXNvdXJjZSB0aGF0IGhvbGRzIHRoZSB0b2tlbnMgdGhhdCBhcmUgYmVpbmcgdHJhbnNmZXJyZWQKICBsZXQgcGF5bWVudFZhdWx0OiBAe0Z1bmdpYmxlVG9rZW4uVmF1bHR9CiAgbGV0IHZhdWx0RGF0YTogRnVuZ2libGVUb2tlbk1ldGFkYXRhVmlld3MuRlRWYXVsdERhdGEKCiAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSkgJkFjY291bnQpIHsKICAgICAgLy8gc2lnbmVyIGlzIHRoZSBwYXJlbnQgYWNjb3VudAogICAgICAvLyBnZXQgdGhlIG1hbmFnZXIgcmVzb3VyY2UgYW5kIGJvcnJvdyBjaGlsZEFjY291bnQKICAgICAgbGV0IG0gPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChIeWJyaWRDdXN0b2R5Lk1hbmFnZSkgJkh5YnJpZEN1c3RvZHkuTWFuYWdlcj4oZnJvbTogSHlicmlkQ3VzdG9keS5NYW5hZ2VyU3RvcmFnZVBhdGgpCiAgICAgICAgICA/PyBwYW5pYygibWFuYWdlciBkb2VzIG5vdCBleGlzdCIpCiAgICAgIGxldCBjaGlsZEFjY3QgPSBtLmJvcnJvd0FjY291bnQoYWRkcjogYWRkcmVzcykgPz8gcGFuaWMoImNoaWxkIGFjY291bnQgbm90IGZvdW5kIikKICAgICAgCiAgICAgIHNlbGYudmF1bHREYXRhID0gPFRva2VuPi5yZXNvbHZlQ29udHJhY3RWaWV3KHJlc291cmNlVHlwZTogbmlsLCB2aWV3VHlwZTogVHlwZTxGdW5naWJsZVRva2VuTWV0YWRhdGFWaWV3cy5GVFZhdWx0RGF0YT4oKSkgYXMhIEZ1bmdpYmxlVG9rZW5NZXRhZGF0YVZpZXdzLkZUVmF1bHREYXRhPwogICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBnZXQgdGhlIHZhdWx0IGRhdGEgdmlldyBmb3IgPFRva2VuPiAiKQoKICAgICAgLy9nZXQgRnQgY2FwIGZyb20gY2hpbGQgYWNjb3VudAogICAgICBsZXQgY2FwVHlwZSA9IFR5cGU8YXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAme0Z1bmdpYmxlVG9rZW4uUHJvdmlkZXJ9PigpCiAgICAgIGxldCBjb250cm9sbGVySUQgPSBjaGlsZEFjY3QuZ2V0Q29udHJvbGxlcklERm9yVHlwZSh0eXBlOiBjYXBUeXBlLCBmb3JQYXRoOiBzZWxmLnZhdWx0RGF0YS5zdG9yYWdlUGF0aCkKICAgICAgICAgID8/IHBhbmljKCJubyBjb250cm9sbGVyIGZvdW5kIGZvciBjYXBUeXBlIikKICAgICAgCiAgICAgIGxldCBjYXAgPSBjaGlsZEFjY3QuZ2V0Q2FwYWJpbGl0eShjb250cm9sbGVySUQ6IGNvbnRyb2xsZXJJRCwgdHlwZTogY2FwVHlwZSkgPz8gcGFuaWMoIm5vIGNhcCBmb3VuZCIpCiAgICAgIGxldCBwcm92aWRlckNhcCA9IGNhcCBhcyEgQ2FwYWJpbGl0eTxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+CiAgICAgIGFzc2VydChwcm92aWRlckNhcC5jaGVjaygpLCBtZXNzYWdlOiAiaW52YWxpZCBwcm92aWRlciBjYXBhYmlsaXR5IikKICAgICAgCiAgICAgIC8vIEdldCBhIHJlZmVyZW5jZSB0byB0aGUgY2hpbGQncyBzdG9yZWQgdmF1bHQKICAgICAgbGV0IHZhdWx0UmVmID0gcHJvdmlkZXJDYXAuYm9ycm93KCkhCgogICAgICAvLyBXaXRoZHJhdyB0b2tlbnMgZnJvbSB0aGUgc2lnbmVyJ3Mgc3RvcmVkIHZhdWx0CiAgICAgIHNlbGYucGF5bWVudFZhdWx0IDwtIHZhdWx0UmVmLndpdGhkcmF3KGFtb3VudDogYW1vdW50KQogIH0KCiAgZXhlY3V0ZSB7CgogICAgICAvLyBHZXQgdGhlIHJlY2lwaWVudCdzIHB1YmxpYyBhY2NvdW50IG9iamVjdAogICAgICBsZXQgcmVjaXBpZW50ID0gZ2V0QWNjb3VudChyZWNlaXZlcikKCiAgICAgIC8vIEdldCBhIHJlZmVyZW5jZSB0byB0aGUgcmVjaXBpZW50J3MgUmVjZWl2ZXIKICAgICAgbGV0IHJlY2VpdmVyUmVmID0gcmVjaXBpZW50LmNhcGFiaWxpdGllcy5nZXQ8JntGdW5naWJsZVRva2VuLlJlY2VpdmVyfT4oc2VsZi52YXVsdERhdGEucmVjZWl2ZXJQYXRoKSEuYm9ycm93KCkKICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IHJlY2VpdmVyIHJlZmVyZW5jZSB0byB0aGUgcmVjaXBpZW50J3MgVmF1bHQiKQoKICAgICAgLy8gRGVwb3NpdCB0aGUgd2l0aGRyYXduIHRva2VucyBpbiB0aGUgcmVjaXBpZW50J3MgcmVjZWl2ZXIKICAgICAgcmVjZWl2ZXJSZWYuZGVwb3NpdChmcm9tOiA8LXNlbGYucGF5bWVudFZhdWx0KQogIH0KfQog", - "sendChildFTWithParent": "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\u003d", - "sendChildNFT": "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", - "sendChildNFTToChild": "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", - "setupOwnedAccount": "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", - "setupOwnedAccountAndPublishToParent": "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", - "transferChildFT": "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\u003d\u003d", - "transferChildNFT": "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\u003d\u003d", - "transferNFTToChild": "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", - "unlinkChildAccount": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgdW5saW5rQ2hpbGRBY2NvdW50IC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgSHlicmlkQ3VzdG9keSBmcm9tIDB4ZDhhN2UwNWE3YWM2NzBjMAoKCnRyYW5zYWN0aW9uKGNoaWxkOiBBZGRyZXNzKSB7CiAgICBwcmVwYXJlIChhY2N0OiBhdXRoKFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IG1hbmFnZXIgPSBhY2N0LnN0b3JhZ2UuYm9ycm93PGF1dGgoSHlicmlkQ3VzdG9keS5NYW5hZ2UpICZIeWJyaWRDdXN0b2R5Lk1hbmFnZXI+KGZyb206IEh5YnJpZEN1c3RvZHkuTWFuYWdlclN0b3JhZ2VQYXRoKQogICAgICAgICAgICA/PyBwYW5pYygibWFuYWdlciBub3QgZm91bmQiKQogICAgICAgIG1hbmFnZXIucmVtb3ZlQ2hpbGQoYWRkcjogY2hpbGQpCiAgICB9Cn0\u003d" - }, - "lostAndFound": { - "claimFT": "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\u003d\u003d", - "claimNFT": "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\u003d", - "queryUnclaimedFTs": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcXVlcnlVbmNsYWltZWRGVHMgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBMb3N0QW5kRm91bmQgZnJvbSAweDQ3M2Q2YTJjMzdlYWI1YmUKCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHI6IEFkZHJlc3MpOiBbQW55U3RydWN0P10gewogICAgbGV0IHRpY2tldHMgPSBMb3N0QW5kRm91bmQuYm9ycm93QWxsVGlja2V0cyhhZGRyOiBhZGRyKQogICAgCiAgICBsZXQgZGlzcGxheUFycjogW0FueVN0cnVjdD9dICA9IFtdCiAgICBmb3IgdGlja2V0IGluIHRpY2tldHMgewogICAgICAgIGlmIHRpY2tldC50eXBlLmlzU3VidHlwZShvZjogVHlwZTxAe0Z1bmdpYmxlVG9rZW4uVmF1bHR9PigpKSB7IAogICAgICAgICAgICBkaXNwbGF5QXJyLmFwcGVuZCh7ImRpc3BsYXkiOiB0aWNrZXQuZGlzcGxheSwgImJhbGFuY2UiOiB0aWNrZXQuZ2V0RnVuZ2libGVUb2tlbkJhbGFuY2UoKX0pCiAgICAgICAgfQogICAgfQogICAgcmV0dXJuIGRpc3BsYXlBcnIKfQ\u003d\u003d", - "queryUnclaimedNFTs": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcXVlcnlVbmNsYWltZWRORlRzIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTG9zdEFuZEZvdW5kIGZyb20gMHg0NzNkNmEyYzM3ZWFiNWJlCgppbXBvcnQgTWV0YWRhdGFWaWV3cyBmcm9tIDB4MWQ3ZTU3YWE1NTgxNzQ0OAoKaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyOiBBZGRyZXNzKTogWyZNZXRhZGF0YVZpZXdzLkRpc3BsYXk/XSB7CiAgICBsZXQgdGlja2V0cyA9IExvc3RBbmRGb3VuZC5ib3Jyb3dBbGxUaWNrZXRzKGFkZHI6IGFkZHIpCiAgICAKICAgIGxldCBkaXNwbGF5QXJyOiBbJk1ldGFkYXRhVmlld3MuRGlzcGxheT9dICA9IFtdCiAgICBmb3IgdGlja2V0IGluIHRpY2tldHMgewogICAgICAgIGlmIHRpY2tldC50eXBlLmlzU3VidHlwZShvZjogVHlwZTxAe05vbkZ1bmdpYmxlVG9rZW4uTkZUfT4oKSkgeyAKICAgICAgICAgICAgZGlzcGxheUFyci5hcHBlbmQodGlja2V0LmRpc3BsYXkpCiAgICAgICAgfQogICAgfQogICAgCiAgICByZXR1cm4gZGlzcGxheUFycgp9", - "queryUnclaimedNumber": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcXVlcnlVbmNsYWltZWROdW1iZXIgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBMb3N0QW5kRm91bmQgZnJvbSAweDQ3M2Q2YTJjMzdlYWI1YmUKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyOiBBZGRyZXNzKTogSW50IHsKICAgIGxldCBzaGVsZk1hbmFnZXIgPSBMb3N0QW5kRm91bmQuYm9ycm93U2hlbGZNYW5hZ2VyKCkKICAgIGxldCBzaGVsZiA9IHNoZWxmTWFuYWdlci5ib3Jyb3dTaGVsZihyZWRlZW1lcjogYWRkcikKICAgIGlmIHNoZWxmID09IG5pbCB7CiAgICAgICAgcmV0dXJuIDAKICAgIH0KICAgIAogICAgcmV0dXJuIHNoZWxmIS5nZXRSZWRlZW1hYmxlVHlwZXMoKS5sZW5ndGgKfQ\u003d\u003d", - "sendFT": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgc2VuZEZUIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgoKaW1wb3J0IEZsb3dUb2tlbiBmcm9tIDB4MTY1NDY1MzM5OTA0MGE2MQoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKCmltcG9ydCBMb3N0QW5kRm91bmQgZnJvbSAweDQ3M2Q2YTJjMzdlYWI1YmUKCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgVmlld1Jlc29sdmVyIGZyb20gMHgxZDdlNTdhYTU1ODE3NDQ4CgppbXBvcnQgRnVuZ2libGVUb2tlbk1ldGFkYXRhVmlld3MgZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKCmltcG9ydCBGbG93RVZNQnJpZGdlVXRpbHMgZnJvbSAweDFlNGFhMGI4N2QxMGIxNDEKCgoKdHJhbnNhY3Rpb24odmF1bHRJZGVudGlmaWVyOiBTdHJpbmcsIHJlY2lwaWVudDogQWRkcmVzcywgYW1vdW50OiBVRml4NjQsIG1lbW86IFN0cmluZykgewogICAgbGV0IHNlbnRWYXVsdDogQHtGdW5naWJsZVRva2VuLlZhdWx0fQogICAgbGV0IGZsb3dQcm92aWRlcjogQ2FwYWJpbGl0eTxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZGbG93VG9rZW4uVmF1bHQ+CiAgICBsZXQgZmxvd1JlY2VpdmVyOiBDYXBhYmlsaXR5PCZGbG93VG9rZW4uVmF1bHQ+CiAgICBsZXQgcmVjZWl2ZXJDYXA6IENhcGFiaWxpdHk8JntGdW5naWJsZVRva2VuLlJlY2VpdmVyfT4KICAgIGxldCBkaXNwbGF5OiBNZXRhZGF0YVZpZXdzLkRpc3BsYXk/CgoKICAgIHByZXBhcmUoYWNjdDogYXV0aChTdG9yYWdlLCBDYXBhYmlsaXRpZXMpICZBY2NvdW50KSB7CiAgICAgICAgIGxldCB2YXVsdFR5cGUgPSBDb21wb3NpdGVUeXBlKHZhdWx0SWRlbnRpZmllcikKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBjb25zdHJ1Y3QgVmF1bHQgdHlwZSBmcm9tIGlkZW50aWZpZXI6ICIuY29uY2F0KHZhdWx0SWRlbnRpZmllcikpCiAgICAgICAgLy8gUGFyc2UgdGhlIFZhdWx0IGlkZW50aWZpZXIgaW50byBpdHMgY29tcG9uZW50cwogICAgICAgIGxldCB0b2tlbkNvbnRyYWN0QWRkcmVzcyA9IEZsb3dFVk1CcmlkZ2VVdGlscy5nZXRDb250cmFjdEFkZHJlc3MoZnJvbVR5cGU6IHZhdWx0VHlwZSkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBnZXQgY29udHJhY3QgYWRkcmVzcyBmcm9tIGlkZW50aWZpZXI6ICIuY29uY2F0KHZhdWx0SWRlbnRpZmllcikpCiAgICAgICAgbGV0IHRva2VuQ29udHJhY3ROYW1lID0gRmxvd0VWTUJyaWRnZVV0aWxzLmdldENvbnRyYWN0TmFtZShmcm9tVHlwZTogdmF1bHRUeXBlKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGdldCBjb250cmFjdCBuYW1lIGZyb20gaWRlbnRpZmllcjogIi5jb25jYXQodmF1bHRJZGVudGlmaWVyKSkKICAgICAgICAKICAgICAgICAvKiAtLS0gUmV0cmlldmUgdGhlIGZ1bmRzIC0tLSAqLwogICAgICAgIC8vCiAgICAgICAgLy8gQm9ycm93IGEgcmVmZXJlbmNlIHRvIHRoZSBGdW5naWJsZVRva2VuIFZhdWx0CiAgICAgICAgbGV0IHZpZXdSZXNvbHZlciA9IGdldEFjY291bnQodG9rZW5Db250cmFjdEFkZHJlc3MpLmNvbnRyYWN0cy5ib3Jyb3c8JntWaWV3UmVzb2x2ZXJ9PihuYW1lOiB0b2tlbkNvbnRyYWN0TmFtZSkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgVmlld1Jlc29sdmVyIGZyb20gRnVuZ2libGVUb2tlbiBjb250cmFjdCIpCiAgICAgICAgbGV0IHZhdWx0RGF0YSA9IHZpZXdSZXNvbHZlci5yZXNvbHZlQ29udHJhY3RWaWV3KAogICAgICAgICAgICAgICAgcmVzb3VyY2VUeXBlOiBuaWwsCiAgICAgICAgICAgICAgICB2aWV3VHlwZTogVHlwZTxGdW5naWJsZVRva2VuTWV0YWRhdGFWaWV3cy5GVFZhdWx0RGF0YT4oKQogICAgICAgICAgICApIGFzISBGdW5naWJsZVRva2VuTWV0YWRhdGFWaWV3cy5GVFZhdWx0RGF0YT8gPz8gcGFuaWMoIkNvdWxkIG5vdCByZXNvbHZlIEZUVmF1bHREYXRhIHZpZXciKQoKCiAgICAgICAgbGV0IHZhdWx0RGlzcGxheSA9IHZpZXdSZXNvbHZlci5yZXNvbHZlQ29udHJhY3RWaWV3KAogICAgICAgICAgICAgICAgcmVzb3VyY2VUeXBlOiBuaWwsCiAgICAgICAgICAgICAgICB2aWV3VHlwZTogVHlwZTxGdW5naWJsZVRva2VuTWV0YWRhdGFWaWV3cy5GVERpc3BsYXk+KCkKICAgICAgICAgICAgKSBhcyEgRnVuZ2libGVUb2tlbk1ldGFkYXRhVmlld3MuRlREaXNwbGF5PyA/PyBwYW5pYygiQ291bGQgbm90IHJlc29sdmUgRlRWYXVsdERhdGEgdmlldyIpCgogICAgICAgIHNlbGYuZGlzcGxheSA9IE1ldGFkYXRhVmlld3MuRGlzcGxheSgKICAgICAgICAgICAgbmFtZTogdmF1bHREaXNwbGF5Lm5hbWUsCiAgICAgICAgICAgIGRlc2NyaXB0aW9uOiB2YXVsdERpc3BsYXkuZGVzY3JpcHRpb24sCiAgICAgICAgICAgIHRodW1ibmFpbDogdmF1bHREaXNwbGF5LmxvZ29zLml0ZW1zWzBdLmZpbGUKICAgICAgICApCgogICAgICAgIGxldCB2YXVsdCA9IGFjY3Quc3RvcmFnZS5ib3Jyb3c8YXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAme0Z1bmdpYmxlVG9rZW4uVmF1bHR9PigKICAgICAgICAgICAgICAgIGZyb206IHZhdWx0RGF0YS5zdG9yYWdlUGF0aAogICAgICAgICAgICApID8/IHBhbmljKCJDb3VsZCBub3QgYWNjZXNzIHNpZ25lcidzIEZ1bmdpYmxlVG9rZW4gVmF1bHQiKQoKICAgICAgICBzZWxmLnNlbnRWYXVsdCA8LSB2YXVsdC53aXRoZHJhdyhhbW91bnQ6IGFtb3VudCkKCiAgICAgICAgdmFyIHByb3ZpZGVyOiBDYXBhYmlsaXR5PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJkZsb3dUb2tlbi5WYXVsdD4/ID0gbmlsCiAgICAgICAgYWNjdC5jYXBhYmlsaXRpZXMuc3RvcmFnZS5mb3JFYWNoQ29udHJvbGxlcihmb3JQYXRoOiAvc3RvcmFnZS9mbG93VG9rZW5WYXVsdCwgZnVuKGM6ICZTdG9yYWdlQ2FwYWJpbGl0eUNvbnRyb2xsZXIpOiBCb29sIHsKICAgICAgICAgICAgaWYgYy5ib3Jyb3dUeXBlID09IFR5cGU8YXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAmRmxvd1Rva2VuLlZhdWx0PigpIHsKICAgICAgICAgICAgICAgIHByb3ZpZGVyID0gYy5jYXBhYmlsaXR5IGFzISBDYXBhYmlsaXR5PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJkZsb3dUb2tlbi5WYXVsdD4KICAgICAgICAgICAgfQogICAgICAgICAgICByZXR1cm4gdHJ1ZQogICAgICAgIH0pCgogICAgICAgIGlmIHByb3ZpZGVyID09IG5pbCB7CiAgICAgICAgICAgIHByb3ZpZGVyID0gYWNjdC5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZGbG93VG9rZW4uVmF1bHQ+KC9zdG9yYWdlL2Zsb3dUb2tlblZhdWx0KQogICAgICAgIH0KICAgICAgICBzZWxmLmZsb3dQcm92aWRlciA9IHByb3ZpZGVyIQogICAgICAgIHNlbGYuZmxvd1JlY2VpdmVyID0gYWNjdC5jYXBhYmlsaXRpZXMuZ2V0PCZGbG93VG9rZW4uVmF1bHQ+KC9wdWJsaWMvZmxvd1Rva2VuUmVjZWl2ZXIpIQogICAgICAgIHNlbGYucmVjZWl2ZXJDYXAgPSBnZXRBY2NvdW50KHJlY2lwaWVudCkuY2FwYWJpbGl0aWVzLmdldDwme0Z1bmdpYmxlVG9rZW4uUmVjZWl2ZXJ9Pih2YXVsdERhdGEucmVjZWl2ZXJQYXRoKSEKICAgIH0KCiAgICBleGVjdXRlIHsKCiAgICAgICAgCiAgICAgICAgbGV0IGRlcG9zaXRFc3RpbWF0ZSA8LSBMb3N0QW5kRm91bmQuZXN0aW1hdGVEZXBvc2l0KHJlZGVlbWVyOiByZWNpcGllbnQsIGl0ZW06IDwtc2VsZi5zZW50VmF1bHQsIG1lbW86IG1lbW8sIGRpc3BsYXk6IHNlbGYuZGlzcGxheSkKICAgICAgICBsZXQgc3RvcmFnZUZlZSA8LSBzZWxmLmZsb3dQcm92aWRlci5ib3Jyb3coKSEud2l0aGRyYXcoYW1vdW50OiBkZXBvc2l0RXN0aW1hdGUuc3RvcmFnZUZlZSkKICAgICAgICBsZXQgaXRlbSA8LSBkZXBvc2l0RXN0aW1hdGUud2l0aGRyYXcoKQoKICAgICAgICBMb3N0QW5kRm91bmQudHJ5U2VuZFJlc291cmNlKAogICAgICAgICAgICBpdGVtOiA8LWl0ZW0sCiAgICAgICAgICAgIGNhcDogc2VsZi5yZWNlaXZlckNhcCwKICAgICAgICAgICAgbWVtbzogbWVtbywKICAgICAgICAgICAgZGlzcGxheTogc2VsZi5kaXNwbGF5LAogICAgICAgICAgICBzdG9yYWdlUGF5bWVudDogJnN0b3JhZ2VGZWUgYXMgYXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAme0Z1bmdpYmxlVG9rZW4uVmF1bHR9LAogICAgICAgICAgICBmbG93VG9rZW5SZXBheW1lbnQ6IHNlbGYuZmxvd1JlY2VpdmVyCiAgICAgICAgKQoKICAgICAgICBzZWxmLmZsb3dSZWNlaXZlci5ib3Jyb3coKSEuZGVwb3NpdChmcm9tOiA8LXN0b3JhZ2VGZWUpCiAgICAgICAgZGVzdHJveSBkZXBvc2l0RXN0aW1hdGUKICAgIH0KfQ\u003d\u003d", - "sendNFT": "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\u003d" - }, - "staking": { - "checkSetup": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY2hlY2tTZXR1cCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dTdGFraW5nQ29sbGVjdGlvbiBmcm9tIDB4OGQwZTg3YjY1MTU5YWU2MwoKCi8vLyBEZXRlcm1pbmVzIGlmIGFuIGFjY291bnQgaXMgc2V0IHVwIHdpdGggYSBTdGFraW5nIENvbGxlY3Rpb24KCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBCb29sIHsKICAgIHJldHVybiBGbG93U3Rha2luZ0NvbGxlY3Rpb24uZG9lc0FjY291bnRIYXZlU3Rha2luZ0NvbGxlY3Rpb24oYWRkcmVzczogYWRkcmVzcykKfQ\u003d\u003d", - "checkStakingEnabled": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY2hlY2tTdGFraW5nRW5hYmxlZCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dJRFRhYmxlU3Rha2luZyBmcm9tIDB4ODYyNGI1MmY5ZGRjZDA0YQoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKCk6Qm9vbCB7CiAgICByZXR1cm4gRmxvd0lEVGFibGVTdGFraW5nLnN0YWtpbmdFbmFibGVkKCkKfQ\u003d\u003d", - "closeStake": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY2xvc2VTdGFrZSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dTdGFraW5nQ29sbGVjdGlvbiBmcm9tIDB4OGQwZTg3YjY1MTU5YWU2MwoKCi8vIENsb3NlcyBvdXQgYSBzdGFraW5nIG9iamVjdCBpbiB0aGUgc3Rha2luZyBjb2xsZWN0aW9uCi8vIFRoaXMgZG9lcyBub3QgcmVtb3ZlIHRoZSByZWNvcmQgZnJvbSB0aGUgaWRlbnRpdHkgdGFibGUsCi8vIGJ1dCBpdCBkb2VzIG1lYW4gdGhhdCB0aGUgYWNjb3VudCB0aGF0IGNsb3NlcyBpdCBjYW5ub3QgZXZlciBhY2Nlc3MgaXQgYWdhaW4KCnRyYW5zYWN0aW9uKG5vZGVJRDogU3RyaW5nLCBkZWxlZ2F0b3JJRDogVUludDMyPykgewogICAgCiAgICBsZXQgc3Rha2luZ0NvbGxlY3Rpb25SZWY6IGF1dGgoRmxvd1N0YWtpbmdDb2xsZWN0aW9uLkNvbGxlY3Rpb25Pd25lcikgJkZsb3dTdGFraW5nQ29sbGVjdGlvbi5TdGFraW5nQ29sbGVjdGlvbgoKICAgIHByZXBhcmUoYWNjb3VudDogYXV0aChCb3Jyb3dWYWx1ZSkgJkFjY291bnQpIHsKICAgICAgICBzZWxmLnN0YWtpbmdDb2xsZWN0aW9uUmVmID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzxhdXRoKEZsb3dTdGFraW5nQ29sbGVjdGlvbi5Db2xsZWN0aW9uT3duZXIpICZGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb24+KGZyb206IEZsb3dTdGFraW5nQ29sbGVjdGlvbi5TdGFraW5nQ29sbGVjdGlvblN0b3JhZ2VQYXRoKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBhIHJlZmVyZW5jZSB0byBhIFN0YWtpbmdDb2xsZWN0aW9uIGluIHRoZSBwcmltYXJ5IHVzZXIncyBhY2NvdW50IikKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBzZWxmLnN0YWtpbmdDb2xsZWN0aW9uUmVmLmNsb3NlU3Rha2Uobm9kZUlEOiBub2RlSUQsIGRlbGVnYXRvcklEOiBkZWxlZ2F0b3JJRCkKICAgIH0KfQ\u003d\u003d", - "createDelegator": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY3JlYXRlRGVsZWdhdG9yIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd1N0YWtpbmdDb2xsZWN0aW9uIGZyb20gMHg4ZDBlODdiNjUxNTlhZTYzCgoKLy8vIFJlZ2lzdGVycyBhIGRlbGVnYXRvciBpbiB0aGUgc3Rha2luZyBjb2xsZWN0aW9uIHJlc291cmNlCi8vLyBmb3IgdGhlIHNwZWNpZmllZCBub2RlSUQgYW5kIHRoZSBhbW91bnQgb2YgdG9rZW5zIHRvIGNvbW1pdAoKdHJhbnNhY3Rpb24oaWQ6IFN0cmluZywgYW1vdW50OiBVRml4NjQpIHsKICAgIAogICAgbGV0IHN0YWtpbmdDb2xsZWN0aW9uUmVmOiBhdXRoKEZsb3dTdGFraW5nQ29sbGVjdGlvbi5Db2xsZWN0aW9uT3duZXIpICZGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb24KCiAgICBwcmVwYXJlKGFjY291bnQ6IGF1dGgoQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZiA9IGFjY291bnQuc3RvcmFnZS5ib3Jyb3c8YXV0aChGbG93U3Rha2luZ0NvbGxlY3Rpb24uQ29sbGVjdGlvbk93bmVyKSAmRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uPihmcm9tOiBGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb25TdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgYSByZWZlcmVuY2UgdG8gYSBTdGFraW5nQ29sbGVjdGlvbiBpbiB0aGUgcHJpbWFyeSB1c2VyJ3MgYWNjb3VudCIpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZi5yZWdpc3RlckRlbGVnYXRvcihub2RlSUQ6IGlkLCBhbW91bnQ6IGFtb3VudCkgICAgICAKICAgIH0KfQ\u003d\u003d", - "createStake": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgY3JlYXRlU3Rha2UgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGbG93U3Rha2luZ0NvbGxlY3Rpb24gZnJvbSAweDhkMGU4N2I2NTE1OWFlNjMKCgovLy8gQ29tbWl0cyBuZXcgdG9rZW5zIHRvIHN0YWtlIGZvciB0aGUgc3BlY2lmaWVkIG5vZGUgb3IgZGVsZWdhdG9yIGluIHRoZSBzdGFraW5nIGNvbGxlY3Rpb24KLy8vIFRoZSB0b2tlbnMgZnJvbSB0aGUgbG9ja2VkIHZhdWx0IGFyZSB1c2VkIGZpcnN0LCBpZiBpdCBleGlzdHMKLy8vIGZvbGxvd2VkIGJ5IHRoZSB0b2tlbnMgZnJvbSB0aGUgdW5sb2NrZWQgdmF1bHQKCnRyYW5zYWN0aW9uKG5vZGVJRDogU3RyaW5nLCBkZWxlZ2F0b3JJRDogVUludDMyPywgYW1vdW50OiBVRml4NjQpIHsKICAgIAogICAgbGV0IHN0YWtpbmdDb2xsZWN0aW9uUmVmOiBhdXRoKEZsb3dTdGFraW5nQ29sbGVjdGlvbi5Db2xsZWN0aW9uT3duZXIpICZGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb24KCiAgICBwcmVwYXJlKGFjY291bnQ6IGF1dGgoQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZiA9IGFjY291bnQuc3RvcmFnZS5ib3Jyb3c8YXV0aChGbG93U3Rha2luZ0NvbGxlY3Rpb24uQ29sbGVjdGlvbk93bmVyKSAmRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uPihmcm9tOiBGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb25TdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgYSByZWZlcmVuY2UgdG8gYSBTdGFraW5nQ29sbGVjdGlvbiBpbiB0aGUgcHJpbWFyeSB1c2VyJ3MgYWNjb3VudCIpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZi5zdGFrZU5ld1Rva2Vucyhub2RlSUQ6IG5vZGVJRCwgZGVsZWdhdG9ySUQ6IGRlbGVnYXRvcklELCBhbW91bnQ6IGFtb3VudCkKICAgIH0KfQ\u003d\u003d", - "getApr": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QXByIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd0lEVGFibGVTdGFraW5nIGZyb20gMHg4NjI0YjUyZjlkZGNkMDRhCgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oKTogVUZpeDY0IHsKICAgIGxldCBhcHIgPSBGbG93SURUYWJsZVN0YWtpbmcuZ2V0RXBvY2hUb2tlblBheW91dCgpIC8gRmxvd0lEVGFibGVTdGFraW5nLmdldFRvdGFsU3Rha2VkKCkgLyA3LjAgKiAzNjUuMCAqICgxLjAgLSBGbG93SURUYWJsZVN0YWtpbmcuZ2V0UmV3YXJkQ3V0UGVyY2VudGFnZSgpKQogICAgcmV0dXJuIGFwcgp9", - "getApyWeekly": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QXB5V2Vla2x5IC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd0lEVGFibGVTdGFraW5nIGZyb20gMHg4NjI0YjUyZjlkZGNkMDRhCgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oKTogVUZpeDY0IHsKICAgIGxldCBhcHIgPSBGbG93SURUYWJsZVN0YWtpbmcuZ2V0RXBvY2hUb2tlblBheW91dCgpIC8gRmxvd0lEVGFibGVTdGFraW5nLmdldFRvdGFsU3Rha2VkKCkgKiA1NC4wICogKDEuMCAtIEZsb3dJRFRhYmxlU3Rha2luZy5nZXRSZXdhcmRDdXRQZXJjZW50YWdlKCkpCiAgICByZXR1cm4gYXByCn0\u003d", - "getDelegatesIndo": "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\u003d\u003d", - "getDelegatesInfo": "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", - "getDelegatesInfoArray": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0RGVsZWdhdGVzSW5mb0FycmF5IC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgoKaW1wb3J0IEZsb3dTdGFraW5nQ29sbGVjdGlvbiBmcm9tIDB4OGQwZTg3YjY1MTU5YWU2MwoKaW1wb3J0IEZsb3dJRFRhYmxlU3Rha2luZyBmcm9tIDB4ODYyNGI1MmY5ZGRjZDA0YQoKaW1wb3J0IExvY2tlZFRva2VucyBmcm9tIDB4OGQwZTg3YjY1MTU5YWU2MwoKICAgICAgICAKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IFtGbG93SURUYWJsZVN0YWtpbmcuRGVsZWdhdG9ySW5mb10gewogICAgcmV0dXJuIEZsb3dTdGFraW5nQ29sbGVjdGlvbi5nZXRBbGxEZWxlZ2F0b3JJbmZvKGFkZHJlc3M6IGFkZHJlc3MpCn0\u003d", - "getDelegatesInfoArrayV2": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0RGVsZWdhdGVzSW5mb0FycmF5VjIgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCgppbXBvcnQgRmxvd1N0YWtpbmdDb2xsZWN0aW9uIGZyb20gMHg4ZDBlODdiNjUxNTlhZTYzCgppbXBvcnQgRmxvd0lEVGFibGVTdGFraW5nIGZyb20gMHg4NjI0YjUyZjlkZGNkMDRhCgppbXBvcnQgTG9ja2VkVG9rZW5zIGZyb20gMHg4ZDBlODdiNjUxNTlhZTYzCgogICAgICAgIAphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzKTogW0Zsb3dJRFRhYmxlU3Rha2luZy5EZWxlZ2F0b3JJbmZvXT8gewogICAgdmFyIHJlczogW0Zsb3dJRFRhYmxlU3Rha2luZy5EZWxlZ2F0b3JJbmZvXT8gPSBuaWwKCiAgICBsZXQgaW5pdGVkID0gRmxvd1N0YWtpbmdDb2xsZWN0aW9uLmRvZXNBY2NvdW50SGF2ZVN0YWtpbmdDb2xsZWN0aW9uKGFkZHJlc3M6IGFkZHJlc3MpCgogICAgaWYgaW5pdGVkIHsKICAgICAgICByZXMgPSBGbG93U3Rha2luZ0NvbGxlY3Rpb24uZ2V0QWxsRGVsZWdhdG9ySW5mbyhhZGRyZXNzOiBhZGRyZXNzKQogICAgfQogICAgcmV0dXJuIHJlcwp9", - "getDelegatesInfoV2": "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\u003d", - "getDelegatorInfo": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0RGVsZWdhdG9ySW5mbyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dJRFRhYmxlU3Rha2luZyBmcm9tIDB4ODYyNGI1MmY5ZGRjZDA0YQoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKG5vZGVJRDogU3RyaW5nLCBkZWxlZ2F0b3JJRDogVUludDMyKTogRmxvd0lEVGFibGVTdGFraW5nLkRlbGVnYXRvckluZm8gewogIHJldHVybiBGbG93SURUYWJsZVN0YWtpbmcuRGVsZWdhdG9ySW5mbyhub2RlSUQ6IG5vZGVJRCwgZGVsZWdhdG9ySUQ6IGRlbGVnYXRvcklEKQp9", - "getEpochMetadata": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0RXBvY2hNZXRhZGF0YSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dFcG9jaCBmcm9tIDB4ODYyNGI1MmY5ZGRjZDA0YQoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGVwb2NoQ291bnRlcjogVUludDY0KTogRmxvd0Vwb2NoLkVwb2NoTWV0YWRhdGEgewogICAgcmV0dXJuIEZsb3dFcG9jaC5nZXRFcG9jaE1ldGFkYXRhKGVwb2NoQ291bnRlcikhCn0\u003d", - "getNodeInfo": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0Tm9kZUluZm8gLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGbG93SURUYWJsZVN0YWtpbmcgZnJvbSAweDg2MjRiNTJmOWRkY2QwNGEKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihub2RlSUQ6IFN0cmluZyk6IEZsb3dJRFRhYmxlU3Rha2luZy5Ob2RlSW5mbyB7CiAgcmV0dXJuIEZsb3dJRFRhYmxlU3Rha2luZy5Ob2RlSW5mbyhub2RlSUQ6IG5vZGVJRCkKfQ\u003d\u003d", - "getNodesInfo": "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", - "getStakeInfo": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0U3Rha2VJbmZvIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgoKaW1wb3J0IEZsb3dTdGFraW5nQ29sbGVjdGlvbiBmcm9tIDB4OGQwZTg3YjY1MTU5YWU2MwoKaW1wb3J0IEZsb3dJRFRhYmxlU3Rha2luZyBmcm9tIDB4ODYyNGI1MmY5ZGRjZDA0YQoKaW1wb3J0IExvY2tlZFRva2VucyBmcm9tIDB4OGQwZTg3YjY1MTU5YWU2MwoKCmFjY2VzcyhhbGwpIHN0cnVjdCBTdGFrZUluZm8gewogICAgYWNjZXNzKGFsbCkgbGV0IGlkOiBTdHJpbmcKICAgIGFjY2VzcyhhbGwpIGxldCByb2xlOiBVSW50OAogICAgYWNjZXNzKGFsbCkgbGV0IG5ldHdvcmtpbmdBZGRyZXNzOiBTdHJpbmcKICAgIGFjY2VzcyhhbGwpIGxldCBuZXR3b3JraW5nS2V5OiBTdHJpbmcKICAgIGFjY2VzcyhhbGwpIGxldCBzdGFraW5nS2V5OiBTdHJpbmcKICAgIGFjY2VzcyhhbGwpIGxldCB0b2tlbnNTdGFrZWQ6IFVGaXg2NAogICAgYWNjZXNzKGFsbCkgbGV0IHRvdGFsVG9rZW5zU3Rha2VkOiBVRml4NjQKICAgIGFjY2VzcyhhbGwpIGxldCB0b2tlbnNDb21taXR0ZWQ6IFVGaXg2NAogICAgYWNjZXNzKGFsbCkgbGV0IHRva2Vuc1Vuc3Rha2luZzogVUZpeDY0CiAgICBhY2Nlc3MoYWxsKSBsZXQgdG9rZW5zVW5zdGFrZWQ6IFVGaXg2NAogICAgYWNjZXNzKGFsbCkgbGV0IHRva2Vuc1Jld2FyZGVkOiBVRml4NjQKCiAgICBhY2Nlc3MoYWxsKSBsZXQgZGVsZWdhdG9yc0NudDogSW50CiAgICBhY2Nlc3MoYWxsKSBsZXQgZGVsZWdhdG9ySURDb3VudGVyOiBVSW50MzIKICAgIGFjY2VzcyhhbGwpIGxldCB0b2tlbnNSZXF1ZXN0ZWRUb1Vuc3Rha2U6IFVGaXg2NAogICAgYWNjZXNzKGFsbCkgbGV0IGluaXRpYWxXZWlnaHQ6IFVJbnQ2NAoKICAgIC8vIFByb2plY3RlZCBWYWx1ZXMKICAgIGFjY2VzcyhhbGwpIGxldCBub2RlSUQ6IFN0cmluZwogICAgYWNjZXNzKGFsbCkgbGV0IHVuc3Rha2FibGVUb2tlbnM6IFVGaXg2NAogICAgYWNjZXNzKGFsbCkgbGV0IHRva2Vuc0RlbGVnYXRlZDogVUZpeDY0CiAgICBhY2Nlc3MoYWxsKSBsZXQgcmVzdGFrYWJsZVVuc3Rha2VkVG9rZW5zOiBVRml4NjQKCiAgICBhY2Nlc3MoYWxsKSBsZXQgbWFjaGluZUFjY291bnRBZGRyZXNzOiBBZGRyZXNzPwogICAgYWNjZXNzKGFsbCkgbGV0IG1hY2hpbmVBY2NvdW50QmFsYW5jZTogVUZpeDY0PwoKICAgIGluaXQobm9kZUluZm86IEZsb3dJRFRhYmxlU3Rha2luZy5Ob2RlSW5mbywgbWFjaGluZUFjY291bnRJbmZvOiBGbG93U3Rha2luZ0NvbGxlY3Rpb24uTWFjaGluZUFjY291bnRJbmZvPykgewogICAgICAgIHNlbGYuaWQgPSBub2RlSW5mby5pZAogICAgICAgIHNlbGYucm9sZSA9IG5vZGVJbmZvLnJvbGUKICAgICAgICBzZWxmLm5ldHdvcmtpbmdBZGRyZXNzID0gbm9kZUluZm8ubmV0d29ya2luZ0FkZHJlc3MKICAgICAgICBzZWxmLm5ldHdvcmtpbmdLZXkgPSBub2RlSW5mby5uZXR3b3JraW5nS2V5CiAgICAgICAgc2VsZi5zdGFraW5nS2V5ID0gbm9kZUluZm8uc3Rha2luZ0tleQogICAgICAgIHNlbGYudG9rZW5zU3Rha2VkID0gbm9kZUluZm8udG9rZW5zU3Rha2VkCiAgICAgICAgc2VsZi50b3RhbFRva2Vuc1N0YWtlZCA9IG5vZGVJbmZvLnRvdGFsU3Rha2VkV2l0aERlbGVnYXRvcnMoKQogICAgICAgIHNlbGYudG9rZW5zQ29tbWl0dGVkID0gbm9kZUluZm8udG9rZW5zQ29tbWl0dGVkCiAgICAgICAgc2VsZi50b2tlbnNVbnN0YWtpbmcgPSBub2RlSW5mby50b2tlbnNVbnN0YWtpbmcKICAgICAgICBzZWxmLnRva2Vuc1Vuc3Rha2VkID0gbm9kZUluZm8udG9rZW5zVW5zdGFrZWQKICAgICAgICBzZWxmLnRva2Vuc1Jld2FyZGVkID0gbm9kZUluZm8udG9rZW5zUmV3YXJkZWQKCiAgICAgICAgc2VsZi5kZWxlZ2F0b3JzQ250ID0gbm9kZUluZm8uZGVsZWdhdG9ycy5sZW5ndGggCiAgICAgICAgc2VsZi5kZWxlZ2F0b3JJRENvdW50ZXIgPSBub2RlSW5mby5kZWxlZ2F0b3JJRENvdW50ZXIKICAgICAgICBzZWxmLnRva2Vuc1JlcXVlc3RlZFRvVW5zdGFrZSA9IG5vZGVJbmZvLnRva2Vuc1JlcXVlc3RlZFRvVW5zdGFrZQogICAgICAgIHNlbGYuaW5pdGlhbFdlaWdodCA9IG5vZGVJbmZvLmluaXRpYWxXZWlnaHQKCiAgICAgICAgLy8gUHJvamVjdGVkIFZhbHVlcwogICAgICAgIHNlbGYubm9kZUlEID0gbm9kZUluZm8uaWQKICAgICAgICBzZWxmLnVuc3Rha2FibGVUb2tlbnMgPSBzZWxmLnRva2Vuc1N0YWtlZCArIHNlbGYudG9rZW5zQ29tbWl0dGVkCiAgICAgICAgbGV0IG5vZGVTdGFrZWRCYWxhbmNlV2l0aERlbGVnYXRvcnMgPSBub2RlSW5mby50b3RhbFN0YWtlZFdpdGhEZWxlZ2F0b3JzKCkKICAgICAgICBzZWxmLnRva2Vuc0RlbGVnYXRlZCA9IG5vZGVTdGFrZWRCYWxhbmNlV2l0aERlbGVnYXRvcnMgLSBub2RlSW5mby50b2tlbnNTdGFrZWQKICAgICAgICBzZWxmLnJlc3Rha2FibGVVbnN0YWtlZFRva2VucyA9IHNlbGYudG9rZW5zVW5zdGFrZWQgKyBzZWxmLnRva2Vuc1JlcXVlc3RlZFRvVW5zdGFrZQoKICAgICAgICBpZiBsZXQgX21hY2hpbmVBY2NvdW50SW5mbyA9IG1hY2hpbmVBY2NvdW50SW5mbyB7CiAgICAgICAgICAgIGxldCBfbWFjaGluZUFjY291bnRBZGRyZXNzID0gX21hY2hpbmVBY2NvdW50SW5mby5nZXRBZGRyZXNzKCkKCiAgICAgICAgICAgIGxldCBtYWNoaW5lQWNjb3VudCA9IGdldEFjY291bnQoX21hY2hpbmVBY2NvdW50QWRkcmVzcykKCiAgICAgICAgICAgIHNlbGYubWFjaGluZUFjY291bnRBZGRyZXNzID0gX21hY2hpbmVBY2NvdW50QWRkcmVzcwogICAgICAgICAgICBzZWxmLm1hY2hpbmVBY2NvdW50QmFsYW5jZSA9IG1hY2hpbmVBY2NvdW50LmJhbGFuY2UKICAgICAgICB9IGVsc2UgewogICAgICAgICAgICBzZWxmLm1hY2hpbmVBY2NvdW50QWRkcmVzcyA9IG5pbAogICAgICAgICAgICBzZWxmLm1hY2hpbmVBY2NvdW50QmFsYW5jZSA9IG5pbAogICAgICAgIH0KICAgIH0KfQoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWNjb3VudDogQWRkcmVzcyk6IHtTdHJpbmc6IFN0YWtlSW5mb30/IHsKICAgIGxldCBkb2VzQWNjb3VudEhhdmVTdGFraW5nQ29sbGVjdGlvbiA9IEZsb3dTdGFraW5nQ29sbGVjdGlvbi5kb2VzQWNjb3VudEhhdmVTdGFraW5nQ29sbGVjdGlvbihhZGRyZXNzOiBhY2NvdW50KQogICAgaWYgKCFkb2VzQWNjb3VudEhhdmVTdGFraW5nQ29sbGVjdGlvbikgewogICAgICAgIHJldHVybiBuaWwKICAgIH0KCiAgICBsZXQgZm9ybWF0dGVkTm9kZUluZm86IHtTdHJpbmc6IFN0YWtlSW5mb30gPSB7fQogICAgbGV0IGFsbE5vZGVJbmZvOiBbRmxvd0lEVGFibGVTdGFraW5nLk5vZGVJbmZvXSA9IEZsb3dTdGFraW5nQ29sbGVjdGlvbi5nZXRBbGxOb2RlSW5mbyhhZGRyZXNzOiBhY2NvdW50KQogICAgbGV0IG1hY2hpbmVBY2NvdW50czoge1N0cmluZzogRmxvd1N0YWtpbmdDb2xsZWN0aW9uLk1hY2hpbmVBY2NvdW50SW5mb30gPSBGbG93U3Rha2luZ0NvbGxlY3Rpb24uZ2V0TWFjaGluZUFjY291bnRzKGFkZHJlc3M6IGFjY291bnQpCgogICAgZm9yIG5vZGVJbmZvIGluIGFsbE5vZGVJbmZvIHsKICAgICAgICBmb3JtYXR0ZWROb2RlSW5mb1tub2RlSW5mby5pZF0gPSBTdGFrZUluZm8obm9kZUluZm86IG5vZGVJbmZvLCBtYWNoaW5lQWNjb3VudEluZm86IG1hY2hpbmVBY2NvdW50c1tub2RlSW5mby5pZF0pCiAgICB9CgogICAgcmV0dXJuIGZvcm1hdHRlZE5vZGVJbmZvCn0K", - "getStakingInfo": "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", - "restakeReward": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcmVzdGFrZVJld2FyZCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKIGltcG9ydCBGbG93U3Rha2luZ0NvbGxlY3Rpb24gZnJvbSAweDhkMGU4N2I2NTE1OWFlNjMKCgovLy8gQ29tbWl0cyByZXdhcmRlZCB0b2tlbnMgdG8gc3Rha2UgZm9yIHRoZSBzcGVjaWZpZWQgbm9kZSBvciBkZWxlZ2F0b3IgaW4gdGhlIHN0YWtpbmcgY29sbGVjdGlvbgoKdHJhbnNhY3Rpb24obm9kZUlEOiBTdHJpbmcsIGRlbGVnYXRvcklEOiBVSW50MzI/LCBhbW91bnQ6IFVGaXg2NCkgewogICAgCiAgICBsZXQgc3Rha2luZ0NvbGxlY3Rpb25SZWY6IGF1dGgoRmxvd1N0YWtpbmdDb2xsZWN0aW9uLkNvbGxlY3Rpb25Pd25lcikgJkZsb3dTdGFraW5nQ29sbGVjdGlvbi5TdGFraW5nQ29sbGVjdGlvbgoKICAgIHByZXBhcmUoYWNjb3VudDogYXV0aChCb3Jyb3dWYWx1ZSkgJkFjY291bnQpIHsKICAgICAgICBzZWxmLnN0YWtpbmdDb2xsZWN0aW9uUmVmID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzxhdXRoKEZsb3dTdGFraW5nQ29sbGVjdGlvbi5Db2xsZWN0aW9uT3duZXIpICZGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb24+KGZyb206IEZsb3dTdGFraW5nQ29sbGVjdGlvbi5TdGFraW5nQ29sbGVjdGlvblN0b3JhZ2VQYXRoKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBhIHJlZmVyZW5jZSB0byBhIFN0YWtpbmdDb2xsZWN0aW9uIGluIHRoZSBwcmltYXJ5IHVzZXIncyBhY2NvdW50IikKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBzZWxmLnN0YWtpbmdDb2xsZWN0aW9uUmVmLnN0YWtlUmV3YXJkZWRUb2tlbnMobm9kZUlEOiBub2RlSUQsIGRlbGVnYXRvcklEOiBkZWxlZ2F0b3JJRCwgYW1vdW50OiBhbW91bnQpCiAgICB9Cn0\u003d", - "restakeUnstaked": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcmVzdGFrZVVuc3Rha2VkIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd1N0YWtpbmdDb2xsZWN0aW9uIGZyb20gMHg4ZDBlODdiNjUxNTlhZTYzCgoKLy8vIENvbW1pdHMgdW5zdGFrZWQgdG9rZW5zIHRvIHN0YWtlIGZvciB0aGUgc3BlY2lmaWVkIG5vZGUgb3IgZGVsZWdhdG9yIGluIHRoZSBzdGFraW5nIGNvbGxlY3Rpb24KCnRyYW5zYWN0aW9uKG5vZGVJRDogU3RyaW5nLCBkZWxlZ2F0b3JJRDogVUludDMyPywgYW1vdW50OiBVRml4NjQpIHsKICAgIAogICAgbGV0IHN0YWtpbmdDb2xsZWN0aW9uUmVmOiBhdXRoKEZsb3dTdGFraW5nQ29sbGVjdGlvbi5Db2xsZWN0aW9uT3duZXIpICZGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb24KCiAgICBwcmVwYXJlKGFjY291bnQ6IGF1dGgoQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZiA9IGFjY291bnQuc3RvcmFnZS5ib3Jyb3c8YXV0aChGbG93U3Rha2luZ0NvbGxlY3Rpb24uQ29sbGVjdGlvbk93bmVyKSAmRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uPihmcm9tOiBGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb25TdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgYSByZWZlcmVuY2UgdG8gYSBTdGFraW5nQ29sbGVjdGlvbiBpbiB0aGUgcHJpbWFyeSB1c2VyJ3MgYWNjb3VudCIpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZi5zdGFrZVVuc3Rha2VkVG9rZW5zKG5vZGVJRDogbm9kZUlELCBkZWxlZ2F0b3JJRDogZGVsZWdhdG9ySUQsIGFtb3VudDogYW1vdW50KQogICAgfQp9", - "setup": "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\u003d", - "unstake": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgdW5zdGFrZSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKIGltcG9ydCBGbG93U3Rha2luZ0NvbGxlY3Rpb24gZnJvbSAweDhkMGU4N2I2NTE1OWFlNjMKCgovLy8gUmVxdWVzdHMgdW5zdGFraW5nIGZvciB0aGUgc3BlY2lmaWVkIG5vZGUgb3IgZGVsZWdhdG9yIGluIHRoZSBzdGFraW5nIGNvbGxlY3Rpb24KCnRyYW5zYWN0aW9uKG5vZGVJRDogU3RyaW5nLCBkZWxlZ2F0b3JJRDogVUludDMyPywgYW1vdW50OiBVRml4NjQpIHsKICAgIAogICAgbGV0IHN0YWtpbmdDb2xsZWN0aW9uUmVmOiBhdXRoKEZsb3dTdGFraW5nQ29sbGVjdGlvbi5Db2xsZWN0aW9uT3duZXIpICZGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb24KCiAgICBwcmVwYXJlKGFjY291bnQ6IGF1dGgoQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZiA9IGFjY291bnQuc3RvcmFnZS5ib3Jyb3c8YXV0aChGbG93U3Rha2luZ0NvbGxlY3Rpb24uQ29sbGVjdGlvbk93bmVyKSAmRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uPihmcm9tOiBGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb25TdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgYSByZWZlcmVuY2UgdG8gYSBTdGFraW5nQ29sbGVjdGlvbiBpbiB0aGUgcHJpbWFyeSB1c2VyJ3MgYWNjb3VudCIpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZi5yZXF1ZXN0VW5zdGFraW5nKG5vZGVJRDogbm9kZUlELCBkZWxlZ2F0b3JJRDogZGVsZWdhdG9ySUQsIGFtb3VudDogYW1vdW50KQogICAgfQp9", - "withdrawLocked": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgd2l0aGRyYXdMb2NrZWQgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhGVU5HSUJMRVRPS0VOQUREUkVTUwppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHhGTE9XVE9LRU5BRERSRVNTCmltcG9ydCBMb2NrZWRUb2tlbnMgZnJvbSAweExPQ0tFRFRPS0VOQUREUkVTUwoKdHJhbnNhY3Rpb24oYW1vdW50OiBVRml4NjQpIHsKCiAgICBsZXQgaG9sZGVyUmVmOiBhdXRoKExvY2tlZFRva2Vucy5Ub2tlbk9wZXJhdGlvbnMsIEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZMb2NrZWRUb2tlbnMuVG9rZW5Ib2xkZXIKICAgIGxldCB2YXVsdFJlZjogYXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAmRmxvd1Rva2VuLlZhdWx0CgogICAgcHJlcGFyZShhY2N0OiBhdXRoKEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgIHNlbGYuaG9sZGVyUmVmID0gYWNjdC5zdG9yYWdlLmJvcnJvdzxhdXRoKExvY2tlZFRva2Vucy5Ub2tlbk9wZXJhdGlvbnMsIEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZMb2NrZWRUb2tlbnMuVG9rZW5Ib2xkZXI+KGZyb206IExvY2tlZFRva2Vucy5Ub2tlbkhvbGRlclN0b3JhZ2VQYXRoKQogICAgICAgICAgICA/PyBwYW5pYygiVGhlIHByaW1hcnkgdXNlciBhY2NvdW50IGRvZXMgbm90IGhhdmUgYW4gYXNzb2NpYXRlZCBsb2NrZWQgYWNjb3VudCIpCgogICAgICAgIHNlbGYudmF1bHRSZWYgPSBhY2N0LnN0b3JhZ2UuYm9ycm93PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJkZsb3dUb2tlbi5WYXVsdD4oZnJvbTogL3N0b3JhZ2UvZmxvd1Rva2VuVmF1bHQpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IGZsb3cgdG9rZW4gdmF1bHQgcmVmIikKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBzZWxmLnZhdWx0UmVmLmRlcG9zaXQoZnJvbTogPC1zZWxmLmhvbGRlclJlZi53aXRoZHJhdyhhbW91bnQ6IGFtb3VudCkpCiAgICB9Cn0\u003d", - "withdrawReward": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgd2l0aGRyYXdSZXdhcmQgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGbG93U3Rha2luZ0NvbGxlY3Rpb24gZnJvbSAweDhkMGU4N2I2NTE1OWFlNjMKCgovLy8gUmVxdWVzdCB0byB3aXRoZHJhdyByZXdhcmRlZCB0b2tlbnMgZm9yIHRoZSBzcGVjaWZpZWQgbm9kZSBvciBkZWxlZ2F0b3IgaW4gdGhlIHN0YWtpbmcgY29sbGVjdGlvbgovLy8gVGhlIHRva2VucyBhcmUgYXV0b21hdGljYWxseSBkZXBvc2l0ZWQgdG8gdGhlIHVubG9ja2VkIGFjY291bnQgdmF1bHQgZmlyc3QsCi8vLyBBbmQgdGhlbiBhbnkgbG9ja2VkIHRva2VucyBhcmUgZGVwb3NpdGVkIGludG8gdGhlIGxvY2tlZCBhY2NvdW50IHZhdWx0Cgp0cmFuc2FjdGlvbihub2RlSUQ6IFN0cmluZywgZGVsZWdhdG9ySUQ6IFVJbnQzMj8sIGFtb3VudDogVUZpeDY0KSB7CiAgICAKICAgIGxldCBzdGFraW5nQ29sbGVjdGlvblJlZjogYXV0aChGbG93U3Rha2luZ0NvbGxlY3Rpb24uQ29sbGVjdGlvbk93bmVyKSAmRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uCgogICAgcHJlcGFyZShhY2NvdW50OiBhdXRoKEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgIHNlbGYuc3Rha2luZ0NvbGxlY3Rpb25SZWYgPSBhY2NvdW50LnN0b3JhZ2UuYm9ycm93PGF1dGgoRmxvd1N0YWtpbmdDb2xsZWN0aW9uLkNvbGxlY3Rpb25Pd25lcikgJkZsb3dTdGFraW5nQ29sbGVjdGlvbi5TdGFraW5nQ29sbGVjdGlvbj4oZnJvbTogRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uU3RvcmFnZVBhdGgpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IGEgcmVmZXJlbmNlIHRvIGEgU3Rha2luZ0NvbGxlY3Rpb24gaW4gdGhlIHByaW1hcnkgdXNlcidzIGFjY291bnQiKQogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIHNlbGYuc3Rha2luZ0NvbGxlY3Rpb25SZWYud2l0aGRyYXdSZXdhcmRlZFRva2Vucyhub2RlSUQ6IG5vZGVJRCwgZGVsZWdhdG9ySUQ6IGRlbGVnYXRvcklELCBhbW91bnQ6IGFtb3VudCkKICAgIH0KfQ\u003d\u003d", - "withdrawUnstaked": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgd2l0aGRyYXdVbnN0YWtlZCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKIGltcG9ydCBGbG93U3Rha2luZ0NvbGxlY3Rpb24gZnJvbSAweDhkMGU4N2I2NTE1OWFlNjMKCgovLy8gUmVxdWVzdCB0byB3aXRoZHJhdyB1bnN0YWtlZCB0b2tlbnMgZm9yIHRoZSBzcGVjaWZpZWQgbm9kZSBvciBkZWxlZ2F0b3IgaW4gdGhlIHN0YWtpbmcgY29sbGVjdGlvbgovLy8gVGhlIHRva2VucyBhcmUgYXV0b21hdGljYWxseSBkZXBvc2l0ZWQgdG8gdGhlIHVubG9ja2VkIGFjY291bnQgdmF1bHQgZmlyc3QsCi8vLyBBbmQgdGhlbiBhbnkgbG9ja2VkIHRva2VucyBhcmUgZGVwb3NpdGVkIGludG8gdGhlIGxvY2tlZCBhY2NvdW50IHZhdWx0IGlmIGl0IGlzIHRoZXJlCgp0cmFuc2FjdGlvbihub2RlSUQ6IFN0cmluZywgZGVsZWdhdG9ySUQ6IFVJbnQzMj8sIGFtb3VudDogVUZpeDY0KSB7CiAgICAKICAgIGxldCBzdGFraW5nQ29sbGVjdGlvblJlZjogYXV0aChGbG93U3Rha2luZ0NvbGxlY3Rpb24uQ29sbGVjdGlvbk93bmVyKSAmRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uCgogICAgcHJlcGFyZShhY2NvdW50OiBhdXRoKEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgIHNlbGYuc3Rha2luZ0NvbGxlY3Rpb25SZWYgPSBhY2NvdW50LnN0b3JhZ2UuYm9ycm93PGF1dGgoRmxvd1N0YWtpbmdDb2xsZWN0aW9uLkNvbGxlY3Rpb25Pd25lcikgJkZsb3dTdGFraW5nQ29sbGVjdGlvbi5TdGFraW5nQ29sbGVjdGlvbj4oZnJvbTogRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uU3RvcmFnZVBhdGgpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IGEgcmVmZXJlbmNlIHRvIGEgU3Rha2luZ0NvbGxlY3Rpb24gaW4gdGhlIHByaW1hcnkgdXNlcidzIGFjY291bnQiKQogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIHNlbGYuc3Rha2luZ0NvbGxlY3Rpb25SZWYud2l0aGRyYXdVbnN0YWtlZFRva2Vucyhub2RlSUQ6IG5vZGVJRCwgZGVsZWdhdG9ySUQ6IGRlbGVnYXRvcklELCBhbW91bnQ6IGFtb3VudCkKICAgIH0KfQ\u003d\u003d" - }, - "storage": { - "enableTokenStorage": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZW5hYmxlVG9rZW5TdG9yYWdlIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKaW1wb3J0IDxUb2tlbj4gZnJvbSA8VG9rZW5BZGRyZXNzPgoKdHJhbnNhY3Rpb24gewoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIENhcGFiaWxpdGllcykgJkFjY291bnQpIHsKCiAgICAgICAgaWYgc2lnbmVyLnN0b3JhZ2UuYm9ycm93PCY8VG9rZW4+LlZhdWx0Pihmcm9tOiA8VG9rZW5TdG9yYWdlUGF0aD4gKSA9PSBuaWwgewogICAgICAgICAgICBzaWduZXIuc3RvcmFnZS5zYXZlKDwtIDxUb2tlbj4uY3JlYXRlRW1wdHlWYXVsdCh2YXVsdFR5cGU6IFR5cGU8QDxUb2tlbj4uVmF1bHQ+KCkpLCB0bzogPFRva2VuU3RvcmFnZVBhdGg+KQogICAgICAgIH0KCiAgICAgICAgaWYgc2lnbmVyLmNhcGFiaWxpdGllcy5leGlzdHMoPFRva2VuUmVjZWl2ZXJQYXRoPikgPT0gZmFsc2UgewogICAgICAgICAgICBsZXQgcmVjZWl2ZXJDYXBhYmlsaXR5ID0gc2lnbmVyLmNhcGFiaWxpdGllcy5zdG9yYWdlLmlzc3VlPCY8VG9rZW4+LlZhdWx0Pig8VG9rZW5TdG9yYWdlUGF0aD4pCiAgICAgICAgICAgIHNpZ25lci5jYXBhYmlsaXRpZXMucHVibGlzaChyZWNlaXZlckNhcGFiaWxpdHksIGF0OiA8VG9rZW5SZWNlaXZlclBhdGg+KQogICAgICAgIAogICAgICAgIH0KICAgICAgIAogICAgICAgIGlmIHNpZ25lci5jYXBhYmlsaXRpZXMuZXhpc3RzKDxUb2tlbkJhbGFuY2VQYXRoPikgPT0gZmFsc2UgewogICAgICAgICAgICBsZXQgYmFsYW5jZUNhcGFiaWxpdHkgPSBzaWduZXIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8JjxUb2tlbj4uVmF1bHQ+KDxUb2tlblN0b3JhZ2VQYXRoPikKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5wdWJsaXNoKGJhbGFuY2VDYXBhYmlsaXR5LCBhdDogPFRva2VuQmFsYW5jZVBhdGg+KQogICAgICAgIH0KICAgIAogICAgfQp9", - "enableTokenStorageV2": "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\u003d\u003d", - "getBasicPublicItems": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0QmFzaWNQdWJsaWNJdGVtcyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKYWNjZXNzKGFsbClzdHJ1Y3QgSXRlbSB7CiAgYWNjZXNzKGFsbClsZXQgYWRkcmVzczogQWRkcmVzcwogIGFjY2VzcyhhbGwpbGV0IHBhdGg6IFN0cmluZwogIGFjY2VzcyhhbGwpbGV0IHRhcmdldFBhdGg6IFN0cmluZz8KCiAgaW5pdChhZGRyZXNzOiBBZGRyZXNzLCBwYXRoOiBTdHJpbmcsIHRhcmdldFBhdGg6IFN0cmluZz8pIHsKICAgIHNlbGYuYWRkcmVzcyA9IGFkZHJlc3MKICAgIHNlbGYucGF0aCA9IHBhdGgKICAgIHNlbGYudGFyZ2V0UGF0aCA9IHRhcmdldFBhdGgKICB9Cn0KCmFjY2VzcyhhbGwpZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IFtJdGVtXSB7CiAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgbGV0IGl0ZW1zOiBbSXRlbV0gPSBbXQoKCiAgZnVuIGVhY2hQYXRoKHBhdGg6IFB1YmxpY1BhdGgsIGNhcFR5cGU6IFR5cGUpOiBCb29sIHsKICAgIC8vIHRvZG8KICAgIGxldCBjYXAgPSBhY2NvdW50LmNhcGFiaWxpdGllcy5nZXQ8JkFueVN0cnVjdD4ocGF0aCkKICAgIHZhciB0YXJnZXRQYXRoID0gIiIKCiAgICBpZiBjYXAgIT0gbmlsIHsKICAgICAgdGFyZ2V0UGF0aCA9ICIxMiIgCiAgICB9CiAgICBsZXQgaXRlbSA9IEl0ZW0oYWRkcmVzczogYWRkcmVzcywgcGF0aDogcGF0aC50b1N0cmluZygpLCB0YXJnZXRQYXRoOiB0YXJnZXRQYXRoKQogICAgaXRlbXMuYXBwZW5kKGl0ZW0pCiAgICByZXR1cm4gdHJ1ZQogIH0KICBhY2NvdW50LnN0b3JhZ2UuZm9yRWFjaFB1YmxpYyhlYWNoUGF0aCkKCiAgcmV0dXJuIGl0ZW1zCn0\u003d", - "getPrivateItems": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0UHJpdmF0ZUl0ZW1zIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgphY2Nlc3MoYWxsKXN0cnVjdCBJdGVtIHsKICBhY2Nlc3MoYWxsKWxldCBhZGRyZXNzOiBBZGRyZXNzCiAgYWNjZXNzKGFsbClsZXQgcGF0aDogU3RyaW5nCiAgYWNjZXNzKGFsbClsZXQgdHlwZTogVHlwZQogIGFjY2VzcyhhbGwpbGV0IHRhcmdldFBhdGg6IFN0cmluZz8KCiAgaW5pdCgKICAgIGFkZHJlc3M6IEFkZHJlc3MsIAogICAgcGF0aDogU3RyaW5nLCAKICAgIHR5cGU6IFR5cGUsIAogICAgdGFyZ2V0UGF0aDogU3RyaW5nPwogICkgewogICAgc2VsZi5hZGRyZXNzID0gYWRkcmVzcwogICAgc2VsZi5wYXRoID0gcGF0aAogICAgc2VsZi50eXBlID0gdHlwZQogICAgc2VsZi50YXJnZXRQYXRoID0gdGFyZ2V0UGF0aAogIH0KfQoKYWNjZXNzKGFsbClmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzLCBwYXRoTWFwOiB7U3RyaW5nOiBCb29sfSk6IFtJdGVtXSB7CiAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCgogIGxldCBpdGVtczogW0l0ZW1dID0gW10KCiAgYWNjb3VudC5zdG9yYWdlLmZvckVhY2hQcml2YXRlKGZ1biAocGF0aDogUHJpdmF0ZVBhdGgsIHR5cGU6IFR5cGUpOiBCb29sIHsKICAgIGlmICFwYXRoTWFwLmNvbnRhaW5zS2V5KHBhdGgudG9TdHJpbmcoKSkgewogICAgICByZXR1cm4gdHJ1ZQogICAgfQoKICAgIHZhciB0YXJnZXRQYXRoOiBTdHJpbmc/ID0gbmlsCiAgICBpZiBsZXQgdGFyZ2V0ID0gYWNjb3VudC5nZXRMaW5rVGFyZ2V0KHBhdGgpIHsKICAgICAgdGFyZ2V0UGF0aCA9IHRhcmdldC50b1N0cmluZygpCiAgICB9CgogICAgbGV0IGl0ZW0gPSBJdGVtKAogICAgICBhZGRyZXNzOiBhZGRyZXNzLAogICAgICBwYXRoOiBwYXRoLnRvU3RyaW5nKCksCiAgICAgIHR5cGU6IHR5cGUsCiAgICAgIHRhcmdldFBhdGg6IHRhcmdldFBhdGgKICAgICkKCiAgICBpdGVtcy5hcHBlbmQoaXRlbSkKICAgIHJldHVybiB0cnVlCiAgfSkKCiAgcmV0dXJuIGl0ZW1zCn0\u003d", - "getPrivatePaths": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0UHJpdmF0ZVBhdGhzIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgphY2Nlc3MoYWxsKWZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBbUHJpdmF0ZVBhdGhdIHsKICBsZXQgYWNjb3VudCA9IGdldEF1dGhBY2NvdW50KGFkZHJlc3MpCiAgbGV0IGNsZWFuZFBhdGhzOiBbUHJpdmF0ZVBhdGhdID0gW10KICBmb3IgcGF0aCBpbiBhY2NvdW50LnByaXZhdGVQYXRocyB7CiAgICBjbGVhbmRQYXRocy5hcHBlbmQocGF0aCkKICB9CiAgcmV0dXJuIGNsZWFuZFBhdGhzCn0\u003d", - "getPublicItem": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0UHVibGljSXRlbSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKLy8gQSB3b3JrYXJvdW5kIG1ldGhvZAppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCiAgCmFjY2VzcyhhbGwpIHN0cnVjdCBJdGVtIHsKICBhY2Nlc3MoYWxsKSBsZXQgYWRkcmVzczogQWRkcmVzcwogIGFjY2VzcyhhbGwpIGxldCBwYXRoOiBTdHJpbmcKICBhY2Nlc3MoYWxsKSBsZXQgdHlwZTogVHlwZQoKICBhY2Nlc3MoYWxsKSBsZXQgdGFyZ2V0UGF0aDogU3RyaW5nPwoKICBpbml0KAogICAgYWRkcmVzczogQWRkcmVzcywgCiAgICBwYXRoOiBTdHJpbmcsIAogICAgdHlwZTogVHlwZSwgCiAgICB0YXJnZXRQYXRoOiBTdHJpbmc/CiAgKSB7CiAgICBzZWxmLmFkZHJlc3MgPSBhZGRyZXNzCiAgICBzZWxmLnBhdGggPSBwYXRoCiAgICBzZWxmLnR5cGUgPSB0eXBlCiAgICBzZWxmLnRhcmdldFBhdGggPSB0YXJnZXRQYXRoCiAgfQp9CgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzLCBwYXRoTWFwOiB7U3RyaW5nOiBCb29sfSk6IFtJdGVtXSB7CiAgbGV0IGFjY291bnQgPSBnZXRBdXRoQWNjb3VudChhZGRyZXNzKQoKICBsZXQgaXRlbXM6IFtJdGVtXSA9IFtdCiAgYWNjb3VudC5mb3JFYWNoUHVibGljKGZ1biAocGF0aDogUHVibGljUGF0aCwgdHlwZTogVHlwZSk6IEJvb2wgewogICAgaWYgIXBhdGhNYXAuY29udGFpbnNLZXkocGF0aC50b1N0cmluZygpKSB7CiAgICAgIHJldHVybiB0cnVlCiAgICB9CgogICAgdmFyIHRhcmdldFBhdGg6IFN0cmluZz8gPSBuaWwKCiAgICBpZiBsZXQgdGFyZ2V0ID0gYWNjb3VudC5nZXRMaW5rVGFyZ2V0KHBhdGgpIHsKICAgICAgdGFyZ2V0UGF0aCA9IHRhcmdldC50b1N0cmluZygpCiAgICB9CgogICAgbGV0IGl0ZW0gPSBJdGVtKAogICAgICBhZGRyZXNzOiBhZGRyZXNzLAogICAgICBwYXRoOiBwYXRoLnRvU3RyaW5nKCksCiAgICAgIHR5cGU6IHR5cGUsCiAgICAgIHRhcmdldFBhdGg6IHRhcmdldFBhdGgKICAgICkKCiAgICBpdGVtcy5hcHBlbmQoaXRlbSkKICAgIHJldHVybiBmYWxzZQogIH0pCgogIHJldHVybiBpdGVtcwp9", - "getPublicItems": "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\u003d\u003d", - "getPublicPaths": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0UHVibGljUGF0aHMgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCnB1YiBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzKTogW1B1YmxpY1BhdGhdIHsKICBsZXQgYWNjb3VudCA9IGdldEF1dGhBY2NvdW50KGFkZHJlc3MpCiAgbGV0IGNsZWFuZFBhdGhzOiBbUHVibGljUGF0aF0gPSBbXQogIGZvciBwYXRoIGluIGFjY291bnQucHVibGljUGF0aHMgewogICAgY2xlYW5kUGF0aHMuYXBwZW5kKHBhdGgpCiAgfQogIHJldHVybiBjbGVhbmRQYXRocwp9", - "getStoragePaths": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0U3RvcmFnZVBhdGhzIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgpwdWIgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IFtTdG9yYWdlUGF0aF0gewogIGxldCBhY2NvdW50ID0gZ2V0QXV0aEFjY291bnQoYWRkcmVzcykKICBsZXQgY2xlYW5kUGF0aHM6IFtTdG9yYWdlUGF0aF0gPSBbXQogIGZvciBwYXRoIGluIGFjY291bnQuc3RvcmFnZVBhdGhzIHsKICAgIGNsZWFuZFBhdGhzLmFwcGVuZChwYXRoKQogIH0KICByZXR1cm4gY2xlYW5kUGF0aHMKfQ\u003d\u003d", - "getStoredItems": "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", - "getStoredResource": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0U3RvcmVkUmVzb3VyY2UgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCnB1YiBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzLCBwYXRoU3RyOiBTdHJpbmcpOiAmQW55UmVzb3VyY2U/IHsKICBsZXQgYWNjb3VudCA9IGdldEF1dGhBY2NvdW50KGFkZHJlc3MpCiAgbGV0IHBhdGggPSBTdG9yYWdlUGF0aChpZGVudGlmaWVyOiBwYXRoU3RyKSEKICByZXR1cm4gYWNjb3VudC5ib3Jyb3c8JkFueVJlc291cmNlPihmcm9tOiBwYXRoKQp9", - "getStoredStruct": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgZ2V0U3RvcmVkU3RydWN0IC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgpwdWIgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcywgcGF0aFN0cjogU3RyaW5nKTogJkFueVN0cnVjdD8gewogIGxldCBhY2NvdW50ID0gZ2V0QXV0aEFjY291bnQoYWRkcmVzcykKICBsZXQgcGF0aCA9IFN0b3JhZ2VQYXRoKGlkZW50aWZpZXI6IHBhdGhTdHIpIQogIHJldHVybiBhY2NvdW50LmJvcnJvdzwmQW55U3RydWN0Pihmcm9tOiBwYXRoKQp9" - }, - "temp": { - "addKeys": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgYWRkS2V5cyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IENyeXB0bwoKdHJhbnNhY3Rpb24ocHVibGljS2V5OiBTdHJpbmcpIHsKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKEtleXMpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IGtleSA9IFB1YmxpY0tleSgKICAgICAgICAgICAgcHVibGljS2V5OiBwdWJsaWNLZXkuZGVjb2RlSGV4KCksCiAgICAgICAgICAgIHNpZ25hdHVyZUFsZ29yaXRobTogU2lnbmF0dXJlQWxnb3JpdGhtKHJhd1ZhbHVlOiAxKSEKICAgICAgICApCiAgICAgICAgdmFyIGlkeCA9IDAKICAgICAgICB3aGlsZSBpZHggPCA5OSB7CiAgICAgICAgICAgIHNpZ25lci5rZXlzLmFkZCgKICAgICAgICAgICAgICAgIHB1YmxpY0tleToga2V5LAogICAgICAgICAgICAgICAgaGFzaEFsZ29yaXRobTogSGFzaEFsZ29yaXRobShyYXdWYWx1ZTogMSkhLAogICAgICAgICAgICAgICAgd2VpZ2h0OiAxMDAwLjAKICAgICAgICAgICAgKQogICAgICAgICAgICBpZHggPSBpZHggKyAxCiAgICAgICAgfQogICAgICAgCiAgICB9Cn0\u003d", - "claim": "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\u003d", - "createAccount": "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", - "hcPublish": "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\u003d\u003d", - "mintNFT": "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\u003d\u003d", - "onboardEvmToFlow": "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", - "queryBall": "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\u003d", - "queryBals": "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\u003d\u003d", - "queryCeCheck": "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\u003d\u003d", - "queryEnable": "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\u003d\u003d", - "relinkVault": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcmVsaW5rVmF1bHQgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCmltcG9ydCBjZVdFVEggZnJvbSAweDIzMWNjMGRiYmNmZmM0YjcKCnRyYW5zYWN0aW9uIHsKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChTdG9yYWdlLCBDYXBhYmlsaXRpZXMpICZBY2NvdW50KSB7CgoKICAgICAgICBzaWduZXIuY2FwYWJpbGl0aWVzLnVucHVibGlzaCgvcHVibGljL2NlV0VUSFJlY2VpdmVyKQogICAgICAgIGxldCByZWNlaXZlckNhcGFiaWxpdHkgPSBzaWduZXIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8JmNlV0VUSC5WYXVsdD4oL3N0b3JhZ2UvY2VXRVRIVmF1bHQpCiAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5wdWJsaXNoKHJlY2VpdmVyQ2FwYWJpbGl0eSwgYXQ6IC9wdWJsaWMvY2VXRVRIUmVjZWl2ZXIpCiAgICAgICAgCgogICAgICAgCiAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy51bnB1Ymxpc2goL3B1YmxpYy9jZVdFVEhCYWxhbmNlKQogICAgICAgIGxldCBiYWxhbmNlQ2FwYWJpbGl0eSA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTwmY2VXRVRILlZhdWx0Pigvc3RvcmFnZS9jZVdFVEhWYXVsdCkKICAgICAgICAKICAgICAgICBzaWduZXIuY2FwYWJpbGl0aWVzLnB1Ymxpc2goYmFsYW5jZUNhcGFiaWxpdHksIGF0OiAvcHVibGljL2NlV0VUSEJhbGFuY2UpCiAgICAKICAgIH0KfQ\u003d\u003d", - "rmChild": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgcm1DaGlsZCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEh5YnJpZEN1c3RvZHkgZnJvbSAweDI5NGU0NGUxZWM2OTkzYzYKCnRyYW5zYWN0aW9uKGNoaWxkOiBBZGRyZXNzKSB7CiAgICBwcmVwYXJlIChhY2N0OiBhdXRoKFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IG1hbmFnZXIgPSBhY2N0LnN0b3JhZ2UuYm9ycm93PGF1dGgoSHlicmlkQ3VzdG9keS5NYW5hZ2UpICZIeWJyaWRDdXN0b2R5Lk1hbmFnZXI+KGZyb206IEh5YnJpZEN1c3RvZHkuTWFuYWdlclN0b3JhZ2VQYXRoKQogICAgICAgICAgICA/PyBwYW5pYygibWFuYWdlciBub3QgZm91bmQiKQogICAgICAgIG1hbmFnZXIucmVtb3ZlQ2hpbGQoYWRkcjogY2hpbGQpCiAgICB9Cn0\u003d", - "setupFTProvider": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgc2V0dXBGVFByb3ZpZGVyIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKCmltcG9ydCBGdW5naWJsZVRva2VuTWV0YWRhdGFWaWV3cyBmcm9tIDB4ZjIzM2RjZWU4OGZlMGFiZQoKaW1wb3J0IDxUb2tlbj4gZnJvbSA8VG9rZW5BZGRyZXNzPgoKdHJhbnNhY3Rpb24gewogICAgcHJlcGFyZShhY2N0OiBhdXRoKENhcGFiaWxpdGllcykgJkFjY291bnQpIHsKICAgICAgICBsZXQgdmF1bHREYXRhID0gRXhhbXBsZVRva2VuLnJlc29sdmVDb250cmFjdFZpZXcocmVzb3VyY2VUeXBlOiBuaWwsIHZpZXdUeXBlOiBUeXBlPEZ1bmdpYmxlVG9rZW5NZXRhZGF0YVZpZXdzLkZUVmF1bHREYXRhPigpKSBhcyEgRnVuZ2libGVUb2tlbk1ldGFkYXRhVmlld3MuRlRWYXVsdERhdGE/CiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgZ2V0IHRoZSB2YXVsdCBkYXRhIHZpZXcgZm9yIEV4YW1wbGVUb2tlbiIpCiAgICAKICAgICAgICBhY2N0LmNhcGFiaWxpdGllcy5zdG9yYWdlLmlzc3VlPGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntGdW5naWJsZVRva2VuLlByb3ZpZGVyfT4odmF1bHREYXRhLnN0b3JhZ2VQYXRoKQogICAgfQp9CiA\u003d", - "setupNFTFull": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgc2V0dXBORlRGdWxsIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4MWQ3ZTU3YWE1NTgxNzQ0OAoKaW1wb3J0IE1ldGFkYXRhVmlld3MgZnJvbSAweDFkN2U1N2FhNTU4MTc0NDgKCgppbXBvcnQgPFRva2VuPiBmcm9tIDxUb2tlbkFkZHJlc3M+Cgp0cmFuc2FjdGlvbiB7CiAgICBwcmVwYXJlKGFjY3Q6IGF1dGgoU3RvcmFnZSwgQ2FwYWJpbGl0aWVzKSAmQWNjb3VudCkgewogICAgICAgIGxldCBkID0gRXhhbXBsZU5GVC5yZXNvbHZlQ29udHJhY3RWaWV3KHJlc291cmNlVHlwZTogbmlsLCB2aWV3VHlwZTogVHlwZTxNZXRhZGF0YVZpZXdzLk5GVENvbGxlY3Rpb25EYXRhPigpKSEgYXMhIE1ldGFkYXRhVmlld3MuTkZUQ29sbGVjdGlvbkRhdGEKCiAgICAgICAgaWYgYWNjdC5zdG9yYWdlLmJvcnJvdzwmRXhhbXBsZU5GVC5Db2xsZWN0aW9uPihmcm9tOiBkLnN0b3JhZ2VQYXRoKSA9PSBuaWwgewogICAgICAgICAgICBhY2N0LnN0b3JhZ2Uuc2F2ZSg8LSBFeGFtcGxlTkZULmNyZWF0ZUVtcHR5Q29sbGVjdGlvbigpLCB0bzogRXhhbXBsZU5GVC5Db2xsZWN0aW9uU3RvcmFnZVBhdGgpCiAgICAgICAgfQoKICAgICAgICBhY2N0LmNhcGFiaWxpdGllcy51bnB1Ymxpc2goZC5wdWJsaWNQYXRoKQogICAgICAgIGxldCBjYXAgPSBhY2N0LmNhcGFiaWxpdGllcy5zdG9yYWdlLmlzc3VlPCZ7RXhhbXBsZU5GVC5FeGFtcGxlTkZUQ29sbGVjdGlvblB1YmxpYywgTm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9uUHVibGljfT4oZC5zdG9yYWdlUGF0aCkKICAgICAgICBhY2N0LmNhcGFiaWxpdGllcy5wdWJsaXNoKGNhcCwgYXQ6IGQucHVibGljUGF0aCkKCiAgICAgICAgYWNjdC5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTxhdXRoKE5vbkZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RXhhbXBsZU5GVC5FeGFtcGxlTkZUQ29sbGVjdGlvblB1YmxpYywgTm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9uUHVibGljLCBOb25GdW5naWJsZVRva2VuLlByb3ZpZGVyfT4oZC5zdG9yYWdlUGF0aCkKICAgIH0KfQo\u003d", - "test": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgdGVzdCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoK", - "transWeth": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgdHJhbnNXZXRoIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgovLyBGbG93IFdhbGxldCAtIG1haW5uZXQgU2NyaXB0ICB0cmFuc2ZlclRva2VucyAtIHYyLjQyCi8vIEV4dGVuc2lvbi0yLjUuMjIKCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCmltcG9ydCBjZVdFVEggZnJvbSAweDIzMWNjMGRiYmNmZmM0YjcKCnRyYW5zYWN0aW9uKGFtb3VudDogVUZpeDY0LCByZWNpcGllbnQ6IEFkZHJlc3MpIHsKCi8vIFRoZSBWYXVsdCByZXNvdXJjZSB0aGF0IGhvbGRzIHRoZSB0b2tlbnMgdGhhdCBhcmUgYmVpbmcgdHJhbnNmZXJlZApsZXQgc2VudFZhdWx0OiBAe0Z1bmdpYmxlVG9rZW4uVmF1bHR9CgpwcmVwYXJlKHNpZ25lcjogYXV0aChTdG9yYWdlLCBCb3Jyb3dWYWx1ZSkgJkFjY291bnQpIHsKICAgICAvLyBHZXQgYSByZWZlcmVuY2UgdG8gdGhlIHNpZ25lcidzIHN0b3JlZCB2YXVsdAogICAgbGV0IHZhdWx0UmVmID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJmNlV0VUSC5WYXVsdD4oZnJvbTogL3N0b3JhZ2UvY2VXRVRIVmF1bHQpCiAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgcmVmZXJlbmNlIHRvIHRoZSBvd25lcidzIFZhdWx0ISIpCgogICAgLy8gV2l0aGRyYXcgdG9rZW5zIGZyb20gdGhlIHNpZ25lcidzIHN0b3JlZCB2YXVsdAogICAgc2VsZi5zZW50VmF1bHQgPC0gdmF1bHRSZWYud2l0aGRyYXcoYW1vdW50OiBhbW91bnQpCn0KCmV4ZWN1dGUgewogICAgLy8gR2V0IHRoZSByZWNpcGllbnQncyBwdWJsaWMgYWNjb3VudCBvYmplY3QKICAgIGxldCByZWNpcGllbnRBY2NvdW50ID0gZ2V0QWNjb3VudChyZWNpcGllbnQpCgogICAgLy8gR2V0IGEgcmVmZXJlbmNlIHRvIHRoZSByZWNpcGllbnQncyBSZWNlaXZlcgogICAgbGV0IHJlY2VpdmVyUmVmID0gcmVjaXBpZW50QWNjb3VudC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5WYXVsdH0+KC9wdWJsaWMvY2VXRVRIVmF1bHQpIQogICAgICAgIAogICAgLy8gRGVwb3NpdCB0aGUgd2l0aGRyYXduIHRva2VucyBpbiB0aGUgcmVjaXBpZW50J3MgcmVjZWl2ZXIKICAgIHJlY2VpdmVyUmVmLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKfQp9", - "transferTokens": "Ly8gRmxvdyBXYWxsZXQgLSBtYWlubmV0IFNjcmlwdCAgdHJhbnNmZXJUb2tlbnMgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHgxNjU0NjUzMzk5MDQwYTYxCgoKdHJhbnNhY3Rpb24ocmVjaXBpZW50OiBBZGRyZXNzLCBhbW91bnQ6IFVGaXg2NCkgewogICAgLy8gVGhlIFZhdWx0IHJlc291cmNlIHRoYXQgaG9sZHMgdGhlIHRva2VucyB0aGF0IGFyZSBiZWluZyB0cmFuc2ZlcmVkCiAgICBsZXQgc2VudFZhdWx0OiBAe0Z1bmdpYmxlVG9rZW4uVmF1bHR9CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChTdG9yYWdlLCBCb3Jyb3dWYWx1ZSkgJkFjY291bnQpIHsKICAgICAgICAgLy8gR2V0IGEgcmVmZXJlbmNlIHRvIHRoZSBzaWduZXIncyBzdG9yZWQgdmF1bHQKICAgICAgICBsZXQgdmF1bHRSZWYgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAmRmxvd1Rva2VuLlZhdWx0Pihmcm9tOiAvc3RvcmFnZS9GbG93VG9rZW5WYXVsdCkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgcmVmZXJlbmNlIHRvIHRoZSBvd25lcidzIFZhdWx0ISIpCgogICAgICAgIC8vIFdpdGhkcmF3IHRva2VucyBmcm9tIHRoZSBzaWduZXIncyBzdG9yZWQgdmF1bHQKICAgICAgICBzZWxmLnNlbnRWYXVsdCA8LSB2YXVsdFJlZi53aXRoZHJhdyhhbW91bnQ6IGFtb3VudCkKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICAvLyBHZXQgdGhlIHJlY2lwaWVudCdzIHB1YmxpYyBhY2NvdW50IG9iamVjdAogICAgICAgIGxldCByZWNpcGllbnRBY2NvdW50ID0gZ2V0QWNjb3VudChyZWNpcGllbnQpCgogICAgICAgIC8vIEdldCBhIHJlZmVyZW5jZSB0byB0aGUgcmVjaXBpZW50J3MgUmVjZWl2ZXIKICAgICAgICBsZXQgcmVjZWl2ZXJSZWYgPSByZWNpcGllbnRBY2NvdW50LmNhcGFiaWxpdGllcy5ib3Jyb3c8JntGdW5naWJsZVRva2VuLlJlY2VpdmVyfT4oL3B1YmxpYy9GbG93VG9rZW5SZWNlaXZlcikhCiAgICAgICAgICAgIAogICAgICAgIC8vIERlcG9zaXQgdGhlIHdpdGhkcmF3biB0b2tlbnMgaW4gdGhlIHJlY2lwaWVudCdzIHJlY2VpdmVyCiAgICAgICAgcmVjZWl2ZXJSZWYuZGVwb3NpdChmcm9tOiA8LXNlbGYuc2VudFZhdWx0KQogICAgfQp9" - } + "version": "1.0" }, "testnet": { - "version": "1.0", - "ft": { - "isTokenListEnabled": "
    // Flow Wallet - testnet Script  isTokenListEnabled - v2.72
// <platform_info>


    import FungibleToken from 0x9a0766d93b6608b7


    
    access(all) fun checkFiatToken0xa983fecbed621163Vault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/USDCVaultReceiver)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/USDCVaultBalance)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkFlovatarDustToken0x9392a4a7c3f49a0bVault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/FlovatarDustTokenReceiver)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/FlovatarDustTokenBalance)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkFlowToken0x7e60df042a9c0868Vault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/flowTokenReceiver)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/flowTokenBalance)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkUSDCFlow0x64adf39cbc354fcbVault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/usdcFlowReceiver)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/usdcFlowMetadata)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkstFlowToken0xe45c64ecfe31e465Vault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/stFlowTokenReceiver)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/stFlowTokenBalance)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkCosmicGATE0x00af2ab363fa49e4Vault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/CosmicGATEReceiver)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/CosmicGATEVault)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkSUGOI0x566c813b3632783eVault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/SUGOIReceiver)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/SUGOIBalance)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkEVMVMBridgedToken_1119ca4d5145432b7b1cd197d136da15e236e8960xdfc20aee650fcbdfVault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/EVMVMBridgedToken_1119ca4d5145432b7b1cd197d136da15e236e896Receiver)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/EVMVMBridgedToken_1119ca4d5145432b7b1cd197d136da15e236e896Vault)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkMEDI0x566c813b3632783eVault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/MEDI24KaratReceiver)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/MEDI24KaratBalance)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkDapperUtilityCoin0x82ec283f88a62e65Vault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/dapperUtilityCoinReceiver)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/dapperUtilityCoinReceiver)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkKarat0x566c813b3632783eVault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/karatReceiver003)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/karatBalance003)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkKaratv20x566c813b3632783eVault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/karatv2Receiver003)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/karatv2Balance003)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkKARATZ1LXGPK0x566c813b3632783eVault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/KARATZ1LXGPKReceiver)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/KARATZ1LXGPKBalance)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkKARATZ1JXDXD0x566c813b3632783eVault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/KARATZ1JXDXDReceiver)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/KARATZ1JXDXDBalance)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkKARATZ1TEFQ20x566c813b3632783eVault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/KARATZ1TEFQ2Receiver)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/KARATZ1TEFQ2Balance)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkTeleportedTetherToken0x2d270db9ac8c7fefVault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/teleportedTetherTokenReceiver)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/teleportedTetherTokenBalance)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkStarlyToken0xf63219072aaddd50Vault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/starlyTokenReceiver)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/starlyTokenBalance)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkBloctoToken0x653cfe36d146e7beVault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/bloctoTokenReceiver)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/bloctoTokenBalance)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkGOWTKN20x566c813b3632783eVault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/KRTKNGOWTKN2Receiver)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/KRTKNGOWTKN2Balance)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkKARATMDV9T0x566c813b3632783eVault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/KARATMDV9TReceiver)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/KARATMDV9TBalance)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkJOSHIN0x566c813b3632783eVault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/JOSHIN24KaratReceiver)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/JOSHIN24KaratBalance)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkKARAT2EA28H0x566c813b3632783eVault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/KARAT2EA28HReceiver)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/KARAT2EA28HBalance)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkDOGETKN0x566c813b3632783eVault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/DOGETKNReceiver)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/DOGETKNBalance)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkTSTCON0x566c813b3632783eVault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/TSTCONReceiver)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/TSTCONBalance)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkaiSportsJuice0xf8ba321af4bd37bbVault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/aiSportsJuiceReceiver)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/aiSportsJuiceMetadata)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkDWLC0x566c813b3632783eVault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/DWLCReceiver)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/DWLCBalance)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkNocenix0xa622afad07f6739eVault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/NocenixReceiver)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/NocenixVault)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkFooToken0x432050232f9a49e7Vault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/fooTokenVault)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/fooTokenVault)
      let flag = receiver && balance
       return flag
    }
    

    access(all) fun checkSorachi0x566c813b3632783eVault(address: Address) : Bool {
      let receiver: Bool = getAccount(address)
      .capabilities.exists(/public/sorachiReceiver)
      let balance: Bool = getAccount(address)
       .capabilities.exists(/public/sorachiBalance)
      let flag = receiver && balance
       return flag
    }
    
    access(all) fun main(address: Address) : {String: Bool} {
      return {
    "A.a983fecbed621163.FiatToken" :
    checkFiatToken0xa983fecbed621163Vault(address: address)
    ,
    "A.9392a4a7c3f49a0b.FlovatarDustToken" :
    checkFlovatarDustToken0x9392a4a7c3f49a0bVault(address: address)
    ,
    "A.7e60df042a9c0868.FlowToken" :
    checkFlowToken0x7e60df042a9c0868Vault(address: address)
    ,
    "A.64adf39cbc354fcb.USDCFlow" :
    checkUSDCFlow0x64adf39cbc354fcbVault(address: address)
    ,
    "A.e45c64ecfe31e465.stFlowToken" :
    checkstFlowToken0xe45c64ecfe31e465Vault(address: address)
    ,
    "A.00af2ab363fa49e4.CosmicGATE" :
    checkCosmicGATE0x00af2ab363fa49e4Vault(address: address)
    ,
    "A.566c813b3632783e.SUGOI" :
    checkSUGOI0x566c813b3632783eVault(address: address)
    ,
    "A.dfc20aee650fcbdf.EVMVMBridgedToken_1119ca4d5145432b7b1cd197d136da15e236e896" :
    checkEVMVMBridgedToken_1119ca4d5145432b7b1cd197d136da15e236e8960xdfc20aee650fcbdfVault(address: address)
    ,
    "A.566c813b3632783e.MEDI" :
    checkMEDI0x566c813b3632783eVault(address: address)
    ,
    "A.82ec283f88a62e65.DapperUtilityCoin" :
    checkDapperUtilityCoin0x82ec283f88a62e65Vault(address: address)
    ,
    "A.566c813b3632783e.Karat" :
    checkKarat0x566c813b3632783eVault(address: address)
    ,
    "A.566c813b3632783e.Karatv2" :
    checkKaratv20x566c813b3632783eVault(address: address)
    ,
    "A.566c813b3632783e.KARATZ1LXGPK" :
    checkKARATZ1LXGPK0x566c813b3632783eVault(address: address)
    ,
    "A.566c813b3632783e.KARATZ1JXDXD" :
    checkKARATZ1JXDXD0x566c813b3632783eVault(address: address)
    ,
    "A.566c813b3632783e.KARATZ1TEFQ2" :
    checkKARATZ1TEFQ20x566c813b3632783eVault(address: address)
    ,
    "A.2d270db9ac8c7fef.TeleportedTetherToken" :
    checkTeleportedTetherToken0x2d270db9ac8c7fefVault(address: address)
    ,
    "A.f63219072aaddd50.StarlyToken" :
    checkStarlyToken0xf63219072aaddd50Vault(address: address)
    ,
    "A.653cfe36d146e7be.BloctoToken" :
    checkBloctoToken0x653cfe36d146e7beVault(address: address)
    ,
    "A.566c813b3632783e.GOWTKN2" :
    checkGOWTKN20x566c813b3632783eVault(address: address)
    ,
    "A.566c813b3632783e.KARATMDV9T" :
    checkKARATMDV9T0x566c813b3632783eVault(address: address)
    ,
    "A.566c813b3632783e.JOSHIN" :
    checkJOSHIN0x566c813b3632783eVault(address: address)
    ,
    "A.566c813b3632783e.KARAT2EA28H" :
    checkKARAT2EA28H0x566c813b3632783eVault(address: address)
    ,
    "A.566c813b3632783e.DOGETKN" :
    checkDOGETKN0x566c813b3632783eVault(address: address)
    ,
    "A.566c813b3632783e.TSTCON" :
    checkTSTCON0x566c813b3632783eVault(address: address)
    ,
    "A.f8ba321af4bd37bb.aiSportsJuice" :
    checkaiSportsJuice0xf8ba321af4bd37bbVault(address: address)
    ,
    "A.566c813b3632783e.DWLC" :
    checkDWLC0x566c813b3632783eVault(address: address)
    ,
    "A.a622afad07f6739e.Nocenix" :
    checkNocenix0xa622afad07f6739eVault(address: address)
    ,
    "A.432050232f9a49e7.FooToken" :
    checkFooToken0x432050232f9a49e7Vault(address: address)
    ,
    "A.566c813b3632783e.Sorachi" :
    checkSorachi0x566c813b3632783eVault(address: address)
    }
    }
  ", - "getTokenListBalance": "CiAgICAvLyBGbG93IFdhbGxldCAtIHRlc3RuZXQgU2NyaXB0ICBnZXRUb2tlbkxpc3RCYWxhbmNlU3RhYmxlIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgoKICAgIGltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgoKICAgIAogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRmlhdFRva2VuMHhhOTgzZmVjYmVkNjIxMTYzQmFsYW5jZShhZGRyZXNzOiBBZGRyZXNzKSA6IFVGaXg2NCB7CiAgICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICBsZXQgdmF1bHRSZWYgPSBhY2NvdW50CiAgICAgICAgLmNhcGFiaWxpdGllcy5ib3Jyb3c8JntGdW5naWJsZVRva2VuLkJhbGFuY2V9PigvcHVibGljL1VTRENWYXVsdEJhbGFuY2UpID8/IG5pbAoKICAgICAgaWYgdmF1bHRSZWYgIT0gbmlsIHsKCiAgICAgICAgcmV0dXJuIHZhdWx0UmVmIS5iYWxhbmNlCiAgICAgIH0KCiAgICAgIHJldHVybiAwLjAKCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRmxvdmF0YXJEdXN0VG9rZW4weDkzOTJhNGE3YzNmNDlhMGJCYWxhbmNlKGFkZHJlc3M6IEFkZHJlc3MpIDogVUZpeDY0IHsKICAgICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIGxldCB2YXVsdFJlZiA9IGFjY291bnQKICAgICAgICAuY2FwYWJpbGl0aWVzLmJvcnJvdzwme0Z1bmdpYmxlVG9rZW4uQmFsYW5jZX0+KC9wdWJsaWMvRmxvdmF0YXJEdXN0VG9rZW5CYWxhbmNlKSA/PyBuaWwKCiAgICAgIGlmIHZhdWx0UmVmICE9IG5pbCB7CgogICAgICAgIHJldHVybiB2YXVsdFJlZiEuYmFsYW5jZQogICAgICB9CgogICAgICByZXR1cm4gMC4wCgogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0Zsb3dUb2tlbjB4N2U2MGRmMDQyYTljMDg2OEJhbGFuY2UoYWRkcmVzczogQWRkcmVzcykgOiBVRml4NjQgewogICAgICBsZXQgYWNjb3VudCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgbGV0IHZhdWx0UmVmID0gYWNjb3VudAogICAgICAgIC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5CYWxhbmNlfT4oL3B1YmxpYy9mbG93VG9rZW5CYWxhbmNlKSA/PyBuaWwKCiAgICAgIGlmIHZhdWx0UmVmICE9IG5pbCB7CgogICAgICAgIHJldHVybiB2YXVsdFJlZiEuYmFsYW5jZQogICAgICB9CgogICAgICByZXR1cm4gMC4wCgogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja1VTRENGbG93MHg2NGFkZjM5Y2JjMzU0ZmNiQmFsYW5jZShhZGRyZXNzOiBBZGRyZXNzKSA6IFVGaXg2NCB7CiAgICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICBsZXQgdmF1bHRSZWYgPSBhY2NvdW50CiAgICAgICAgLmNhcGFiaWxpdGllcy5ib3Jyb3c8JntGdW5naWJsZVRva2VuLkJhbGFuY2V9PigvcHVibGljL3VzZGNGbG93TWV0YWRhdGEpID8/IG5pbAoKICAgICAgaWYgdmF1bHRSZWYgIT0gbmlsIHsKCiAgICAgICAgcmV0dXJuIHZhdWx0UmVmIS5iYWxhbmNlCiAgICAgIH0KCiAgICAgIHJldHVybiAwLjAKCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrc3RGbG93VG9rZW4weGU0NWM2NGVjZmUzMWU0NjVCYWxhbmNlKGFkZHJlc3M6IEFkZHJlc3MpIDogVUZpeDY0IHsKICAgICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIGxldCB2YXVsdFJlZiA9IGFjY291bnQKICAgICAgICAuY2FwYWJpbGl0aWVzLmJvcnJvdzwme0Z1bmdpYmxlVG9rZW4uQmFsYW5jZX0+KC9wdWJsaWMvc3RGbG93VG9rZW5CYWxhbmNlKSA/PyBuaWwKCiAgICAgIGlmIHZhdWx0UmVmICE9IG5pbCB7CgogICAgICAgIHJldHVybiB2YXVsdFJlZiEuYmFsYW5jZQogICAgICB9CgogICAgICByZXR1cm4gMC4wCgogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0Nvc21pY0dBVEUweDAwYWYyYWIzNjNmYTQ5ZTRCYWxhbmNlKGFkZHJlc3M6IEFkZHJlc3MpIDogVUZpeDY0IHsKICAgICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIGxldCB2YXVsdFJlZiA9IGFjY291bnQKICAgICAgICAuY2FwYWJpbGl0aWVzLmJvcnJvdzwme0Z1bmdpYmxlVG9rZW4uQmFsYW5jZX0+KC9wdWJsaWMvQ29zbWljR0FURVZhdWx0KSA/PyBuaWwKCiAgICAgIGlmIHZhdWx0UmVmICE9IG5pbCB7CgogICAgICAgIHJldHVybiB2YXVsdFJlZiEuYmFsYW5jZQogICAgICB9CgogICAgICByZXR1cm4gMC4wCgogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja1NVR09JMHg1NjZjODEzYjM2MzI3ODNlQmFsYW5jZShhZGRyZXNzOiBBZGRyZXNzKSA6IFVGaXg2NCB7CiAgICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICBsZXQgdmF1bHRSZWYgPSBhY2NvdW50CiAgICAgICAgLmNhcGFiaWxpdGllcy5ib3Jyb3c8JntGdW5naWJsZVRva2VuLkJhbGFuY2V9PigvcHVibGljL1NVR09JQmFsYW5jZSkgPz8gbmlsCgogICAgICBpZiB2YXVsdFJlZiAhPSBuaWwgewoKICAgICAgICByZXR1cm4gdmF1bHRSZWYhLmJhbGFuY2UKICAgICAgfQoKICAgICAgcmV0dXJuIDAuMAoKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tFVk1WTUJyaWRnZWRUb2tlbl8xMTE5Y2E0ZDUxNDU0MzJiN2IxY2QxOTdkMTM2ZGExNWUyMzZlODk2MHhkZmMyMGFlZTY1MGZjYmRmQmFsYW5jZShhZGRyZXNzOiBBZGRyZXNzKSA6IFVGaXg2NCB7CiAgICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICBsZXQgdmF1bHRSZWYgPSBhY2NvdW50CiAgICAgICAgLmNhcGFiaWxpdGllcy5ib3Jyb3c8JntGdW5naWJsZVRva2VuLkJhbGFuY2V9PigvcHVibGljL0VWTVZNQnJpZGdlZFRva2VuXzExMTljYTRkNTE0NTQzMmI3YjFjZDE5N2QxMzZkYTE1ZTIzNmU4OTZWYXVsdCkgPz8gbmlsCgogICAgICBpZiB2YXVsdFJlZiAhPSBuaWwgewoKICAgICAgICByZXR1cm4gdmF1bHRSZWYhLmJhbGFuY2UKICAgICAgfQoKICAgICAgcmV0dXJuIDAuMAoKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tNRURJMHg1NjZjODEzYjM2MzI3ODNlQmFsYW5jZShhZGRyZXNzOiBBZGRyZXNzKSA6IFVGaXg2NCB7CiAgICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICBsZXQgdmF1bHRSZWYgPSBhY2NvdW50CiAgICAgICAgLmNhcGFiaWxpdGllcy5ib3Jyb3c8JntGdW5naWJsZVRva2VuLkJhbGFuY2V9PigvcHVibGljL01FREkyNEthcmF0QmFsYW5jZSkgPz8gbmlsCgogICAgICBpZiB2YXVsdFJlZiAhPSBuaWwgewoKICAgICAgICByZXR1cm4gdmF1bHRSZWYhLmJhbGFuY2UKICAgICAgfQoKICAgICAgcmV0dXJuIDAuMAoKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tEYXBwZXJVdGlsaXR5Q29pbjB4ODJlYzI4M2Y4OGE2MmU2NUJhbGFuY2UoYWRkcmVzczogQWRkcmVzcykgOiBVRml4NjQgewogICAgICBsZXQgYWNjb3VudCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgbGV0IHZhdWx0UmVmID0gYWNjb3VudAogICAgICAgIC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5CYWxhbmNlfT4oL3B1YmxpYy9kYXBwZXJVdGlsaXR5Q29pblJlY2VpdmVyKSA/PyBuaWwKCiAgICAgIGlmIHZhdWx0UmVmICE9IG5pbCB7CgogICAgICAgIHJldHVybiB2YXVsdFJlZiEuYmFsYW5jZQogICAgICB9CgogICAgICByZXR1cm4gMC4wCgogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0thcmF0MHg1NjZjODEzYjM2MzI3ODNlQmFsYW5jZShhZGRyZXNzOiBBZGRyZXNzKSA6IFVGaXg2NCB7CiAgICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICBsZXQgdmF1bHRSZWYgPSBhY2NvdW50CiAgICAgICAgLmNhcGFiaWxpdGllcy5ib3Jyb3c8JntGdW5naWJsZVRva2VuLkJhbGFuY2V9PigvcHVibGljL2thcmF0QmFsYW5jZTAwMykgPz8gbmlsCgogICAgICBpZiB2YXVsdFJlZiAhPSBuaWwgewoKICAgICAgICByZXR1cm4gdmF1bHRSZWYhLmJhbGFuY2UKICAgICAgfQoKICAgICAgcmV0dXJuIDAuMAoKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tLYXJhdHYyMHg1NjZjODEzYjM2MzI3ODNlQmFsYW5jZShhZGRyZXNzOiBBZGRyZXNzKSA6IFVGaXg2NCB7CiAgICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICBsZXQgdmF1bHRSZWYgPSBhY2NvdW50CiAgICAgICAgLmNhcGFiaWxpdGllcy5ib3Jyb3c8JntGdW5naWJsZVRva2VuLkJhbGFuY2V9PigvcHVibGljL2thcmF0djJCYWxhbmNlMDAzKSA/PyBuaWwKCiAgICAgIGlmIHZhdWx0UmVmICE9IG5pbCB7CgogICAgICAgIHJldHVybiB2YXVsdFJlZiEuYmFsYW5jZQogICAgICB9CgogICAgICByZXR1cm4gMC4wCgogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0tBUkFUWjFMWEdQSzB4NTY2YzgxM2IzNjMyNzgzZUJhbGFuY2UoYWRkcmVzczogQWRkcmVzcykgOiBVRml4NjQgewogICAgICBsZXQgYWNjb3VudCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgbGV0IHZhdWx0UmVmID0gYWNjb3VudAogICAgICAgIC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5CYWxhbmNlfT4oL3B1YmxpYy9LQVJBVFoxTFhHUEtCYWxhbmNlKSA/PyBuaWwKCiAgICAgIGlmIHZhdWx0UmVmICE9IG5pbCB7CgogICAgICAgIHJldHVybiB2YXVsdFJlZiEuYmFsYW5jZQogICAgICB9CgogICAgICByZXR1cm4gMC4wCgogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0tBUkFUWjFKWERYRDB4NTY2YzgxM2IzNjMyNzgzZUJhbGFuY2UoYWRkcmVzczogQWRkcmVzcykgOiBVRml4NjQgewogICAgICBsZXQgYWNjb3VudCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgbGV0IHZhdWx0UmVmID0gYWNjb3VudAogICAgICAgIC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5CYWxhbmNlfT4oL3B1YmxpYy9LQVJBVFoxSlhEWERCYWxhbmNlKSA/PyBuaWwKCiAgICAgIGlmIHZhdWx0UmVmICE9IG5pbCB7CgogICAgICAgIHJldHVybiB2YXVsdFJlZiEuYmFsYW5jZQogICAgICB9CgogICAgICByZXR1cm4gMC4wCgogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0tBUkFUWjFURUZRMjB4NTY2YzgxM2IzNjMyNzgzZUJhbGFuY2UoYWRkcmVzczogQWRkcmVzcykgOiBVRml4NjQgewogICAgICBsZXQgYWNjb3VudCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgbGV0IHZhdWx0UmVmID0gYWNjb3VudAogICAgICAgIC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5CYWxhbmNlfT4oL3B1YmxpYy9LQVJBVFoxVEVGUTJCYWxhbmNlKSA/PyBuaWwKCiAgICAgIGlmIHZhdWx0UmVmICE9IG5pbCB7CgogICAgICAgIHJldHVybiB2YXVsdFJlZiEuYmFsYW5jZQogICAgICB9CgogICAgICByZXR1cm4gMC4wCgogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja1RlbGVwb3J0ZWRUZXRoZXJUb2tlbjB4MmQyNzBkYjlhYzhjN2ZlZkJhbGFuY2UoYWRkcmVzczogQWRkcmVzcykgOiBVRml4NjQgewogICAgICBsZXQgYWNjb3VudCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgbGV0IHZhdWx0UmVmID0gYWNjb3VudAogICAgICAgIC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5CYWxhbmNlfT4oL3B1YmxpYy90ZWxlcG9ydGVkVGV0aGVyVG9rZW5CYWxhbmNlKSA/PyBuaWwKCiAgICAgIGlmIHZhdWx0UmVmICE9IG5pbCB7CgogICAgICAgIHJldHVybiB2YXVsdFJlZiEuYmFsYW5jZQogICAgICB9CgogICAgICByZXR1cm4gMC4wCgogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja1N0YXJseVRva2VuMHhmNjMyMTkwNzJhYWRkZDUwQmFsYW5jZShhZGRyZXNzOiBBZGRyZXNzKSA6IFVGaXg2NCB7CiAgICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICBsZXQgdmF1bHRSZWYgPSBhY2NvdW50CiAgICAgICAgLmNhcGFiaWxpdGllcy5ib3Jyb3c8JntGdW5naWJsZVRva2VuLkJhbGFuY2V9PigvcHVibGljL3N0YXJseVRva2VuQmFsYW5jZSkgPz8gbmlsCgogICAgICBpZiB2YXVsdFJlZiAhPSBuaWwgewoKICAgICAgICByZXR1cm4gdmF1bHRSZWYhLmJhbGFuY2UKICAgICAgfQoKICAgICAgcmV0dXJuIDAuMAoKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tCbG9jdG9Ub2tlbjB4NjUzY2ZlMzZkMTQ2ZTdiZUJhbGFuY2UoYWRkcmVzczogQWRkcmVzcykgOiBVRml4NjQgewogICAgICBsZXQgYWNjb3VudCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgbGV0IHZhdWx0UmVmID0gYWNjb3VudAogICAgICAgIC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5CYWxhbmNlfT4oL3B1YmxpYy9ibG9jdG9Ub2tlbkJhbGFuY2UpID8/IG5pbAoKICAgICAgaWYgdmF1bHRSZWYgIT0gbmlsIHsKCiAgICAgICAgcmV0dXJuIHZhdWx0UmVmIS5iYWxhbmNlCiAgICAgIH0KCiAgICAgIHJldHVybiAwLjAKCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrR09XVEtOMjB4NTY2YzgxM2IzNjMyNzgzZUJhbGFuY2UoYWRkcmVzczogQWRkcmVzcykgOiBVRml4NjQgewogICAgICBsZXQgYWNjb3VudCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgbGV0IHZhdWx0UmVmID0gYWNjb3VudAogICAgICAgIC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5CYWxhbmNlfT4oL3B1YmxpYy9LUlRLTkdPV1RLTjJCYWxhbmNlKSA/PyBuaWwKCiAgICAgIGlmIHZhdWx0UmVmICE9IG5pbCB7CgogICAgICAgIHJldHVybiB2YXVsdFJlZiEuYmFsYW5jZQogICAgICB9CgogICAgICByZXR1cm4gMC4wCgogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0tBUkFUTURWOVQweDU2NmM4MTNiMzYzMjc4M2VCYWxhbmNlKGFkZHJlc3M6IEFkZHJlc3MpIDogVUZpeDY0IHsKICAgICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIGxldCB2YXVsdFJlZiA9IGFjY291bnQKICAgICAgICAuY2FwYWJpbGl0aWVzLmJvcnJvdzwme0Z1bmdpYmxlVG9rZW4uQmFsYW5jZX0+KC9wdWJsaWMvS0FSQVRNRFY5VEJhbGFuY2UpID8/IG5pbAoKICAgICAgaWYgdmF1bHRSZWYgIT0gbmlsIHsKCiAgICAgICAgcmV0dXJuIHZhdWx0UmVmIS5iYWxhbmNlCiAgICAgIH0KCiAgICAgIHJldHVybiAwLjAKCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrSk9TSElOMHg1NjZjODEzYjM2MzI3ODNlQmFsYW5jZShhZGRyZXNzOiBBZGRyZXNzKSA6IFVGaXg2NCB7CiAgICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICBsZXQgdmF1bHRSZWYgPSBhY2NvdW50CiAgICAgICAgLmNhcGFiaWxpdGllcy5ib3Jyb3c8JntGdW5naWJsZVRva2VuLkJhbGFuY2V9PigvcHVibGljL0pPU0hJTjI0S2FyYXRCYWxhbmNlKSA/PyBuaWwKCiAgICAgIGlmIHZhdWx0UmVmICE9IG5pbCB7CgogICAgICAgIHJldHVybiB2YXVsdFJlZiEuYmFsYW5jZQogICAgICB9CgogICAgICByZXR1cm4gMC4wCgogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0tBUkFUMkVBMjhIMHg1NjZjODEzYjM2MzI3ODNlQmFsYW5jZShhZGRyZXNzOiBBZGRyZXNzKSA6IFVGaXg2NCB7CiAgICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICBsZXQgdmF1bHRSZWYgPSBhY2NvdW50CiAgICAgICAgLmNhcGFiaWxpdGllcy5ib3Jyb3c8JntGdW5naWJsZVRva2VuLkJhbGFuY2V9PigvcHVibGljL0tBUkFUMkVBMjhIQmFsYW5jZSkgPz8gbmlsCgogICAgICBpZiB2YXVsdFJlZiAhPSBuaWwgewoKICAgICAgICByZXR1cm4gdmF1bHRSZWYhLmJhbGFuY2UKICAgICAgfQoKICAgICAgcmV0dXJuIDAuMAoKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tET0dFVEtOMHg1NjZjODEzYjM2MzI3ODNlQmFsYW5jZShhZGRyZXNzOiBBZGRyZXNzKSA6IFVGaXg2NCB7CiAgICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICBsZXQgdmF1bHRSZWYgPSBhY2NvdW50CiAgICAgICAgLmNhcGFiaWxpdGllcy5ib3Jyb3c8JntGdW5naWJsZVRva2VuLkJhbGFuY2V9PigvcHVibGljL0RPR0VUS05CYWxhbmNlKSA/PyBuaWwKCiAgICAgIGlmIHZhdWx0UmVmICE9IG5pbCB7CgogICAgICAgIHJldHVybiB2YXVsdFJlZiEuYmFsYW5jZQogICAgICB9CgogICAgICByZXR1cm4gMC4wCgogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja1RTVENPTjB4NTY2YzgxM2IzNjMyNzgzZUJhbGFuY2UoYWRkcmVzczogQWRkcmVzcykgOiBVRml4NjQgewogICAgICBsZXQgYWNjb3VudCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgbGV0IHZhdWx0UmVmID0gYWNjb3VudAogICAgICAgIC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5CYWxhbmNlfT4oL3B1YmxpYy9UU1RDT05CYWxhbmNlKSA/PyBuaWwKCiAgICAgIGlmIHZhdWx0UmVmICE9IG5pbCB7CgogICAgICAgIHJldHVybiB2YXVsdFJlZiEuYmFsYW5jZQogICAgICB9CgogICAgICByZXR1cm4gMC4wCgogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja2FpU3BvcnRzSnVpY2UweGY4YmEzMjFhZjRiZDM3YmJCYWxhbmNlKGFkZHJlc3M6IEFkZHJlc3MpIDogVUZpeDY0IHsKICAgICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIGxldCB2YXVsdFJlZiA9IGFjY291bnQKICAgICAgICAuY2FwYWJpbGl0aWVzLmJvcnJvdzwme0Z1bmdpYmxlVG9rZW4uQmFsYW5jZX0+KC9wdWJsaWMvYWlTcG9ydHNKdWljZU1ldGFkYXRhKSA/PyBuaWwKCiAgICAgIGlmIHZhdWx0UmVmICE9IG5pbCB7CgogICAgICAgIHJldHVybiB2YXVsdFJlZiEuYmFsYW5jZQogICAgICB9CgogICAgICByZXR1cm4gMC4wCgogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0RXTEMweDU2NmM4MTNiMzYzMjc4M2VCYWxhbmNlKGFkZHJlc3M6IEFkZHJlc3MpIDogVUZpeDY0IHsKICAgICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIGxldCB2YXVsdFJlZiA9IGFjY291bnQKICAgICAgICAuY2FwYWJpbGl0aWVzLmJvcnJvdzwme0Z1bmdpYmxlVG9rZW4uQmFsYW5jZX0+KC9wdWJsaWMvRFdMQ0JhbGFuY2UpID8/IG5pbAoKICAgICAgaWYgdmF1bHRSZWYgIT0gbmlsIHsKCiAgICAgICAgcmV0dXJuIHZhdWx0UmVmIS5iYWxhbmNlCiAgICAgIH0KCiAgICAgIHJldHVybiAwLjAKCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrTm9jZW5peDB4YTYyMmFmYWQwN2Y2NzM5ZUJhbGFuY2UoYWRkcmVzczogQWRkcmVzcykgOiBVRml4NjQgewogICAgICBsZXQgYWNjb3VudCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgbGV0IHZhdWx0UmVmID0gYWNjb3VudAogICAgICAgIC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5CYWxhbmNlfT4oL3B1YmxpYy9Ob2Nlbml4VmF1bHQpID8/IG5pbAoKICAgICAgaWYgdmF1bHRSZWYgIT0gbmlsIHsKCiAgICAgICAgcmV0dXJuIHZhdWx0UmVmIS5iYWxhbmNlCiAgICAgIH0KCiAgICAgIHJldHVybiAwLjAKCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRm9vVG9rZW4weDQzMjA1MDIzMmY5YTQ5ZTdCYWxhbmNlKGFkZHJlc3M6IEFkZHJlc3MpIDogVUZpeDY0IHsKICAgICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIGxldCB2YXVsdFJlZiA9IGFjY291bnQKICAgICAgICAuY2FwYWJpbGl0aWVzLmJvcnJvdzwme0Z1bmdpYmxlVG9rZW4uQmFsYW5jZX0+KC9wdWJsaWMvZm9vVG9rZW5WYXVsdCkgPz8gbmlsCgogICAgICBpZiB2YXVsdFJlZiAhPSBuaWwgewoKICAgICAgICByZXR1cm4gdmF1bHRSZWYhLmJhbGFuY2UKICAgICAgfQoKICAgICAgcmV0dXJuIDAuMAoKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tTb3JhY2hpMHg1NjZjODEzYjM2MzI3ODNlQmFsYW5jZShhZGRyZXNzOiBBZGRyZXNzKSA6IFVGaXg2NCB7CiAgICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICBsZXQgdmF1bHRSZWYgPSBhY2NvdW50CiAgICAgICAgLmNhcGFiaWxpdGllcy5ib3Jyb3c8JntGdW5naWJsZVRva2VuLkJhbGFuY2V9PigvcHVibGljL3NvcmFjaGlCYWxhbmNlKSA/PyBuaWwKCiAgICAgIGlmIHZhdWx0UmVmICE9IG5pbCB7CgogICAgICAgIHJldHVybiB2YXVsdFJlZiEuYmFsYW5jZQogICAgICB9CgogICAgICByZXR1cm4gMC4wCgogICAgfQogICAgCiAgICBhY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzKSA6IHtTdHJpbmc6IFVGaXg2NH0gewogICAgICByZXR1cm4gewogICAgICAiQS5hOTgzZmVjYmVkNjIxMTYzLkZpYXRUb2tlbiIgOgogICAgY2hlY2tGaWF0VG9rZW4weGE5ODNmZWNiZWQ2MjExNjNCYWxhbmNlKGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAgICJBLjkzOTJhNGE3YzNmNDlhMGIuRmxvdmF0YXJEdXN0VG9rZW4iIDoKICAgIGNoZWNrRmxvdmF0YXJEdXN0VG9rZW4weDkzOTJhNGE3YzNmNDlhMGJCYWxhbmNlKGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAgICJBLjdlNjBkZjA0MmE5YzA4NjguRmxvd1Rva2VuIiA6CiAgICBjaGVja0Zsb3dUb2tlbjB4N2U2MGRmMDQyYTljMDg2OEJhbGFuY2UoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICAgIkEuNjRhZGYzOWNiYzM1NGZjYi5VU0RDRmxvdyIgOgogICAgY2hlY2tVU0RDRmxvdzB4NjRhZGYzOWNiYzM1NGZjYkJhbGFuY2UoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICAgIkEuZTQ1YzY0ZWNmZTMxZTQ2NS5zdEZsb3dUb2tlbiIgOgogICAgY2hlY2tzdEZsb3dUb2tlbjB4ZTQ1YzY0ZWNmZTMxZTQ2NUJhbGFuY2UoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICAgIkEuMDBhZjJhYjM2M2ZhNDllNC5Db3NtaWNHQVRFIiA6CiAgICBjaGVja0Nvc21pY0dBVEUweDAwYWYyYWIzNjNmYTQ5ZTRCYWxhbmNlKGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAgICJBLjU2NmM4MTNiMzYzMjc4M2UuU1VHT0kiIDoKICAgIGNoZWNrU1VHT0kweDU2NmM4MTNiMzYzMjc4M2VCYWxhbmNlKGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAgICJBLmRmYzIwYWVlNjUwZmNiZGYuRVZNVk1CcmlkZ2VkVG9rZW5fMTExOWNhNGQ1MTQ1NDMyYjdiMWNkMTk3ZDEzNmRhMTVlMjM2ZTg5NiIgOgogICAgY2hlY2tFVk1WTUJyaWRnZWRUb2tlbl8xMTE5Y2E0ZDUxNDU0MzJiN2IxY2QxOTdkMTM2ZGExNWUyMzZlODk2MHhkZmMyMGFlZTY1MGZjYmRmQmFsYW5jZShhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgICAiQS41NjZjODEzYjM2MzI3ODNlLk1FREkiIDoKICAgIGNoZWNrTUVESTB4NTY2YzgxM2IzNjMyNzgzZUJhbGFuY2UoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICAgIkEuODJlYzI4M2Y4OGE2MmU2NS5EYXBwZXJVdGlsaXR5Q29pbiIgOgogICAgY2hlY2tEYXBwZXJVdGlsaXR5Q29pbjB4ODJlYzI4M2Y4OGE2MmU2NUJhbGFuY2UoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICAgIkEuNTY2YzgxM2IzNjMyNzgzZS5LYXJhdCIgOgogICAgY2hlY2tLYXJhdDB4NTY2YzgxM2IzNjMyNzgzZUJhbGFuY2UoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICAgIkEuNTY2YzgxM2IzNjMyNzgzZS5LYXJhdHYyIiA6CiAgICBjaGVja0thcmF0djIweDU2NmM4MTNiMzYzMjc4M2VCYWxhbmNlKGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAgICJBLjU2NmM4MTNiMzYzMjc4M2UuS0FSQVRaMUxYR1BLIiA6CiAgICBjaGVja0tBUkFUWjFMWEdQSzB4NTY2YzgxM2IzNjMyNzgzZUJhbGFuY2UoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICAgIkEuNTY2YzgxM2IzNjMyNzgzZS5LQVJBVFoxSlhEWEQiIDoKICAgIGNoZWNrS0FSQVRaMUpYRFhEMHg1NjZjODEzYjM2MzI3ODNlQmFsYW5jZShhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgICAiQS41NjZjODEzYjM2MzI3ODNlLktBUkFUWjFURUZRMiIgOgogICAgY2hlY2tLQVJBVFoxVEVGUTIweDU2NmM4MTNiMzYzMjc4M2VCYWxhbmNlKGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAgICJBLjJkMjcwZGI5YWM4YzdmZWYuVGVsZXBvcnRlZFRldGhlclRva2VuIiA6CiAgICBjaGVja1RlbGVwb3J0ZWRUZXRoZXJUb2tlbjB4MmQyNzBkYjlhYzhjN2ZlZkJhbGFuY2UoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICAgIkEuZjYzMjE5MDcyYWFkZGQ1MC5TdGFybHlUb2tlbiIgOgogICAgY2hlY2tTdGFybHlUb2tlbjB4ZjYzMjE5MDcyYWFkZGQ1MEJhbGFuY2UoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICAgIkEuNjUzY2ZlMzZkMTQ2ZTdiZS5CbG9jdG9Ub2tlbiIgOgogICAgY2hlY2tCbG9jdG9Ub2tlbjB4NjUzY2ZlMzZkMTQ2ZTdiZUJhbGFuY2UoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICAgIkEuNTY2YzgxM2IzNjMyNzgzZS5HT1dUS04yIiA6CiAgICBjaGVja0dPV1RLTjIweDU2NmM4MTNiMzYzMjc4M2VCYWxhbmNlKGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAgICJBLjU2NmM4MTNiMzYzMjc4M2UuS0FSQVRNRFY5VCIgOgogICAgY2hlY2tLQVJBVE1EVjlUMHg1NjZjODEzYjM2MzI3ODNlQmFsYW5jZShhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgICAiQS41NjZjODEzYjM2MzI3ODNlLkpPU0hJTiIgOgogICAgY2hlY2tKT1NISU4weDU2NmM4MTNiMzYzMjc4M2VCYWxhbmNlKGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAgICJBLjU2NmM4MTNiMzYzMjc4M2UuS0FSQVQyRUEyOEgiIDoKICAgIGNoZWNrS0FSQVQyRUEyOEgweDU2NmM4MTNiMzYzMjc4M2VCYWxhbmNlKGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAgICJBLjU2NmM4MTNiMzYzMjc4M2UuRE9HRVRLTiIgOgogICAgY2hlY2tET0dFVEtOMHg1NjZjODEzYjM2MzI3ODNlQmFsYW5jZShhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgICAiQS41NjZjODEzYjM2MzI3ODNlLlRTVENPTiIgOgogICAgY2hlY2tUU1RDT04weDU2NmM4MTNiMzYzMjc4M2VCYWxhbmNlKGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAgICJBLmY4YmEzMjFhZjRiZDM3YmIuYWlTcG9ydHNKdWljZSIgOgogICAgY2hlY2thaVNwb3J0c0p1aWNlMHhmOGJhMzIxYWY0YmQzN2JiQmFsYW5jZShhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgICAiQS41NjZjODEzYjM2MzI3ODNlLkRXTEMiIDoKICAgIGNoZWNrRFdMQzB4NTY2YzgxM2IzNjMyNzgzZUJhbGFuY2UoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICAgIkEuYTYyMmFmYWQwN2Y2NzM5ZS5Ob2Nlbml4IiA6CiAgICBjaGVja05vY2VuaXgweGE2MjJhZmFkMDdmNjczOWVCYWxhbmNlKGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAgICJBLjQzMjA1MDIzMmY5YTQ5ZTcuRm9vVG9rZW4iIDoKICAgIGNoZWNrRm9vVG9rZW4weDQzMjA1MDIzMmY5YTQ5ZTdCYWxhbmNlKGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAgICJBLjU2NmM4MTNiMzYzMjc4M2UuU29yYWNoaSIgOgogICAgY2hlY2tTb3JhY2hpMHg1NjZjODEzYjM2MzI3ODNlQmFsYW5jZShhZGRyZXNzOiBhZGRyZXNzKQogICAgfQogICAgfQogIA\u003d\u003d", - "addToken": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYWRkVG9rZW4gLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgppbXBvcnQgPFRva2VuPiBmcm9tIDxUb2tlbkFkZHJlc3M+Cgp0cmFuc2FjdGlvbiB7CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSwgQ2FwYWJpbGl0aWVzKSAmQWNjb3VudCkgewoKICAgICAgICBpZiBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8JjxUb2tlbj4uVmF1bHQ+KGZyb206IDxUb2tlblN0b3JhZ2VQYXRoPiApID09IG5pbCB7CiAgICAgICAgICAgIHNpZ25lci5zdG9yYWdlLnNhdmUoPC0gPFRva2VuPi5jcmVhdGVFbXB0eVZhdWx0KHZhdWx0VHlwZTogVHlwZTxAPFRva2VuPi5WYXVsdD4oKSksIHRvOiA8VG9rZW5TdG9yYWdlUGF0aD4pCiAgICAgICAgfQoKICAgICAgICBpZiBzaWduZXIuY2FwYWJpbGl0aWVzLmV4aXN0cyg8VG9rZW5SZWNlaXZlclBhdGg+KSA9PSBmYWxzZSB7CiAgICAgICAgICAgIGxldCByZWNlaXZlckNhcGFiaWxpdHkgPSBzaWduZXIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8JjxUb2tlbj4uVmF1bHQ+KDxUb2tlblN0b3JhZ2VQYXRoPikKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5wdWJsaXNoKHJlY2VpdmVyQ2FwYWJpbGl0eSwgYXQ6IDxUb2tlblJlY2VpdmVyUGF0aD4pCiAgICAgICAgCiAgICAgICAgfQogICAgICAgCiAgICAgICAgaWYgc2lnbmVyLmNhcGFiaWxpdGllcy5leGlzdHMoPFRva2VuQmFsYW5jZVBhdGg+KSA9PSBmYWxzZSB7CiAgICAgICAgICAgIGxldCBiYWxhbmNlQ2FwYWJpbGl0eSA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTwmPFRva2VuPi5WYXVsdD4oPFRva2VuU3RvcmFnZVBhdGg+KQogICAgICAgICAgICBzaWduZXIuY2FwYWJpbGl0aWVzLnB1Ymxpc2goYmFsYW5jZUNhcGFiaWxpdHksIGF0OiA8VG9rZW5CYWxhbmNlUGF0aD4pCiAgICAgICAgfQogICAgCiAgICB9Cn0\u003d", - "enableTokenStorage": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZW5hYmxlVG9rZW5TdG9yYWdlIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKaW1wb3J0IDxUb2tlbj4gZnJvbSA8VG9rZW5BZGRyZXNzPgoKdHJhbnNhY3Rpb24gewoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIENhcGFiaWxpdGllcykgJkFjY291bnQpIHsKCiAgICAgICAgaWYgc2lnbmVyLnN0b3JhZ2UuYm9ycm93PCY8VG9rZW4+LlZhdWx0Pihmcm9tOiA8VG9rZW5TdG9yYWdlUGF0aD4gKSA9PSBuaWwgewogICAgICAgICAgICBzaWduZXIuc3RvcmFnZS5zYXZlKDwtIDxUb2tlbj4uY3JlYXRlRW1wdHlWYXVsdCh2YXVsdFR5cGU6IFR5cGU8QDxUb2tlbj4uVmF1bHQ+KCkpLCB0bzogPFRva2VuU3RvcmFnZVBhdGg+KQogICAgICAgIH0KCiAgICAgICAgaWYgc2lnbmVyLmNhcGFiaWxpdGllcy5leGlzdHMoPFRva2VuUmVjZWl2ZXJQYXRoPikgPT0gZmFsc2UgewogICAgICAgICAgICBsZXQgcmVjZWl2ZXJDYXBhYmlsaXR5ID0gc2lnbmVyLmNhcGFiaWxpdGllcy5zdG9yYWdlLmlzc3VlPCY8VG9rZW4+LlZhdWx0Pig8VG9rZW5TdG9yYWdlUGF0aD4pCiAgICAgICAgICAgIHNpZ25lci5jYXBhYmlsaXRpZXMucHVibGlzaChyZWNlaXZlckNhcGFiaWxpdHksIGF0OiA8VG9rZW5SZWNlaXZlclBhdGg+KQogICAgICAgIAogICAgICAgIH0KICAgICAgIAogICAgICAgIGlmIHNpZ25lci5jYXBhYmlsaXRpZXMuZXhpc3RzKDxUb2tlbkJhbGFuY2VQYXRoPikgPT0gZmFsc2UgewogICAgICAgICAgICBsZXQgYmFsYW5jZUNhcGFiaWxpdHkgPSBzaWduZXIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8JjxUb2tlbj4uVmF1bHQ+KDxUb2tlblN0b3JhZ2VQYXRoPikKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5wdWJsaXNoKGJhbGFuY2VDYXBhYmlsaXR5LCBhdDogPFRva2VuQmFsYW5jZVBhdGg+KQogICAgICAgIH0KICAgIAogICAgfQp9", - "enableTokenStorageV2": "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", - "getTokenBalanceStorage": "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\u003d\u003d", - "transferEvmTokens": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdHJhbnNmZXJFdm1Ub2tlbnMgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBFVk0gZnJvbSAweDhjNTMwM2VhYTI2MjAyZDYKCgovLy8gVHJhbnNmZXJzICRGTE9XIGZyb20gdGhlIHNpZ25lcidzIGFjY291bnQgQ2FkZW5jZSBGbG93IGJhbGFuY2UgdG8gdGhlIHJlY2lwaWVudCdzIGhleC1lbmNvZGVkIEVWTSBhZGRyZXNzLgovLy8gTm90ZSB0aGF0IGEgQ09BIG11c3QgaGF2ZSBhICRGTE9XIGJhbGFuY2UgaW4gRVZNIGJlZm9yZSB0cmFuc2ZlcnJpbmcgdmFsdWUgdG8gYW5vdGhlciBFVk0gYWRkcmVzcy4KLy8vCnRyYW5zYWN0aW9uKHRvRVZNQWRkcmVzc0hleDogU3RyaW5nLCBhbW91bnQ6IFVJbnQyNTYsIGdhc0xpbWl0OiBVSW50NjQpIHsKCiAgICBsZXQgY29hOiBhdXRoKEVWTS5XaXRoZHJhdywgRVZNLkNhbGwpICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudAogICAgbGV0IHJlY2lwaWVudEVWTUFkZHJlc3M6IEVWTS5FVk1BZGRyZXNzCgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoQm9ycm93VmFsdWUsIFNhdmVWYWx1ZSkgJkFjY291bnQpIHsKICAgICAgICBpZiBzaWduZXIuc3RvcmFnZS50eXBlKGF0OiAvc3RvcmFnZS9ldm0pID09IG5pbCB7CiAgICAgICAgICAgIHNpZ25lci5zdG9yYWdlLnNhdmUoPC1FVk0uY3JlYXRlQ2FkZW5jZU93bmVkQWNjb3VudCgpLCB0bzogL3N0b3JhZ2UvZXZtKQogICAgICAgIH0KICAgICAgICBzZWxmLmNvYSA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEVWTS5XaXRoZHJhdywgRVZNLkNhbGwpICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oZnJvbTogL3N0b3JhZ2UvZXZtKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIHNpZ25lcidzIGJyaWRnZWQgYWNjb3VudCIpCgogICAgICAgIHNlbGYucmVjaXBpZW50RVZNQWRkcmVzcyA9IEVWTS5hZGRyZXNzRnJvbVN0cmluZyh0b0VWTUFkZHJlc3NIZXgpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgLy8gaWYgc2VsZi5yZWNpcGllbnRFVk1BZGRyZXNzLmJ5dGVzID09IHNlbGYuY29hLmFkZHJlc3MoKS5ieXRlcyB7CiAgICAgICAgLy8gICAgIHJldHVybgogICAgICAgIC8vIH0KICAgICAgICBsZXQgZGF0YSA9ICIiCiAgICAgICAgbGV0IHR4UmVzdWx0ID0gc2VsZi5jb2EuY2FsbCgKICAgICAgICAgICAgdG86IHNlbGYucmVjaXBpZW50RVZNQWRkcmVzcywKICAgICAgICAgICAgZGF0YTogZGF0YSwKICAgICAgICAgICAgZ2FzTGltaXQ6IGdhc0xpbWl0LAogICAgICAgICAgICB2YWx1ZTogdmFsdWVCYWxhbmNlCiAgICAgICAgKQogICAgICAgIGFzc2VydCgKICAgICAgICAgICAgdHhSZXN1bHQuc3RhdHVzID09IEVWTS5TdGF0dXMuZmFpbGVkIHx8IHR4UmVzdWx0LnN0YXR1cyA9PSBFVk0uU3RhdHVzLnN1Y2Nlc3NmdWwsCiAgICAgICAgICAgIG1lc3NhZ2U6ICJldm1fZXJyb3I9Ii5jb25jYXQodHhSZXN1bHQuZXJyb3JNZXNzYWdlKS5jb25jYXQoIlxuIikKICAgICAgICApCiAgICB9Cn0\u003d", - "transferTokens": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdHJhbnNmZXJUb2tlbnMgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgppbXBvcnQgPFRva2VuPiBmcm9tIDxUb2tlbkFkZHJlc3M+CgoKdHJhbnNhY3Rpb24oYW1vdW50OiBVRml4NjQsIHJlY2lwaWVudDogQWRkcmVzcykgewoKICAgIC8vIFRoZSBWYXVsdCByZXNvdXJjZSB0aGF0IGhvbGRzIHRoZSB0b2tlbnMgdGhhdCBhcmUgYmVpbmcgdHJhbnNmZXJlZAogICAgbGV0IHNlbnRWYXVsdDogQHtGdW5naWJsZVRva2VuLlZhdWx0fQoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgICAvLyBHZXQgYSByZWZlcmVuY2UgdG8gdGhlIHNpZ25lcidzIHN0b3JlZCB2YXVsdAogICAgICAgIGxldCB2YXVsdFJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICY8VG9rZW4+LlZhdWx0Pihmcm9tOiA8VG9rZW5TdG9yYWdlUGF0aD4pCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IHJlZmVyZW5jZSB0byB0aGUgb3duZXIncyBWYXVsdCEiKQoKICAgICAgICAvLyBXaXRoZHJhdyB0b2tlbnMgZnJvbSB0aGUgc2lnbmVyJ3Mgc3RvcmVkIHZhdWx0CiAgICAgICAgc2VsZi5zZW50VmF1bHQgPC0gdmF1bHRSZWYud2l0aGRyYXcoYW1vdW50OiBhbW91bnQpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgLy8gR2V0IHRoZSByZWNpcGllbnQncyBwdWJsaWMgYWNjb3VudCBvYmplY3QKICAgICAgICBsZXQgcmVjaXBpZW50QWNjb3VudCA9IGdldEFjY291bnQocmVjaXBpZW50KQoKICAgICAgICAvLyBHZXQgYSByZWZlcmVuY2UgdG8gdGhlIHJlY2lwaWVudCdzIFJlY2VpdmVyCiAgICAgICAgbGV0IHJlY2VpdmVyUmVmID0gcmVjaXBpZW50QWNjb3VudC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5WYXVsdH0+KDxUb2tlblJlY2VpdmVyUGF0aD4pIQogICAgICAgICAgICAKICAgICAgICAvLyBEZXBvc2l0IHRoZSB3aXRoZHJhd24gdG9rZW5zIGluIHRoZSByZWNpcGllbnQncyByZWNlaXZlcgogICAgICAgIHJlY2VpdmVyUmVmLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKCiAgICB9Cn0\u003d", - "transferTokensV3": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdHJhbnNmZXJUb2tlbnNWMyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCmltcG9ydCBTdG9yYWdlUmVudCBmcm9tIDB4ZDUwMDg0YTFhNDNiMTUwNwoKaW1wb3J0IDxUb2tlbj4gZnJvbSA8VG9rZW5BZGRyZXNzPgoKCnRyYW5zYWN0aW9uKGFtb3VudDogVUZpeDY0LCByZWNpcGllbnQ6IEFkZHJlc3MpIHsKCiAgICAvLyBUaGUgVmF1bHQgcmVzb3VyY2UgdGhhdCBob2xkcyB0aGUgdG9rZW5zIHRoYXQgYXJlIGJlaW5nIHRyYW5zZmVyZWQKICAgIGxldCBzZW50VmF1bHQ6IEB7RnVuZ2libGVUb2tlbi5WYXVsdH0KCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChTdG9yYWdlLCBCb3Jyb3dWYWx1ZSkgJkFjY291bnQpIHsKICAgICAgICAgLy8gR2V0IGEgcmVmZXJlbmNlIHRvIHRoZSBzaWduZXIncyBzdG9yZWQgdmF1bHQKICAgICAgICBsZXQgdmF1bHRSZWYgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAmPFRva2VuPi5WYXVsdD4oZnJvbTogPFRva2VuU3RvcmFnZVBhdGg+KQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIG93bmVyJ3MgVmF1bHQhIikKCiAgICAgICAgLy8gV2l0aGRyYXcgdG9rZW5zIGZyb20gdGhlIHNpZ25lcidzIHN0b3JlZCB2YXVsdAogICAgICAgIHNlbGYuc2VudFZhdWx0IDwtIHZhdWx0UmVmLndpdGhkcmF3KGFtb3VudDogYW1vdW50KQogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIC8vIEdldCB0aGUgcmVjaXBpZW50J3MgcHVibGljIGFjY291bnQgb2JqZWN0CiAgICAgICAgbGV0IHJlY2lwaWVudEFjY291bnQgPSBnZXRBY2NvdW50KHJlY2lwaWVudCkKCiAgICAgICAgLy8gR2V0IGEgcmVmZXJlbmNlIHRvIHRoZSByZWNpcGllbnQncyBSZWNlaXZlcgogICAgICAgIGxldCByZWNlaXZlclJlZiA9IHJlY2lwaWVudEFjY291bnQuY2FwYWJpbGl0aWVzLmJvcnJvdzwme0Z1bmdpYmxlVG9rZW4uVmF1bHR9Pig8VG9rZW5SZWNlaXZlclBhdGg+KSEKICAgICAgICAgICAgCiAgICAgICAgLy8gRGVwb3NpdCB0aGUgd2l0aGRyYXduIHRva2VucyBpbiB0aGUgcmVjaXBpZW50J3MgcmVjZWl2ZXIKICAgICAgICByZWNlaXZlclJlZi5kZXBvc2l0KGZyb206IDwtc2VsZi5zZW50VmF1bHQpCiAgICAgICAgU3RvcmFnZVJlbnQudHJ5UmVmaWxsKHJlY2lwaWVudCkKCiAgICB9Cn0\u003d" - }, - "nft": { - "checkNFTListEnabledNew": "
    // Flow Wallet - testnet Script  checkNFTListEnabled - v2.72
// <platform_info>


    import NonFungibleToken from 0x631e88ae7f1d7c20


    
    access(all) fun checkAllDay0x4dfd62c88d1b6462Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/AllDayNFTCollection)
      return vaultRef
    }
    

    access(all) fun checkDimensionX0x46664e2033f9853dVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/dmxCollection)
      return vaultRef
    }
    

    access(all) fun checkDimensionXComics0x46664e2033f9853dVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/dmxComicsCollection)
      return vaultRef
    }
    

    access(all) fun checkDoodles0x1c5033ad60821c97Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/doodles)
      return vaultRef
    }
    

    access(all) fun checkFlovatarComponent0x9392a4a7c3f49a0bVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlovatarComponentCollection)
      return vaultRef
    }
    

    access(all) fun checkFlowRewards0x2e7cfb413f04382fVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/flowRewardsCollectionPublic)
      return vaultRef
    }
    

    access(all) fun checkFlowtyTestNFT0xd9c02cdacccb25abVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlowtyTestNFTCollection)
      return vaultRef
    }
    

    access(all) fun checkFlowversePass0xc7c122b5b811de8eVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlowversePassCollection)
      return vaultRef
    }
    

    access(all) fun checkFlowverseShirt0xc7c122b5b811de8eVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlowverseShirtCollection)
      return vaultRef
    }
    

    access(all) fun checkFlowverseTreasures0xc7c122b5b811de8eVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlowverseTreasuresCollection)
      return vaultRef
    }
    

    access(all) fun checkFRC20SemiNFT0xb7248baa24a95c3fVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FRC20SemiNFT_0xb7248baa24a95c3fcollection)
      return vaultRef
    }
    

    access(all) fun checkGolazos0x1271da8a94edb0ffVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/GolazosNFTCollection)
      return vaultRef
    }
    

    access(all) fun checkHeroesOfTheFlow0x2d59ec5158e3adaeVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/HeroesOfTheFlowCollection)
      return vaultRef
    }
    

    access(all) fun checkIconoGraphika0x08b1f9c0bc04f36fVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/IconoGraphikaNFT)
      return vaultRef
    }
    

    access(all) fun checkJollyJokers0xe9760069d688ef5eVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/JollyJokersCollection)
      return vaultRef
    }
    

    access(all) fun checkMFLPack0x683564e46977788aVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/MFLPackCollection)
      return vaultRef
    }
    

    access(all) fun checkMFLPlayer0x683564e46977788aVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/MFLPlayerCollection)
      return vaultRef
    }
    

    access(all) fun checknba_NFT0x04625c28593d9408Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/nba_NFTCollection)
      return vaultRef
    }
    

    access(all) fun checkOrdinal0xc7c122b5b811de8eVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/OrdinalCollection)
      return vaultRef
    }
    

    access(all) fun checkPackNFT0x4dfd62c88d1b6462Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/PackNFTCollectionPub)
      return vaultRef
    }
    

    access(all) fun checkTicalUniverse0x58b60c5240d3f39bVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/TicalUniverseCollection)
      return vaultRef
    }
    

    access(all) fun checktoddnewstaging2_NFT0x2dcd833119c0570cVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/toddnewstaging2_NFTCollection)
      return vaultRef
    }
    

    access(all) fun checkTopShot0x877931736ee77cffVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/MomentCollection)
      return vaultRef
    }
    

    access(all) fun checkTuneGO0x58b60c5240d3f39bVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/TuneGOCollection)
      return vaultRef
    }
    

    access(all) fun checkTuneGONFTV50x58b60c5240d3f39bVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/tunegoNFTCollection013)
      return vaultRef
    }
    

    access(all) fun checkufcInt_NFT0x04625c28593d9408Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/ufcInt_NFTCollection)
      return vaultRef
    }
    

    access(all) fun checkWearables0x1c5033ad60821c97Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/wearables)
      return vaultRef
    }
    

    access(all) fun checkZeedzINO0x7dc7430a06f38af3Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/ZeedzINOCollection)
      return vaultRef
    }
    

    access(all) fun checkEVMVMBridgedNFT_c2a60e868fb75b7ea2e24de2e07ea9e552b5ab610xdfc20aee650fcbdfVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/EVMVMBridgedNFT_c2a60e868fb75b7ea2e24de2e07ea9e552b5ab61Collection)
      return vaultRef
    }
    

    access(all) fun checkEVMVMBridgedNFT_3fe47f54dbb0c9e2c98c3ac1b327720e18c067460xdfc20aee650fcbdfVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/EVMVMBridgedNFT_3fe47f54dbb0c9e2c98c3ac1b327720e18c06746Collection)
      return vaultRef
    }
    

    access(all) fun checkEVMVMBridgedNFT_9204ea1f54212963f210ec89c712594ff52912230xdfc20aee650fcbdfVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/EVMVMBridgedNFT_9204ea1f54212963f210ec89c712594ff5291223Collection)
      return vaultRef
    }
    
    access(all) fun main(address: Address) : {String: Bool} {
      return {
    "A.4dfd62c88d1b6462.AllDay" :
    checkAllDay0x4dfd62c88d1b6462Vault(address: address)
    ,
    "A.46664e2033f9853d.DimensionX" :
    checkDimensionX0x46664e2033f9853dVault(address: address)
    ,
    "A.46664e2033f9853d.DimensionXComics" :
    checkDimensionXComics0x46664e2033f9853dVault(address: address)
    ,
    "A.1c5033ad60821c97.Doodles" :
    checkDoodles0x1c5033ad60821c97Vault(address: address)
    ,
    "A.9392a4a7c3f49a0b.FlovatarComponent" :
    checkFlovatarComponent0x9392a4a7c3f49a0bVault(address: address)
    ,
    "A.2e7cfb413f04382f.FlowRewards" :
    checkFlowRewards0x2e7cfb413f04382fVault(address: address)
    ,
    "A.d9c02cdacccb25ab.FlowtyTestNFT" :
    checkFlowtyTestNFT0xd9c02cdacccb25abVault(address: address)
    ,
    "A.c7c122b5b811de8e.FlowversePass" :
    checkFlowversePass0xc7c122b5b811de8eVault(address: address)
    ,
    "A.c7c122b5b811de8e.FlowverseShirt" :
    checkFlowverseShirt0xc7c122b5b811de8eVault(address: address)
    ,
    "A.c7c122b5b811de8e.FlowverseTreasures" :
    checkFlowverseTreasures0xc7c122b5b811de8eVault(address: address)
    ,
    "A.b7248baa24a95c3f.FRC20SemiNFT" :
    checkFRC20SemiNFT0xb7248baa24a95c3fVault(address: address)
    ,
    "A.1271da8a94edb0ff.Golazos" :
    checkGolazos0x1271da8a94edb0ffVault(address: address)
    ,
    "A.2d59ec5158e3adae.HeroesOfTheFlow" :
    checkHeroesOfTheFlow0x2d59ec5158e3adaeVault(address: address)
    ,
    "A.08b1f9c0bc04f36f.IconoGraphika" :
    checkIconoGraphika0x08b1f9c0bc04f36fVault(address: address)
    ,
    "A.e9760069d688ef5e.JollyJokers" :
    checkJollyJokers0xe9760069d688ef5eVault(address: address)
    ,
    "A.683564e46977788a.MFLPack" :
    checkMFLPack0x683564e46977788aVault(address: address)
    ,
    "A.683564e46977788a.MFLPlayer" :
    checkMFLPlayer0x683564e46977788aVault(address: address)
    ,
    "A.04625c28593d9408.nba_NFT" :
    checknba_NFT0x04625c28593d9408Vault(address: address)
    ,
    "A.c7c122b5b811de8e.Ordinal" :
    checkOrdinal0xc7c122b5b811de8eVault(address: address)
    ,
    "A.4dfd62c88d1b6462.PackNFT" :
    checkPackNFT0x4dfd62c88d1b6462Vault(address: address)
    ,
    "A.58b60c5240d3f39b.TicalUniverse" :
    checkTicalUniverse0x58b60c5240d3f39bVault(address: address)
    ,
    "A.2dcd833119c0570c.toddnewstaging2_NFT" :
    checktoddnewstaging2_NFT0x2dcd833119c0570cVault(address: address)
    ,
    "A.877931736ee77cff.TopShot" :
    checkTopShot0x877931736ee77cffVault(address: address)
    ,
    "A.58b60c5240d3f39b.TuneGO" :
    checkTuneGO0x58b60c5240d3f39bVault(address: address)
    ,
    "A.58b60c5240d3f39b.TuneGONFTV5" :
    checkTuneGONFTV50x58b60c5240d3f39bVault(address: address)
    ,
    "A.04625c28593d9408.ufcInt_NFT" :
    checkufcInt_NFT0x04625c28593d9408Vault(address: address)
    ,
    "A.1c5033ad60821c97.Wearables" :
    checkWearables0x1c5033ad60821c97Vault(address: address)
    ,
    "A.7dc7430a06f38af3.ZeedzINO" :
    checkZeedzINO0x7dc7430a06f38af3Vault(address: address)
    ,
    "A.dfc20aee650fcbdf.EVMVMBridgedNFT_c2a60e868fb75b7ea2e24de2e07ea9e552b5ab61" :
    checkEVMVMBridgedNFT_c2a60e868fb75b7ea2e24de2e07ea9e552b5ab610xdfc20aee650fcbdfVault(address: address)
    ,
    "A.dfc20aee650fcbdf.EVMVMBridgedNFT_3fe47f54dbb0c9e2c98c3ac1b327720e18c06746" :
    checkEVMVMBridgedNFT_3fe47f54dbb0c9e2c98c3ac1b327720e18c067460xdfc20aee650fcbdfVault(address: address)
    ,
    "A.dfc20aee650fcbdf.EVMVMBridgedNFT_9204ea1f54212963f210ec89c712594ff5291223" :
    checkEVMVMBridgedNFT_9204ea1f54212963f210ec89c712594ff52912230xdfc20aee650fcbdfVault(address: address)
    }
    }
  ", - "checkNFTListEnabled": "
    // Flow Wallet - testnet Script  checkNFTListEnabled - v2.72
// <platform_info>


    import NonFungibleToken from 0x631e88ae7f1d7c20


    
    access(all) fun checkAllDay0x4dfd62c88d1b6462Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/AllDayNFTCollection)
      return vaultRef
    }
    

    access(all) fun checkDimensionX0x46664e2033f9853dVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/dmxCollection)
      return vaultRef
    }
    

    access(all) fun checkDimensionXComics0x46664e2033f9853dVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/dmxComicsCollection)
      return vaultRef
    }
    

    access(all) fun checkDoodles0x1c5033ad60821c97Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/doodles)
      return vaultRef
    }
    

    access(all) fun checkFlovatarComponent0x9392a4a7c3f49a0bVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlovatarComponentCollection)
      return vaultRef
    }
    

    access(all) fun checkFlowRewards0x2e7cfb413f04382fVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/flowRewardsCollectionPublic)
      return vaultRef
    }
    

    access(all) fun checkFlowtyTestNFT0xd9c02cdacccb25abVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlowtyTestNFTCollection)
      return vaultRef
    }
    

    access(all) fun checkFlowversePass0xc7c122b5b811de8eVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlowversePassCollection)
      return vaultRef
    }
    

    access(all) fun checkFlowverseShirt0xc7c122b5b811de8eVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlowverseShirtCollection)
      return vaultRef
    }
    

    access(all) fun checkFlowverseTreasures0xc7c122b5b811de8eVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlowverseTreasuresCollection)
      return vaultRef
    }
    

    access(all) fun checkFRC20SemiNFT0xb7248baa24a95c3fVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FRC20SemiNFT_0xb7248baa24a95c3fcollection)
      return vaultRef
    }
    

    access(all) fun checkGolazos0x1271da8a94edb0ffVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/GolazosNFTCollection)
      return vaultRef
    }
    

    access(all) fun checkHeroesOfTheFlow0x2d59ec5158e3adaeVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/HeroesOfTheFlowCollection)
      return vaultRef
    }
    

    access(all) fun checkIconoGraphika0x08b1f9c0bc04f36fVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/IconoGraphikaNFT)
      return vaultRef
    }
    

    access(all) fun checkJollyJokers0xe9760069d688ef5eVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/JollyJokersCollection)
      return vaultRef
    }
    

    access(all) fun checkMFLPack0x683564e46977788aVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/MFLPackCollection)
      return vaultRef
    }
    

    access(all) fun checkMFLPlayer0x683564e46977788aVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/MFLPlayerCollection)
      return vaultRef
    }
    

    access(all) fun checknba_NFT0x04625c28593d9408Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/nba_NFTCollection)
      return vaultRef
    }
    

    access(all) fun checkOrdinal0xc7c122b5b811de8eVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/OrdinalCollection)
      return vaultRef
    }
    

    access(all) fun checkPackNFT0x4dfd62c88d1b6462Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/PackNFTCollectionPub)
      return vaultRef
    }
    

    access(all) fun checkTicalUniverse0x58b60c5240d3f39bVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/TicalUniverseCollection)
      return vaultRef
    }
    

    access(all) fun checktoddnewstaging2_NFT0x2dcd833119c0570cVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/toddnewstaging2_NFTCollection)
      return vaultRef
    }
    

    access(all) fun checkTopShot0x877931736ee77cffVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/MomentCollection)
      return vaultRef
    }
    

    access(all) fun checkTuneGO0x58b60c5240d3f39bVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/TuneGOCollection)
      return vaultRef
    }
    

    access(all) fun checkTuneGONFTV50x58b60c5240d3f39bVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/tunegoNFTCollection013)
      return vaultRef
    }
    

    access(all) fun checkufcInt_NFT0x04625c28593d9408Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/ufcInt_NFTCollection)
      return vaultRef
    }
    

    access(all) fun checkWearables0x1c5033ad60821c97Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/wearables)
      return vaultRef
    }
    

    access(all) fun checkZeedzINO0x7dc7430a06f38af3Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/ZeedzINOCollection)
      return vaultRef
    }
    

    access(all) fun checkEVMVMBridgedNFT_c2a60e868fb75b7ea2e24de2e07ea9e552b5ab610xdfc20aee650fcbdfVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/EVMVMBridgedNFT_c2a60e868fb75b7ea2e24de2e07ea9e552b5ab61Collection)
      return vaultRef
    }
    

    access(all) fun checkEVMVMBridgedNFT_3fe47f54dbb0c9e2c98c3ac1b327720e18c067460xdfc20aee650fcbdfVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/EVMVMBridgedNFT_3fe47f54dbb0c9e2c98c3ac1b327720e18c06746Collection)
      return vaultRef
    }
    

    access(all) fun checkEVMVMBridgedNFT_9204ea1f54212963f210ec89c712594ff52912230xdfc20aee650fcbdfVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/EVMVMBridgedNFT_9204ea1f54212963f210ec89c712594ff5291223Collection)
      return vaultRef
    }
    
    access(all) fun main(address: Address) : {String: Bool} {
      return {
    "A.4dfd62c88d1b6462.AllDay" :
    checkAllDay0x4dfd62c88d1b6462Vault(address: address)
    ,
    "A.46664e2033f9853d.DimensionX" :
    checkDimensionX0x46664e2033f9853dVault(address: address)
    ,
    "A.46664e2033f9853d.DimensionXComics" :
    checkDimensionXComics0x46664e2033f9853dVault(address: address)
    ,
    "A.1c5033ad60821c97.Doodles" :
    checkDoodles0x1c5033ad60821c97Vault(address: address)
    ,
    "A.9392a4a7c3f49a0b.FlovatarComponent" :
    checkFlovatarComponent0x9392a4a7c3f49a0bVault(address: address)
    ,
    "A.2e7cfb413f04382f.FlowRewards" :
    checkFlowRewards0x2e7cfb413f04382fVault(address: address)
    ,
    "A.d9c02cdacccb25ab.FlowtyTestNFT" :
    checkFlowtyTestNFT0xd9c02cdacccb25abVault(address: address)
    ,
    "A.c7c122b5b811de8e.FlowversePass" :
    checkFlowversePass0xc7c122b5b811de8eVault(address: address)
    ,
    "A.c7c122b5b811de8e.FlowverseShirt" :
    checkFlowverseShirt0xc7c122b5b811de8eVault(address: address)
    ,
    "A.c7c122b5b811de8e.FlowverseTreasures" :
    checkFlowverseTreasures0xc7c122b5b811de8eVault(address: address)
    ,
    "A.b7248baa24a95c3f.FRC20SemiNFT" :
    checkFRC20SemiNFT0xb7248baa24a95c3fVault(address: address)
    ,
    "A.1271da8a94edb0ff.Golazos" :
    checkGolazos0x1271da8a94edb0ffVault(address: address)
    ,
    "A.2d59ec5158e3adae.HeroesOfTheFlow" :
    checkHeroesOfTheFlow0x2d59ec5158e3adaeVault(address: address)
    ,
    "A.08b1f9c0bc04f36f.IconoGraphika" :
    checkIconoGraphika0x08b1f9c0bc04f36fVault(address: address)
    ,
    "A.e9760069d688ef5e.JollyJokers" :
    checkJollyJokers0xe9760069d688ef5eVault(address: address)
    ,
    "A.683564e46977788a.MFLPack" :
    checkMFLPack0x683564e46977788aVault(address: address)
    ,
    "A.683564e46977788a.MFLPlayer" :
    checkMFLPlayer0x683564e46977788aVault(address: address)
    ,
    "A.04625c28593d9408.nba_NFT" :
    checknba_NFT0x04625c28593d9408Vault(address: address)
    ,
    "A.c7c122b5b811de8e.Ordinal" :
    checkOrdinal0xc7c122b5b811de8eVault(address: address)
    ,
    "A.4dfd62c88d1b6462.PackNFT" :
    checkPackNFT0x4dfd62c88d1b6462Vault(address: address)
    ,
    "A.58b60c5240d3f39b.TicalUniverse" :
    checkTicalUniverse0x58b60c5240d3f39bVault(address: address)
    ,
    "A.2dcd833119c0570c.toddnewstaging2_NFT" :
    checktoddnewstaging2_NFT0x2dcd833119c0570cVault(address: address)
    ,
    "A.877931736ee77cff.TopShot" :
    checkTopShot0x877931736ee77cffVault(address: address)
    ,
    "A.58b60c5240d3f39b.TuneGO" :
    checkTuneGO0x58b60c5240d3f39bVault(address: address)
    ,
    "A.58b60c5240d3f39b.TuneGONFTV5" :
    checkTuneGONFTV50x58b60c5240d3f39bVault(address: address)
    ,
    "A.04625c28593d9408.ufcInt_NFT" :
    checkufcInt_NFT0x04625c28593d9408Vault(address: address)
    ,
    "A.1c5033ad60821c97.Wearables" :
    checkWearables0x1c5033ad60821c97Vault(address: address)
    ,
    "A.7dc7430a06f38af3.ZeedzINO" :
    checkZeedzINO0x7dc7430a06f38af3Vault(address: address)
    ,
    "A.dfc20aee650fcbdf.EVMVMBridgedNFT_c2a60e868fb75b7ea2e24de2e07ea9e552b5ab61" :
    checkEVMVMBridgedNFT_c2a60e868fb75b7ea2e24de2e07ea9e552b5ab610xdfc20aee650fcbdfVault(address: address)
    ,
    "A.dfc20aee650fcbdf.EVMVMBridgedNFT_3fe47f54dbb0c9e2c98c3ac1b327720e18c06746" :
    checkEVMVMBridgedNFT_3fe47f54dbb0c9e2c98c3ac1b327720e18c067460xdfc20aee650fcbdfVault(address: address)
    ,
    "A.dfc20aee650fcbdf.EVMVMBridgedNFT_9204ea1f54212963f210ec89c712594ff5291223" :
    checkEVMVMBridgedNFT_9204ea1f54212963f210ec89c712594ff52912230xdfc20aee650fcbdfVault(address: address)
    }
    }
  " - }, "basic": { - "accountStorage": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYWNjb3VudFN0b3JhZ2UgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCiBhY2Nlc3MoYWxsKSBzdHJ1Y3QgU3RvcmFnZUluZm8gewogICAgYWNjZXNzKGFsbCkgIGxldCBjYXBhY2l0eTogVUludDY0CiAgICBhY2Nlc3MoYWxsKSAgbGV0IHVzZWQ6IFVJbnQ2NAogICAgYWNjZXNzKGFsbCkgIGxldCBhdmFpbGFibGU6IFVJbnQ2NAoKICAgIGluaXQoY2FwYWNpdHk6IFVJbnQ2NCwgdXNlZDogVUludDY0LCBhdmFpbGFibGU6IFVJbnQ2NCkgewogICAgICAgIHNlbGYuY2FwYWNpdHkgPSBjYXBhY2l0eQogICAgICAgIHNlbGYudXNlZCA9IHVzZWQKICAgICAgICBzZWxmLmF2YWlsYWJsZSA9IGF2YWlsYWJsZQogICAgfQp9CgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyOiBBZGRyZXNzKTogU3RvcmFnZUluZm8gewogICAgbGV0IGFjY3QgPSBnZXRBY2NvdW50KGFkZHIpCiAgICB2YXIgYXZhaWxhYmxlOiBVSW50NjQgPSAwCiAgICBpZiBhY2N0LnN0b3JhZ2UuY2FwYWNpdHkgPiAwIHsKICAgICAgICBhdmFpbGFibGUgPSBhY2N0LnN0b3JhZ2UuY2FwYWNpdHkgLSBhY2N0LnN0b3JhZ2UudXNlZAogICAgfQogICAgcmV0dXJuIFN0b3JhZ2VJbmZvKGNhcGFjaXR5OiBhY2N0LnN0b3JhZ2UuY2FwYWNpdHksCiAgICAgICAgICAgIHVzZWQ6IGFjY3Quc3RvcmFnZS51c2VkLAogICAgICAgICAgICBhdmFpbGFibGU6IGF2YWlsYWJsZSkKfQ\u003d\u003d", - "addContractToAccount": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYWRkQ29udHJhY3RUb0FjY291bnQgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCnRyYW5zYWN0aW9uKG5hbWU6IFN0cmluZywgY29kZTogU3RyaW5nKSB7CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChDb250cmFjdHMsIEFkZENvbnRyYWN0KSAmQWNjb3VudCkgewogICAgICAgIHNpZ25lci5jb250cmFjdHMuYWRkKG5hbWU6IG5hbWUsIGNvZGU6IGNvZGUudXRmOCkKICAgIH0KfQ\u003d\u003d", - "addKey": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYWRkS2V5IC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgQ3J5cHRvCgp0cmFuc2FjdGlvbihwdWJsaWNLZXk6IFN0cmluZywgc2lnbmF0dXJlQWxnb3JpdGhtOiBVSW50OCwgaGFzaEFsZ29yaXRobTogVUludDgsIHdlaWdodDogVUZpeDY0KSB7CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChLZXlzKSAmQWNjb3VudCkgewogICAgICAgIGxldCBrZXkgPSBQdWJsaWNLZXkoCiAgICAgICAgICAgIHB1YmxpY0tleTogcHVibGljS2V5LmRlY29kZUhleCgpLAogICAgICAgICAgICBzaWduYXR1cmVBbGdvcml0aG06IFNpZ25hdHVyZUFsZ29yaXRobShyYXdWYWx1ZTogc2lnbmF0dXJlQWxnb3JpdGhtKSEKICAgICAgICApCgogICAgICAgIHNpZ25lci5rZXlzLmFkZCgKICAgICAgICAgICAgcHVibGljS2V5OiBrZXksCiAgICAgICAgICAgIGhhc2hBbGdvcml0aG06IEhhc2hBbGdvcml0aG0ocmF3VmFsdWU6IGhhc2hBbGdvcml0aG0pISwKICAgICAgICAgICAgd2VpZ2h0OiB3ZWlnaHQKICAgICAgICApCiAgICB9Cn0\u003d", - "addKeyTemp": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYWRkS2V5VGVtcCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IENyeXB0bwoKdHJhbnNhY3Rpb24ocHVibGljS2V5czogW0NyeXB0by5LZXlMaXN0RW50cnldLCBjb250cmFjdHM6IHtTdHJpbmc6IFN0cmluZ30pIHsKCXByZXBhcmUoc2lnbmVyOiBhdXRoKEJvcnJvd1ZhbHVlIHwgU3RvcmFnZSkgJkFjY291bnQpIHsKCgkJbGV0IGFjY291bnQgPSBBY2NvdW50KHBheWVyOiBzaWduZXIpCgoJCS8vIGFkZCBhbGwgdGhlIGtleXMgdG8gdGhlIGFjY291bnQKCQlmb3Iga2V5IGluIHB1YmxpY0tleXMgewoJCQlhY2NvdW50LmtleXMuYWRkKHB1YmxpY0tleToga2V5LnB1YmxpY0tleSwgaGFzaEFsZ29yaXRobToga2V5Lmhhc2hBbGdvcml0aG0sIHdlaWdodDoga2V5LndlaWdodCkKCQl9CgkJCgkJLy8gYWRkIGNvbnRyYWN0cyBpZiBwcm92aWRlZAoJCWZvciBjb250cmFjdCBpbiBjb250cmFjdHMua2V5cyB7CgkJCWFjY291bnQuY29udHJhY3RzLmFkZChuYW1lOiBjb250cmFjdCwgY29kZTogY29udHJhY3RzW2NvbnRyYWN0XSEuZGVjb2RlSGV4KCkpCgkJfQoJfQp9", - "createAccount": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY3JlYXRlQWNjb3VudCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IENyeXB0bwppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHg3ZTYwZGYwNDJhOWMwODY4CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKCiB0cmFuc2FjdGlvbihwdWJsaWNLZXlzOiBbQ3J5cHRvLktleUxpc3RFbnRyeV0sIGNvbnRyYWN0czoge1N0cmluZzogU3RyaW5nfSwgZnVuZEFtb3VudDogVUZpeDY0KSB7CiAgICBsZXQgdG9rZW5SZWNlaXZlcjogJntGdW5naWJsZVRva2VuLlJlY2VpdmVyfQogICAgbGV0IHNlbnRWYXVsdDogQEZ1bmdpYmxlVG9rZW4uVmF1bHQKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChCb3Jyb3dWYWx1ZSB8IFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IGFjY291bnQgPSBBY2NvdW50KHBheWVyOiBzaWduZXIpCiAgICAgICAgZm9yIGtleSBpbiBwdWJsaWNLZXlzIHsKICAgICAgICAgICAgYWNjb3VudC5rZXlzLmFkZChwdWJsaWNLZXk6IGtleS5wdWJsaWNLZXksIGhhc2hBbGdvcml0aG06IGtleS5oYXNoQWxnb3JpdGhtLCB3ZWlnaHQ6IGtleS53ZWlnaHQpCiAgICAgICAgfQogICAgICAgIGZvciBjb250cmFjdCBpbiBjb250cmFjdHMua2V5cyB7CiAgICAgICAgICAgIGFjY291bnQuY29udHJhY3RzLmFkZChuYW1lOiBjb250cmFjdCwgY29kZTogY29udHJhY3RzW2NvbnRyYWN0XSEuZGVjb2RlSGV4KCkpCiAgICAgICAgfQogICAgICAgIHNlbGYudG9rZW5SZWNlaXZlciA9IGFjY291bnQuY2FwYWJpbGl0aWVzLmJvcnJvdzwme0Z1bmdpYmxlVG9rZW4uUmVjZWl2ZXJ9PigvcHVibGljL2Zsb3dUb2tlblJlY2VpdmVyKSA/PyBwYW5pYygiVW5hYmxlIHRvIGJvcnJvdyByZWNlaXZlciByZWZlcmVuY2UiKQogICAgICAgIGxldCB2YXVsdFJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZGbG93VG9rZW4uVmF1bHQ+KGZyb206IC9zdG9yYWdlL2Zsb3dUb2tlblZhdWx0KSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIG93bmVyJydzIFZhdWx0ISIpCiAgICAgICAgc2VsZi5zZW50VmF1bHQgPC0gdmF1bHRSZWYud2l0aGRyYXcoYW1vdW50OiBmdW5kQW1vdW50KQogICAgfQogICAgZXhlY3V0ZSB7CiAgICAgICAgc2VsZi50b2tlblJlY2VpdmVyLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKICAgIH0KIH0\u003d", - "createAccountSdk": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY3JlYXRlQWNjb3VudFNkayAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IENyeXB0bwoKdHJhbnNhY3Rpb24ocHVibGljS2V5OiBTdHJpbmcsIHNpZ25hdHVyZUFsZ29yaXRobTogVUludDgsIGhhc2hBbGdvcml0aG06IFVJbnQ4LCB3ZWlnaHQ6IFVGaXg2NCwgY29udHJhY3RzOiB7U3RyaW5nOiBTdHJpbmd9KSB7CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChCb3Jyb3dWYWx1ZSB8IFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IGFjY291bnQgPSBBY2NvdW50KHBheWVyOiBzaWduZXIpCgogICAgICAgIGxldCBrZXkgPSBQdWJsaWNLZXkoCiAgICAgICAgICAgIHB1YmxpY0tleTogcHVibGljS2V5LmRlY29kZUhleCgpLAogICAgICAgICAgICBzaWduYXR1cmVBbGdvcml0aG06IFNpZ25hdHVyZUFsZ29yaXRobShyYXdWYWx1ZTogc2lnbmF0dXJlQWxnb3JpdGhtKSEKICAgICAgICApCgogICAgICAgIGFjY291bnQua2V5cy5hZGQoCiAgICAgICAgICAgIHB1YmxpY0tleToga2V5LAogICAgICAgICAgICBoYXNoQWxnb3JpdGhtOiBIYXNoQWxnb3JpdGhtKHJhd1ZhbHVlOiBoYXNoQWxnb3JpdGhtKSEsCiAgICAgICAgICAgIHdlaWdodDogd2VpZ2h0CiAgICAgICAgKQoKICAgICAgICBmb3IgY29udHJhY3QgaW4gY29udHJhY3RzLmtleXMgewogICAgICAgICAgICBhY2NvdW50LmNvbnRyYWN0cy5hZGQobmFtZTogY29udHJhY3QsIGNvZGU6IGNvbnRyYWN0c1tjb250cmFjdF0hLmRlY29kZUhleCgpKQogICAgICAgIH0KICAgIH0KfQ\u003d\u003d", - "getAccountInfo": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QWNjb3VudEluZm8gLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmFjY2VzcyhhbGwpIHN0cnVjdCBSZXN1bHQgewogIGFjY2VzcyhhbGwpIGxldCBhZGRyZXNzOiBBZGRyZXNzCiAgYWNjZXNzKGFsbCkgbGV0IGJhbGFuY2U6IFVGaXg2NAogIGFjY2VzcyhhbGwpIGxldCBhdmFpbGFibGVCYWxhbmNlOiBVRml4NjQKICBhY2Nlc3MoYWxsKSBsZXQgc3RvcmFnZVVzZWQ6IFVJbnQ2NAogIGFjY2VzcyhhbGwpIGxldCBzdG9yYWdlQ2FwYWNpdHk6IFVJbnQ2NAogIGFjY2VzcyhhbGwpIGxldCBzdG9yYWdlRmxvdzogVUZpeDY0CgogIGluaXQoCiAgICBhZGRyZXNzOiBBZGRyZXNzLAogICAgYmFsYW5jZTogVUZpeDY0LAogICAgYXZhaWxhYmxlQmFsYW5jZTogVUZpeDY0LAogICAgc3RvcmFnZVVzZWQ6IFVJbnQ2NCwKICAgIHN0b3JhZ2VDYXBhY2l0eTogVUludDY0LAogICAgc3RvcmFnZUZsb3c6IFVGaXg2NCwKICApIHsKICAgIHNlbGYuYWRkcmVzcyA9IGFkZHJlc3MKICAgIHNlbGYuYmFsYW5jZSA9IGJhbGFuY2UKICAgIHNlbGYuYXZhaWxhYmxlQmFsYW5jZSA9IGF2YWlsYWJsZUJhbGFuY2UKICAgIHNlbGYuc3RvcmFnZVVzZWQgPSBzdG9yYWdlVXNlZAogICAgc2VsZi5zdG9yYWdlQ2FwYWNpdHkgPSBzdG9yYWdlQ2FwYWNpdHkKICAgIHNlbGYuc3RvcmFnZUZsb3cgPSBzdG9yYWdlRmxvdwogIH0KfQoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IFJlc3VsdCB7CiAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgcmV0dXJuIFJlc3VsdCgKICAgIGFkZHJlc3M6IGFjY291bnQuYWRkcmVzcywKICAgIGJhbGFuY2U6IGFjY291bnQuYmFsYW5jZSwKICAgIGF2YWlsYWJsZUJhbGFuY2U6IGFjY291bnQuYXZhaWxhYmxlQmFsYW5jZSwKICAgIHN0b3JhZ2VVc2VkOiBhY2NvdW50LnN0b3JhZ2UudXNlZCwKICAgIHN0b3JhZ2VDYXBhY2l0eTogYWNjb3VudC5zdG9yYWdlLmNhcGFjaXR5LAogICAgc3RvcmFnZUZsb3c6IGFjY291bnQuYmFsYW5jZSAtIGFjY291bnQuYXZhaWxhYmxlQmFsYW5jZQogICkKfQ\u003d\u003d", - "getAccountMinFlow": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QWNjb3VudE1pbkZsb3cgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBVRml4NjQgewogIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogIHJldHVybiBhY2NvdW50LmJhbGFuY2UgLSBhY2NvdW50LmF2YWlsYWJsZUJhbGFuY2UKfQ\u003d\u003d", - "getAccountTotalFlowBalance": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QWNjb3VudFRvdGFsRmxvd0JhbGFuY2UgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHg3ZTYwZGYwNDJhOWMwODY4CgppbXBvcnQgTG9ja2VkVG9rZW5zIGZyb20gMHg5NWUwMTlhMTdkMGUyM2Q3CgovLyBpbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKLy8gaW1wb3J0IEZsb3dUb2tlbiBmcm9tIDB4N2U2MGRmMDQyYTljMDg2OAoKLy8gaW1wb3J0IExvY2tlZFRva2VucyBmcm9tIDB4OTVlMDE5YTE3ZDBlMjNkNwoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBVRml4NjQgewogICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICBsZXQgdW5sb2NrZWRWYXVsdCA9IGFjY291bnQKICAgICAgLmNhcGFiaWxpdGllcy5nZXQ8JntGdW5naWJsZVRva2VuLkJhbGFuY2V9PigvcHVibGljL2Zsb3dUb2tlbkJhbGFuY2UpIQogICAgICAuYm9ycm93KCkKICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBCYWxhbmNlIHJlZmVyZW5jZSB0byB0aGUgVmF1bHQiKQogICAgbGV0IHVubG9ja2VkQmFsYW5jZSA9IHVubG9ja2VkVmF1bHQuYmFsYW5jZQogICAgICAgIAogICAgbGV0IGxvY2tlZEFjY291bnRJbmZvQ2FwID0gYWNjb3VudAogICAgICAuY2FwYWJpbGl0aWVzLmdldAogICAgICA8JkxvY2tlZFRva2Vucy5Ub2tlbkhvbGRlcj4KICAgICAgKExvY2tlZFRva2Vucy5Mb2NrZWRBY2NvdW50SW5mb1B1YmxpY1BhdGgpCiAgICBpZiBsb2NrZWRBY2NvdW50SW5mb0NhcCA9PSBuaWwgfHwgIShsb2NrZWRBY2NvdW50SW5mb0NhcCEuY2hlY2soKSkgewogICAgICAgIHJldHVybiB1bmxvY2tlZEJhbGFuY2UKICAgIH0KICAgIAogICAgbGV0IGxvY2tlZEFjY291bnRJbmZvUmVmID0gbG9ja2VkQWNjb3VudEluZm9DYXAhLmJvcnJvdygpIQogICAgbGV0IGxvY2tlZEJhbGFuY2UgPSBsb2NrZWRBY2NvdW50SW5mb1JlZi5nZXRMb2NrZWRBY2NvdW50QmFsYW5jZSgpCiAgICAKICAgIHJldHVybiBsb2NrZWRCYWxhbmNlICsgdW5sb2NrZWRCYWxhbmNlCn0\u003d", - "getAccountTotalLockedFlowBalance": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QWNjb3VudFRvdGFsTG9ja2VkRmxvd0JhbGFuY2UgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHg3ZTYwZGYwNDJhOWMwODY4CgppbXBvcnQgTG9ja2VkVG9rZW5zIGZyb20gMHg5NWUwMTlhMTdkMGUyM2Q3CgoKLy8gaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCi8vIGltcG9ydCBGbG93VG9rZW4gZnJvbSAweDdlNjBkZjA0MmE5YzA4NjgKCi8vIGltcG9ydCBMb2NrZWRUb2tlbnMgZnJvbSAweDk1ZTAxOWExN2QwZTIzZDcKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzKTogVUZpeDY0IHsKICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQoKICAgIGxldCBsb2NrZWRBY2NvdW50SW5mb0NhcCA9IGFjY291bnQKICAgICAgLmNhcGFiaWxpdGllcy5nZXQKICAgICAgPCZMb2NrZWRUb2tlbnMuVG9rZW5Ib2xkZXI+CiAgICAgIChMb2NrZWRUb2tlbnMuTG9ja2VkQWNjb3VudEluZm9QdWJsaWNQYXRoKQogICAgaWYgbG9ja2VkQWNjb3VudEluZm9DYXAgPT0gbmlsIHx8ICEobG9ja2VkQWNjb3VudEluZm9DYXAhLmNoZWNrKCkpIHsKICAgICAgICByZXR1cm4gVUZpeDY0KDApCiAgICB9CiAgICAKICAgIGxldCBsb2NrZWRBY2NvdW50SW5mb1JlZiA9IGxvY2tlZEFjY291bnRJbmZvQ2FwIS5ib3Jyb3coKSEKICAgIGxldCBsb2NrZWRCYWxhbmNlID0gbG9ja2VkQWNjb3VudEluZm9SZWYuZ2V0TG9ja2VkQWNjb3VudEJhbGFuY2UoKQogICAgCiAgICByZXR1cm4gbG9ja2VkQmFsYW5jZQp9", - "getAccountTotalUnlockedFlowBalance": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QWNjb3VudFRvdGFsVW5sb2NrZWRGbG93QmFsYW5jZSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKLy8gaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCi8vIGltcG9ydCBGbG93VG9rZW4gZnJvbSAweDdlNjBkZjA0MmE5YzA4NjgKCi8vIGltcG9ydCBMb2NrZWRUb2tlbnMgZnJvbSAweDk1ZTAxOWExN2QwZTIzZDcKCgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKaW1wb3J0IEZsb3dUb2tlbiBmcm9tIDB4N2U2MGRmMDQyYTljMDg2OAoKaW1wb3J0IExvY2tlZFRva2VucyBmcm9tIDB4OTVlMDE5YTE3ZDBlMjNkNwoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBVRml4NjQgewogICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCgogICAgbGV0IHVubG9ja2VkVmF1bHQgPSBhY2NvdW50CiAgICAgIC5jYXBhYmlsaXRpZXMuZ2V0PCZGbG93VG9rZW4uVmF1bHQ+KC9wdWJsaWMvZmxvd1Rva2VuQmFsYW5jZSkhCiAgICAgIC5ib3Jyb3coKQogICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IEJhbGFuY2UgcmVmZXJlbmNlIHRvIHRoZSBWYXVsdCIpCiAgICBsZXQgdW5sb2NrZWRCYWxhbmNlID0gdW5sb2NrZWRWYXVsdC5iYWxhbmNlCgogICAgbGV0IGxvY2tlZEFjY291bnRJbmZvQ2FwID0gYWNjb3VudAogICAgICAuY2FwYWJpbGl0aWVzLmdldAogICAgICA8JkxvY2tlZFRva2Vucy5Ub2tlbkhvbGRlcj4KICAgICAgKExvY2tlZFRva2Vucy5Mb2NrZWRBY2NvdW50SW5mb1B1YmxpY1BhdGgpCiAgICBpZiBsb2NrZWRBY2NvdW50SW5mb0NhcCA9PSBuaWwgfHwgIShsb2NrZWRBY2NvdW50SW5mb0NhcCEuY2hlY2soKSkgewogICAgICAgIHJldHVybiB1bmxvY2tlZEJhbGFuY2UKICAgIH0KICAgIAogICAgbGV0IGxvY2tlZEFjY291bnRJbmZvUmVmID0gbG9ja2VkQWNjb3VudEluZm9DYXAhLmJvcnJvdygpIQogICAgbGV0IGxvY2tlZEJhbGFuY2UgPSBsb2NrZWRBY2NvdW50SW5mb1JlZi5nZXRMb2NrZWRBY2NvdW50QmFsYW5jZSgpCiAgICBsZXQgbG9ja2VkQmFsYW5jZVVubG9ja2VkID0gbG9ja2VkQWNjb3VudEluZm9SZWYuZ2V0VW5sb2NrTGltaXQoKQoKICAgIGlmIGxvY2tlZEJhbGFuY2UgPT0gVUZpeDY0KDApIHsKICAgICAgICByZXR1cm4gdW5sb2NrZWRCYWxhbmNlCiAgICB9CgogICAgaWYgbG9ja2VkQmFsYW5jZVVubG9ja2VkID4gbG9ja2VkQmFsYW5jZSB7CiAgICAgICAgcmV0dXJuIHVubG9ja2VkQmFsYW5jZSArIGxvY2tlZEJhbGFuY2UKICAgIH0KCiAgICByZXR1cm4gbG9ja2VkQmFsYW5jZVVubG9ja2VkICsgdW5sb2NrZWRCYWxhbmNlCn0\u003d", - "getAccountsDetail": "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", - "getFindAddress": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0RmluZEFkZHJlc3MgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGSU5EIGZyb20gMHhhMTZhYjFkMGFiZGUzNjI1CgovL0NoZWNrIHRoZSBzdGF0dXMgb2YgYSBmaW4gdXNlcgphY2Nlc3MoYWxsKSBmdW4gbWFpbihuYW1lOiBTdHJpbmcpIDogQWRkcmVzcz8gewogICAgbGV0IHN0YXR1cyA9IEZJTkQuc3RhdHVzKG5hbWUpCiAgICByZXR1cm4gc3RhdHVzLm93bmVyCn0\u003d", - "getFindDomainByAddress": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0RmluZERvbWFpbkJ5QWRkcmVzcyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZJTkQgZnJvbSAweGExNmFiMWQwYWJkZTM2MjUKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzKSA6IFN0cmluZz97CiAgICByZXR1cm4gRklORC5yZXZlcnNlTG9va3VwKGFkZHJlc3MpCn0\u003d", - "getFlowBalanceForAnyAccounts": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0Rmxvd0JhbGFuY2VGb3JBbnlBY2NvdW50cyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKCi8vIEdldCB0aGUgYWNjb3VudCBiYWxhbmNlIGZvciBhIENPQSBhY2NvdW50CmFjY2VzcyhhbGwpIGZ1biBnZXRFVk1CYWxhbmNlKF8gYWRkcmVzczogU3RyaW5nKTogVUZpeDY0PyB7CiAgICByZXR1cm4gRVZNLmFkZHJlc3NGcm9tU3RyaW5nKGFkZHJlc3MpLmJhbGFuY2UoKS5pbkZMT1coKQp9CgovLyBHZXQgdGhlIGF2YWlsYWJsZSBhY2NvdW50IGJhbGFuY2UgZm9yIGEgRmxvdyBhY2NvdW50CmFjY2VzcyhhbGwpIGZ1biBnZXRGbG93QmFsYW5jZShfIGFkZHJlc3M6IFN0cmluZyk6IFVGaXg2ND8gewogICAgaWYgbGV0IGFjY291bnQgPSBBZGRyZXNzLmZyb21TdHJpbmcoYWRkcmVzcykgewogICAgICAgIC8vIFVzZSBhdmFpbGFibGUgYmFsYW5jZSBpbnN0ZWFkIG9mIHRvdGFsIGJhbGFuY2UKICAgICAgICByZXR1cm4gZ2V0QWNjb3VudChhY2NvdW50KS5hdmFpbGFibGVCYWxhbmNlCiAgICB9CiAgICByZXR1cm4gbmlsCn0KCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3NlczogW1N0cmluZ10pOiB7U3RyaW5nOiBVRml4NjQ/fSB7CiAgICBsZXQgcmVzOiB7U3RyaW5nOiBVRml4NjQ/fSA9IHt9CgogICAgZm9yIGFkZHIgaW4gYWRkcmVzc2VzIHsKICAgICAgICBsZXQgaGV4ID0gYWRkclsxXSA9PSAieCIgPyBhZGRyIDogIjB4Ii5jb25jYXQoYWRkcikKICAgICAgICBpZiBsZXQgZmxvd0JhbGFuY2UgPSBnZXRGbG93QmFsYW5jZShoZXgpIHsKICAgICAgICAgICAgcmVzW2hleF0gPSBmbG93QmFsYW5jZQogICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgIGlmIGxldCBldm1CYWxhbmNlID0gZ2V0RVZNQmFsYW5jZShoZXgpIHsKICAgICAgICAgICAgICAgIHJlc1toZXhdID0gZXZtQmFsYW5jZQogICAgICAgICAgICB9CiAgICAgICAgfQogICAgfQogICAgcmV0dXJuIHJlcwp9", - "getFlownsAddress": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0Rmxvd25zQWRkcmVzcyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3ducyBmcm9tIDB4YjA1YjJhYmI0MjMzNWU4OAoKaW1wb3J0IERvbWFpbnMgZnJvbSAweGIwNWIyYWJiNDIzMzVlODgKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihuYW1lOiBTdHJpbmcsIHJvb3Q6IFN0cmluZykgOiBBZGRyZXNzPyB7CiAgICBsZXQgcHJlZml4ID0gIjB4IgogICAgbGV0IHJvb3RIYWhzaCA9IEZsb3ducy5oYXNoKG5vZGU6ICIiLCBsYWJsZTogcm9vdCkKICAgIGxldCBuYW1laGFzaCA9IHByZWZpeC5jb25jYXQoRmxvd25zLmhhc2gobm9kZTogcm9vdEhhaHNoLCBsYWJsZTogbmFtZSkpCiAgICB2YXIgYWRkcmVzcyA9IERvbWFpbnMuZ2V0UmVjb3JkcyhuYW1laGFzaCkKICAgIHJldHVybiBhZGRyZXNzCn0\u003d", - "getFlownsDomainsByAddress": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0Rmxvd25zRG9tYWluc0J5QWRkcmVzcyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IERvbWFpbnMgZnJvbSAweGIwNWIyYWJiNDIzMzVlODgKCi8vIGFkZHJlc3M6IEZsb3cgYWRkcmVzcwoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IFtEb21haW5zLkRvbWFpbkRldGFpbF0gewogICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICBsZXQgY29sbGVjdGlvbkNhcCA9IGFjY291bnQuZ2V0Q2FwYWJpbGl0eTwme0RvbWFpbnMuQ29sbGVjdGlvblB1YmxpY30+KERvbWFpbnMuQ29sbGVjdGlvblB1YmxpY1BhdGgpCiAgICBsZXQgY29sbGVjdGlvbiA9IGNvbGxlY3Rpb25DYXAuYm9ycm93KCkhCiAgICBsZXQgZG9tYWluczpbRG9tYWlucy5Eb21haW5EZXRhaWxdID0gW10KICAgIGxldCBpZHMgPSBjb2xsZWN0aW9uLmdldElEcygpCgogICAgZm9yIGlkIGluIGlkcyB7CiAgICAgICAgbGV0IGRvbWFpbiA9IGNvbGxlY3Rpb24uYm9ycm93RG9tYWluKGlkOiBpZCkKICAgICAgICBsZXQgZGV0YWlsID0gZG9tYWluLmdldERldGFpbCgpCiAgICAgICAgZG9tYWlucy5hcHBlbmQoZGV0YWlsKQogICAgfQoKICAgIHJldHVybiBkb21haW5zCn0\u003d", - "getStorageInfo": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0U3RvcmFnZUluZm8gLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCiBhY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyOiBBZGRyZXNzKToge1N0cmluZzogVUludDY0fSB7CiAgICBsZXQgYWNjdCA9IGdldEFjY291bnQoYWRkcikKICAgIGxldCByZXQ6IHtTdHJpbmc6IFVJbnQ2NH0gPSB7fQogICAgcmV0WyJjYXBhY2l0eSJdID0gYWNjdC5zdG9yYWdlLmNhcGFjaXR5CiAgICByZXRbInVzZWQiXSA9IGFjY3Quc3RvcmFnZS51c2VkCiAgICBpZiBhY2N0LnN0b3JhZ2UuY2FwYWNpdHkgPiAwIHsKICAgICAgICByZXRbImF2YWlsYWJsZSJdID0gYWNjdC5zdG9yYWdlLmNhcGFjaXR5IC0gIGFjY3Quc3RvcmFnZS51c2VkCiAgICB9IGVsc2UgewogICAgICAgIHJldFsiYXZhaWxhYmxlIl0gPSAwCiAgICB9CiAgICAKICAgIHJldHVybiByZXQKfQ\u003d\u003d", - "getTokenBalanceWithModel": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0VG9rZW5CYWxhbmNlV2l0aE1vZGVsIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKaW1wb3J0IDxUb2tlbj4gZnJvbSA8VG9rZW5BZGRyZXNzPgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IFVGaXg2NCB7CiAgICBsZXQgYWNjb3VudCA9IGdldEFjY291bnQoYWRkcmVzcykKCiAgICBsZXQgdmF1bHRSZWYgPSBhY2NvdW50LmNhcGFiaWxpdGllcy5ib3Jyb3c8JntGdW5naWJsZVRva2VuLkJhbGFuY2V9Pig8VG9rZW5CYWxhbmNlUGF0aD4pCiAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBCYWxhbmNlIGNhcGFiaWxpdHkiKQoKICAgIHJldHVybiB2YXVsdFJlZi5iYWxhbmNlCn0\u003d", - "isKeyHasFullAuth": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgaXNLZXlIYXNGdWxsQXV0aCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MsIHB1YmxpY0tleTogU3RyaW5nKTogQm9vbCB7CiAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgdmFyIGZsYWcgPSBmYWxzZQogIGZ1biBhY2NvdW50Rm4oYWNjb3VudEtleTogQWNjb3VudEtleSk6IEJvb2wgewogICAgbGV0IGtleSA9IFN0cmluZy5lbmNvZGVIZXgoYWNjb3VudEtleS5wdWJsaWNLZXkucHVibGljS2V5KQogICAgaWYgcHVibGljS2V5ID09IGtleSB7CiAgICAgIGZsYWcgPSBhY2NvdW50S2V5LndlaWdodCA+PSBVRml4NjQoMTAwMCkgJiYgIWFjY291bnRLZXkuaXNSZXZva2VkCiAgICB9CiAgICByZXR1cm4gZmFsc2UKICB9CiAgYWNjb3VudC5rZXlzLmZvckVhY2goYWNjb3VudEZuKQoKICByZXR1cm4gZmxhZwp9Cg\u003d\u003d", - "isKeysHasFullAuth": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgaXNLZXlzSGFzRnVsbEF1dGggLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzLCBwdWJsaWNLZXlzOiBbU3RyaW5nXSk6IEJvb2wgewogIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogIHZhciB3ZWlnaHQ6IFVGaXg2NCA9IDAuMAogIGZ1biBhY2NvdW50Rm4oYWNjb3VudEtleTogQWNjb3VudEtleSk6IEJvb2wgewogICAgbGV0IGtleSA9IFN0cmluZy5lbmNvZGVIZXgoYWNjb3VudEtleS5wdWJsaWNLZXkucHVibGljS2V5KQogICAgaWYgcHVibGljS2V5cy5jb250YWlucyhrZXkpICYmICFhY2NvdW50S2V5LmlzUmV2b2tlZCB7CiAgICAgIHdlaWdodCA9IHdlaWdodCArIGFjY291bnRLZXkud2VpZ2h0IAogICAgfQogICAgcmV0dXJuIGZhbHNlCiAgfQogIGFjY291bnQua2V5cy5mb3JFYWNoKGFjY291bnRGbikKCiAgcmV0dXJuIHdlaWdodCA+PSBVRml4NjQoMTAwMCkKfQo\u003d", - "isLockedFlowEnable": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgaXNMb2NrZWRGbG93RW5hYmxlIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTG9ja2VkVG9rZW5zIGZyb20gMHg5NWUwMTlhMTdkMGUyM2Q3CgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IEJvb2wgewogICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICByZXR1cm4gYWNjb3VudC5jYXBhYmlsaXRpZXMuZXhpc3RzKExvY2tlZFRva2Vucy5Mb2NrZWRBY2NvdW50SW5mb1B1YmxpY1BhdGgpCn0\u003d", - "isTokenStorageEnabled": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgaXNUb2tlblN0b3JhZ2VFbmFibGVkIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKaW1wb3J0IDxUb2tlbj4gZnJvbSA8VG9rZW5BZGRyZXNzPgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAKICAgIGxldCByZWNlaXZlciA9IGFjY291bnQuY2FwYWJpbGl0aWVzLmV4aXN0cyg8VG9rZW5SZWNlaXZlclBhdGg+KQogICAgbGV0IGJhbGFuY2UgPSBhY2NvdW50LmNhcGFiaWxpdGllcy5leGlzdHMoPFRva2VuQmFsYW5jZVBhdGg+KQoKICAgIHJldHVybiByZWNlaXZlciAmJiBiYWxhbmNlCn0\u003d", - "queryBalanceForAccounts": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcXVlcnlCYWxhbmNlRm9yQWNjb3VudHMgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBOb25GdW5naWJsZVRva2VuIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcnM6IFtBZGRyZXNzXSk6IHtBZGRyZXNzOiBBbnlTdHJ1Y3R9IHsKCiAgICB2YXIgcmVzdWx0OiB7QWRkcmVzczogQW55U3RydWN0fSA9IHt9CiAgICBmb3IgYWRkciBpbiBhZGRycyB7CiAgICAgICAgbGV0IGFjY291bnRJbmZvID0gZ2V0QWNjb3VudEluZm8oYWRkcmVzczogYWRkcikKICAgICAgICByZXN1bHRbYWRkcl0gPSBhY2NvdW50SW5mbwogICAgfQogICAgcmV0dXJuIHJlc3VsdAp9CgphY2Nlc3MoYWxsKSBmdW4gZ2V0QWNjb3VudEluZm8oYWRkcmVzczogQWRkcmVzcyk6IEFueVN0cnVjdCB7CiAgICBsZXQgYWNjID0gZ2V0QXV0aEFjY291bnQ8YXV0aChTdG9yYWdlKSAmQWNjb3VudD4oYWRkcmVzcykKICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgbGV0IGZvdW5kVHlwZXM6IFtUeXBlXSA9IFtdCiAgICB2YXIgbmZ0Q291bnRzID0gMAoKICAgICBhY2Muc3RvcmFnZS5mb3JFYWNoU3RvcmVkKGZ1biAocGF0aDogU3RvcmFnZVBhdGgsIHR5cGU6IFR5cGUpOiBCb29sIHsKICAgICAgaWYgdHlwZS5pc1N1YnR5cGUob2Y6IFR5cGU8QHtOb25GdW5naWJsZVRva2VuLkNvbGxlY3Rpb259PigpKSAmJiAhdHlwZS5pc1JlY292ZXJlZCB7CiAgICAgICAgICB2YXIgY29sbGVjdGlvbiA9IGFjYy5zdG9yYWdlLmJvcnJvdzwme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0+KGZyb206cGF0aCkhCiAgICAgICAgICBsZXQgaWRzID0gY29sbGVjdGlvbi5nZXRJRHMoKQogICAgICAgICAgICBuZnRDb3VudHMgPSBuZnRDb3VudHMgKyBpZHMubGVuZ3RoCiAgICAgICAgfQogICAgICAgIHJldHVybiB0cnVlCiAgICB9KQoKICAgIHJldHVybiB7CiAgICAgICAgImZsb3dCYWxhbmNlIjogYWNjb3VudC5iYWxhbmNlLAogICAgICAgICJuZnRDb3VudHMiOiBuZnRDb3VudHMKICAgIH0KfQo\u003d", - "queryCustomFT": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcXVlcnlDdXN0b21GVCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IE1ldGFkYXRhVmlld3MgZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCmltcG9ydCBWaWV3UmVzb2x2ZXIgZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCmltcG9ydCBOb25GdW5naWJsZVRva2VuIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgppbXBvcnQgRnVuZ2libGVUb2tlbk1ldGFkYXRhVmlld3MgZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKTWV0YWRhdGFWaWV3cwoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGNvbnRyYWN0QWRkcmVzczogQWRkcmVzcywgY29udHJhY3ROYW1lOiBTdHJpbmcpOiBGdW5naWJsZVRva2VuTWV0YWRhdGFWaWV3cy5GVFZhdWx0RGF0YSB7CiAgICAKICAgIGxldCB2aWV3UmVzb2x2ZXIgPSBnZXRBY2NvdW50KGNvbnRyYWN0QWRkcmVzcykuY29udHJhY3RzLmJvcnJvdzwme1ZpZXdSZXNvbHZlcn0+KG5hbWU6IGNvbnRyYWN0TmFtZSkKICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IFZpZXdSZXNvbHZlciBmcm9tIEZ1bmdpYmxlVG9rZW4gY29udHJhY3QiKQogICAgbGV0IHZhdWx0RGF0YSA9IHZpZXdSZXNvbHZlci5yZXNvbHZlQ29udHJhY3RWaWV3KAogICAgICAgIHJlc291cmNlVHlwZTogbmlsLAogICAgICAgIHZpZXdUeXBlOiBUeXBlPEZ1bmdpYmxlVG9rZW5NZXRhZGF0YVZpZXdzLkZUVmF1bHREYXRhPigpCiAgICApIGFzISBGdW5naWJsZVRva2VuTWV0YWRhdGFWaWV3cy5GVFZhdWx0RGF0YT8gPz8gcGFuaWMoIkNvdWxkIG5vdCByZXNvbHZlIEZUVmF1bHREYXRhIHZpZXciKQoKICAgIHJldHVybiB2YXVsdERhdGEKfQ\u003d\u003d", - "queryCustomNFT": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcXVlcnlDdXN0b21ORlQgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgppbXBvcnQgVmlld1Jlc29sdmVyIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4NjMxZTg4YWU3ZjFkN2MyMAoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGNvbnRyYWN0QWRkcmVzczogQWRkcmVzcywgY29udHJhY3ROYW1lOiBTdHJpbmcpOiBNZXRhZGF0YVZpZXdzLk5GVENvbGxlY3Rpb25EYXRhIHsKCiAgICBsZXQgdmlld1Jlc29sdmVyID0gZ2V0QWNjb3VudChjb250cmFjdEFkZHJlc3MpLmNvbnRyYWN0cy5ib3Jyb3c8JntWaWV3UmVzb2x2ZXJ9PihuYW1lOiBjb250cmFjdE5hbWUpCiAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgVmlld1Jlc29sdmVyIGZyb20gTkZUIGNvbnRyYWN0IikKICAgIGxldCBjb2xsZWN0aW9uRGF0YSA9IHZpZXdSZXNvbHZlci5yZXNvbHZlQ29udHJhY3RWaWV3KAogICAgICAgICAgICByZXNvdXJjZVR5cGU6IG5pbCwKICAgICAgICAgICAgdmlld1R5cGU6IFR5cGU8TWV0YWRhdGFWaWV3cy5ORlRDb2xsZWN0aW9uRGF0YT4oKQogICAgICAgICkgYXMhIE1ldGFkYXRhVmlld3MuTkZUQ29sbGVjdGlvbkRhdGE/ID8/IHBhbmljKCJDb3VsZCBub3QgcmVzb2x2ZSBORlRDb2xsZWN0aW9uRGF0YSB2aWV3IikKICAgIAogICAgcmV0dXJuIGNvbGxlY3Rpb25EYXRhCn0\u003d", - "queryFlowBalance": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcXVlcnlGbG93QmFsYW5jZSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDdlNjBkZjA0MmE5YzA4NjgKCgphY2Nlc3MoYWxsKSBmdW4gY2hlY2tGbG93VG9rZW5CYWxhbmNlKGFkZHJlc3M6IEFkZHJlc3MpIDogVUZpeDY0IHsKICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgbGV0IHZhdWx0UmVmID0gYWNjb3VudC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5CYWxhbmNlfT4oL3B1YmxpYy9mbG93VG9rZW5CYWxhbmNlKQogICAgPz8gbmlsCgogICAgCiAgICBpZiB2YXVsdFJlZiAhPSBuaWwgewogICAgICAgIHJldHVybiB2YXVsdFJlZiEuYmFsYW5jZQogICAgfQogICAgCiAgICByZXR1cm4gMC4wCn0KCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJzOiBbQWRkcmVzc10pOiBbVUZpeDY0XSB7CiAgICBsZXQgYmFsczogW1VGaXg2NF0gPSBbXQoKICAgIGZvciBhZGRyIGluIGFkZHJzIHsKICAgICAgICBsZXQgYmFsID0gY2hlY2tGbG93VG9rZW5CYWxhbmNlKGFkZHJlc3M6IGFkZHIpCiAgICAgICAgYmFscy5hcHBlbmQoYmFsKQogICAgfQogICAgCiAgICByZXR1cm4gYmFscwp9", - "removeAccountKeyByIndex": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcmVtb3ZlQWNjb3VudEtleUJ5SW5kZXggLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCnRyYW5zYWN0aW9uKGtleUluZGV4OiBJbnQpIHsKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKEtleXMpICZBY2NvdW50KSB7CiAgICAgICAgc2lnbmVyLmtleXMucmV2b2tlKGtleUluZGV4OiBrZXlJbmRleCkKICAgIH0KfQ\u003d\u003d", - "removeContractFromAccount": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcmVtb3ZlQ29udHJhY3RGcm9tQWNjb3VudCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKdHJhbnNhY3Rpb24obmFtZTogU3RyaW5nKSB7CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChSZW1vdmVDb250cmFjdCkgJkFjY291bnQpIHsKICAgICAgICBzaWduZXIuY29udHJhY3RzLnJlbW92ZShuYW1lOiBuYW1lKQogICAgfQp9", - "revokeKey": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcmV2b2tlS2V5IC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+Cgp0cmFuc2FjdGlvbihpbmRleDogSW50KSB7CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChLZXlzKSAmQWNjb3VudCkgewogICAgICAgIC8vIEdldCBhIGtleSBmcm9tIGFuIGF1dGggYWNjb3VudC4KICAgICAgICBsZXQga2V5QSA9IHNpZ25lci5rZXlzLnJldm9rZShrZXlJbmRleDogaW5kZXgpCiAgICB9Cn0\u003d", - "test": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdGVzdCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDdlNjBkZjA0MmE5YzA4NjgKCgp0cmFuc2FjdGlvbihhbW91bnQ6IFVGaXg2NCwgcmVjaXBpZW50OiBBZGRyZXNzKSB7CgogICAgLy8gVGhlIFZhdWx0IHJlc291cmNlIHRoYXQgaG9sZHMgdGhlIHRva2VucyB0aGF0IGFyZSBiZWluZyB0cmFuc2ZlcmVkCiAgICBsZXQgc2VudFZhdWx0OiBAe0Z1bmdpYmxlVG9rZW4uVmF1bHR9CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSwgQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgIC8vIEdldCBhIHJlZmVyZW5jZSB0byB0aGUgc2lnbmVyJ3Mgc3RvcmVkIHZhdWx0CiAgICAgICAgbGV0IHZhdWx0UmVmID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJkZsb3dUb2tlbi5WYXVsdD4oZnJvbTogL3N0b3JhZ2UvZmxvd1Rva2VuVmF1bHQpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IHJlZmVyZW5jZSB0byB0aGUgb3duZXIncyBWYXVsdCEiKQoKICAgICAgICAvLyBXaXRoZHJhdyB0b2tlbnMgZnJvbSB0aGUgc2lnbmVyJ3Mgc3RvcmVkIHZhdWx0CiAgICAgICAgc2VsZi5zZW50VmF1bHQgPC0gdmF1bHRSZWYud2l0aGRyYXcoYW1vdW50OiBhbW91bnQpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgLy8gR2V0IHRoZSByZWNpcGllbnQncyBwdWJsaWMgYWNjb3VudCBvYmplY3QKICAgICAgICBsZXQgcmVjaXBpZW50QWNjb3VudCA9IGdldEFjY291bnQocmVjaXBpZW50KQoKICAgICAgICAvLyBHZXQgYSByZWZlcmVuY2UgdG8gdGhlIHJlY2lwaWVudCdzIFJlY2VpdmVyCiAgICAgICAgbGV0IHJlY2VpdmVyUmVmID0gcmVjaXBpZW50QWNjb3VudC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5SZWNlaXZlcn0+KC9wdWJsaWMvZmxvd1Rva2VuUmVjZWl2ZXIpIQogICAgICAgICAgICAKICAgICAgICAvLyBEZXBvc2l0IHRoZSB3aXRoZHJhd24gdG9rZW5zIGluIHRoZSByZWNpcGllbnQncyByZWNlaXZlcgogICAgICAgIHJlY2VpdmVyUmVmLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKICAgIH0KfQ\u003d\u003d", - "updateContractOfAccount": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdXBkYXRlQ29udHJhY3RPZkFjY291bnQgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCnRyYW5zYWN0aW9uKG5hbWU6IFN0cmluZywgY29kZTogU3RyaW5nKSB7CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChVcGRhdGVDb250cmFjdCkgJkFjY291bnQpIHsKICAgICAgICBzaWduZXIuY29udHJhY3RzLnVwZGF0ZShuYW1lOiBuYW1lLCBjb2RlOiBjb2RlLnV0ZjgpCiAgICB9Cn0\u003d", - "verifyUserSignature": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdmVyaWZ5VXNlclNpZ25hdHVyZSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IENyeXB0bwoKYWNjZXNzKGFsbCkgZnVuIG1haW4oCiAgICBtZXNzYWdlOiBTdHJpbmcsCiAgICByYXdQdWJsaWNLZXlzOiBbU3RyaW5nXSwKICAgIHdlaWdodHM6IFtVRml4NjRdLAogICAgc2lnbkFsZ29zOiBbVUludDhdLAogICAgaGFzaEFsZ29zOiBbVUludDhdLAogICAgc2lnbmF0dXJlczogW1N0cmluZ10sCik6IEJvb2wgewoKICAgIGxldCBrZXlMaXN0ID0gQ3J5cHRvLktleUxpc3QoKQoKICAgIHZhciBpID0gMAogICAgZm9yIHJhd1B1YmxpY0tleSBpbiByYXdQdWJsaWNLZXlzIHsKICAgIGtleUxpc3QuYWRkKAogICAgICAgIFB1YmxpY0tleSgKICAgICAgICBwdWJsaWNLZXk6IHJhd1B1YmxpY0tleS5kZWNvZGVIZXgoKSwKICAgICAgICBzaWduYXR1cmVBbGdvcml0aG06IFNpZ25hdHVyZUFsZ29yaXRobShyYXdWYWx1ZTogc2lnbkFsZ29zW2ldKSEKICAgICAgICApLAogICAgICAgIGhhc2hBbGdvcml0aG06IEhhc2hBbGdvcml0aG0ocmF3VmFsdWU6IGhhc2hBbGdvc1tpXSkhLAogICAgICAgIHdlaWdodDogd2VpZ2h0c1tpXSwKICAgICkKICAgIGkgPSBpICsgMQogICAgfQoKICAgIGxldCBzaWduYXR1cmVTZXQ6IFtDcnlwdG8uS2V5TGlzdFNpZ25hdHVyZV0gPSBbXQoKICAgIHZhciBqID0gMAogICAgZm9yIHNpZ25hdHVyZSBpbiBzaWduYXR1cmVzIHsKICAgIHNpZ25hdHVyZVNldC5hcHBlbmQoCiAgICAgICAgQ3J5cHRvLktleUxpc3RTaWduYXR1cmUoCiAgICAgICAgICAgIGtleUluZGV4OiBqLAogICAgICAgICAgICBzaWduYXR1cmU6IHNpZ25hdHVyZS5kZWNvZGVIZXgoKQogICAgICAgICkKICAgICkKICAgICAgICBqID0gaiArIDEKICAgIH0KCiAgICBsZXQgc2lnbmVkRGF0YSA9IG1lc3NhZ2UuZGVjb2RlSGV4KCkKCiAgICByZXR1cm4ga2V5TGlzdC52ZXJpZnkoCiAgICAgICAgc2lnbmF0dXJlU2V0OiBzaWduYXR1cmVTZXQsCiAgICAgICAgc2lnbmVkRGF0YTogc2lnbmVkRGF0YSwKICAgICAgICBkb21haW5TZXBhcmF0aW9uVGFnOiAiRkxPVy1WMC4wLXVzZXIiCiAgICApCn0\u003d", - "withdrawAllUnlockedFlow": "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\u003d\u003d", - "withdrawUnlockedFlow": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgd2l0aGRyYXdVbmxvY2tlZEZsb3cgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCi8vIGltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgovLyBpbXBvcnQgRmxvd1Rva2VuIGZyb20gMHg3ZTYwZGYwNDJhOWMwODY4CgovLyBpbXBvcnQgTG9ja2VkVG9rZW5zIGZyb20gMHg5NWUwMTlhMTdkMGUyM2Q3CgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDdlNjBkZjA0MmE5YzA4NjgKCmltcG9ydCBMb2NrZWRUb2tlbnMgZnJvbSAweDk1ZTAxOWExN2QwZTIzZDcKCgp0cmFuc2FjdGlvbihhbW91bnQ6IFVGaXg2NCkgewoKICAgIGxldCBob2xkZXJSZWY6IGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgICZMb2NrZWRUb2tlbnMuVG9rZW5Ib2xkZXIKICAgIGxldCB2YXVsdFJlZjogJkZsb3dUb2tlbi5WYXVsdAoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgIHNlbGYuaG9sZGVyUmVmID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJkxvY2tlZFRva2Vucy5Ub2tlbkhvbGRlcj4oZnJvbTogTG9ja2VkVG9rZW5zLlRva2VuSG9sZGVyU3RvcmFnZVBhdGgpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IGEgcmVmZXJlbmNlIHRvIFRva2VuSG9sZGVyIikKCiAgICAgICAgc2VsZi52YXVsdFJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzwmRmxvd1Rva2VuLlZhdWx0Pihmcm9tOiAvc3RvcmFnZS9mbG93VG9rZW5WYXVsdCkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgZmxvdyB0b2tlbiB2YXVsdCByZWYiKQogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIHNlbGYudmF1bHRSZWYuZGVwb3NpdChmcm9tOiA8LXNlbGYuaG9sZGVyUmVmLndpdGhkcmF3KGFtb3VudDogYW1vdW50KSkKICAgIH0KfQ\u003d\u003d" + "accountStorage": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYWNjb3VudFN0b3JhZ2UgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCiBhY2Nlc3MoYWxsKSBzdHJ1Y3QgU3RvcmFnZUluZm8gewogICAgYWNjZXNzKGFsbCkgIGxldCBjYXBhY2l0eTogVUludDY0CiAgICBhY2Nlc3MoYWxsKSAgbGV0IHVzZWQ6IFVJbnQ2NAogICAgYWNjZXNzKGFsbCkgIGxldCBhdmFpbGFibGU6IFVJbnQ2NAoKICAgIGluaXQoY2FwYWNpdHk6IFVJbnQ2NCwgdXNlZDogVUludDY0LCBhdmFpbGFibGU6IFVJbnQ2NCkgewogICAgICAgIHNlbGYuY2FwYWNpdHkgPSBjYXBhY2l0eQogICAgICAgIHNlbGYudXNlZCA9IHVzZWQKICAgICAgICBzZWxmLmF2YWlsYWJsZSA9IGF2YWlsYWJsZQogICAgfQp9CgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyOiBBZGRyZXNzKTogU3RvcmFnZUluZm8gewogICAgbGV0IGFjY3QgPSBnZXRBY2NvdW50KGFkZHIpCiAgICB2YXIgYXZhaWxhYmxlOiBVSW50NjQgPSAwCiAgICBpZiBhY2N0LnN0b3JhZ2UuY2FwYWNpdHkgPiAwIHsKICAgICAgICBhdmFpbGFibGUgPSBhY2N0LnN0b3JhZ2UuY2FwYWNpdHkgLSBhY2N0LnN0b3JhZ2UudXNlZAogICAgfQogICAgcmV0dXJuIFN0b3JhZ2VJbmZvKGNhcGFjaXR5OiBhY2N0LnN0b3JhZ2UuY2FwYWNpdHksCiAgICAgICAgICAgIHVzZWQ6IGFjY3Quc3RvcmFnZS51c2VkLAogICAgICAgICAgICBhdmFpbGFibGU6IGF2YWlsYWJsZSkKfQ\u003d\u003d", + "addContractToAccount": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYWRkQ29udHJhY3RUb0FjY291bnQgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCnRyYW5zYWN0aW9uKG5hbWU6IFN0cmluZywgY29kZTogU3RyaW5nKSB7CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChDb250cmFjdHMsIEFkZENvbnRyYWN0KSAmQWNjb3VudCkgewogICAgICAgIHNpZ25lci5jb250cmFjdHMuYWRkKG5hbWU6IG5hbWUsIGNvZGU6IGNvZGUudXRmOCkKICAgIH0KfQ\u003d\u003d", + "addKey": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYWRkS2V5IC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgQ3J5cHRvCgp0cmFuc2FjdGlvbihwdWJsaWNLZXk6IFN0cmluZywgc2lnbmF0dXJlQWxnb3JpdGhtOiBVSW50OCwgaGFzaEFsZ29yaXRobTogVUludDgsIHdlaWdodDogVUZpeDY0KSB7CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChLZXlzKSAmQWNjb3VudCkgewogICAgICAgIGxldCBrZXkgPSBQdWJsaWNLZXkoCiAgICAgICAgICAgIHB1YmxpY0tleTogcHVibGljS2V5LmRlY29kZUhleCgpLAogICAgICAgICAgICBzaWduYXR1cmVBbGdvcml0aG06IFNpZ25hdHVyZUFsZ29yaXRobShyYXdWYWx1ZTogc2lnbmF0dXJlQWxnb3JpdGhtKSEKICAgICAgICApCgogICAgICAgIHNpZ25lci5rZXlzLmFkZCgKICAgICAgICAgICAgcHVibGljS2V5OiBrZXksCiAgICAgICAgICAgIGhhc2hBbGdvcml0aG06IEhhc2hBbGdvcml0aG0ocmF3VmFsdWU6IGhhc2hBbGdvcml0aG0pISwKICAgICAgICAgICAgd2VpZ2h0OiB3ZWlnaHQKICAgICAgICApCiAgICB9Cn0\u003d", + "addKeyTemp": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYWRkS2V5VGVtcCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IENyeXB0bwoKdHJhbnNhY3Rpb24ocHVibGljS2V5czogW0NyeXB0by5LZXlMaXN0RW50cnldLCBjb250cmFjdHM6IHtTdHJpbmc6IFN0cmluZ30pIHsKCXByZXBhcmUoc2lnbmVyOiBhdXRoKEJvcnJvd1ZhbHVlIHwgU3RvcmFnZSkgJkFjY291bnQpIHsKCgkJbGV0IGFjY291bnQgPSBBY2NvdW50KHBheWVyOiBzaWduZXIpCgoJCS8vIGFkZCBhbGwgdGhlIGtleXMgdG8gdGhlIGFjY291bnQKCQlmb3Iga2V5IGluIHB1YmxpY0tleXMgewoJCQlhY2NvdW50LmtleXMuYWRkKHB1YmxpY0tleToga2V5LnB1YmxpY0tleSwgaGFzaEFsZ29yaXRobToga2V5Lmhhc2hBbGdvcml0aG0sIHdlaWdodDoga2V5LndlaWdodCkKCQl9CgkJCgkJLy8gYWRkIGNvbnRyYWN0cyBpZiBwcm92aWRlZAoJCWZvciBjb250cmFjdCBpbiBjb250cmFjdHMua2V5cyB7CgkJCWFjY291bnQuY29udHJhY3RzLmFkZChuYW1lOiBjb250cmFjdCwgY29kZTogY29udHJhY3RzW2NvbnRyYWN0XSEuZGVjb2RlSGV4KCkpCgkJfQoJfQp9", + "checkResource": "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", + "createAccount": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY3JlYXRlQWNjb3VudCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IENyeXB0bwppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHg3ZTYwZGYwNDJhOWMwODY4CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKCiB0cmFuc2FjdGlvbihwdWJsaWNLZXlzOiBbQ3J5cHRvLktleUxpc3RFbnRyeV0sIGNvbnRyYWN0czoge1N0cmluZzogU3RyaW5nfSwgZnVuZEFtb3VudDogVUZpeDY0KSB7CiAgICBsZXQgdG9rZW5SZWNlaXZlcjogJntGdW5naWJsZVRva2VuLlJlY2VpdmVyfQogICAgbGV0IHNlbnRWYXVsdDogQEZ1bmdpYmxlVG9rZW4uVmF1bHQKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChCb3Jyb3dWYWx1ZSB8IFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IGFjY291bnQgPSBBY2NvdW50KHBheWVyOiBzaWduZXIpCiAgICAgICAgZm9yIGtleSBpbiBwdWJsaWNLZXlzIHsKICAgICAgICAgICAgYWNjb3VudC5rZXlzLmFkZChwdWJsaWNLZXk6IGtleS5wdWJsaWNLZXksIGhhc2hBbGdvcml0aG06IGtleS5oYXNoQWxnb3JpdGhtLCB3ZWlnaHQ6IGtleS53ZWlnaHQpCiAgICAgICAgfQogICAgICAgIGZvciBjb250cmFjdCBpbiBjb250cmFjdHMua2V5cyB7CiAgICAgICAgICAgIGFjY291bnQuY29udHJhY3RzLmFkZChuYW1lOiBjb250cmFjdCwgY29kZTogY29udHJhY3RzW2NvbnRyYWN0XSEuZGVjb2RlSGV4KCkpCiAgICAgICAgfQogICAgICAgIHNlbGYudG9rZW5SZWNlaXZlciA9IGFjY291bnQuY2FwYWJpbGl0aWVzLmJvcnJvdzwme0Z1bmdpYmxlVG9rZW4uUmVjZWl2ZXJ9PigvcHVibGljL2Zsb3dUb2tlblJlY2VpdmVyKSA/PyBwYW5pYygiVW5hYmxlIHRvIGJvcnJvdyByZWNlaXZlciByZWZlcmVuY2UiKQogICAgICAgIGxldCB2YXVsdFJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZGbG93VG9rZW4uVmF1bHQ+KGZyb206IC9zdG9yYWdlL2Zsb3dUb2tlblZhdWx0KSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIG93bmVyJydzIFZhdWx0ISIpCiAgICAgICAgc2VsZi5zZW50VmF1bHQgPC0gdmF1bHRSZWYud2l0aGRyYXcoYW1vdW50OiBmdW5kQW1vdW50KQogICAgfQogICAgZXhlY3V0ZSB7CiAgICAgICAgc2VsZi50b2tlblJlY2VpdmVyLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKICAgIH0KIH0\u003d", + "createAccountSdk": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY3JlYXRlQWNjb3VudFNkayAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IENyeXB0bwoKdHJhbnNhY3Rpb24ocHVibGljS2V5OiBTdHJpbmcsIHNpZ25hdHVyZUFsZ29yaXRobTogVUludDgsIGhhc2hBbGdvcml0aG06IFVJbnQ4LCB3ZWlnaHQ6IFVGaXg2NCwgY29udHJhY3RzOiB7U3RyaW5nOiBTdHJpbmd9KSB7CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChCb3Jyb3dWYWx1ZSB8IFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IGFjY291bnQgPSBBY2NvdW50KHBheWVyOiBzaWduZXIpCgogICAgICAgIGxldCBrZXkgPSBQdWJsaWNLZXkoCiAgICAgICAgICAgIHB1YmxpY0tleTogcHVibGljS2V5LmRlY29kZUhleCgpLAogICAgICAgICAgICBzaWduYXR1cmVBbGdvcml0aG06IFNpZ25hdHVyZUFsZ29yaXRobShyYXdWYWx1ZTogc2lnbmF0dXJlQWxnb3JpdGhtKSEKICAgICAgICApCgogICAgICAgIGFjY291bnQua2V5cy5hZGQoCiAgICAgICAgICAgIHB1YmxpY0tleToga2V5LAogICAgICAgICAgICBoYXNoQWxnb3JpdGhtOiBIYXNoQWxnb3JpdGhtKHJhd1ZhbHVlOiBoYXNoQWxnb3JpdGhtKSEsCiAgICAgICAgICAgIHdlaWdodDogd2VpZ2h0CiAgICAgICAgKQoKICAgICAgICBmb3IgY29udHJhY3QgaW4gY29udHJhY3RzLmtleXMgewogICAgICAgICAgICBhY2NvdW50LmNvbnRyYWN0cy5hZGQobmFtZTogY29udHJhY3QsIGNvZGU6IGNvbnRyYWN0c1tjb250cmFjdF0hLmRlY29kZUhleCgpKQogICAgICAgIH0KICAgIH0KfQ\u003d\u003d", + "getAccountInfo": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QWNjb3VudEluZm8gLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmFjY2VzcyhhbGwpIHN0cnVjdCBSZXN1bHQgewogIGFjY2VzcyhhbGwpIGxldCBhZGRyZXNzOiBBZGRyZXNzCiAgYWNjZXNzKGFsbCkgbGV0IGJhbGFuY2U6IFVGaXg2NAogIGFjY2VzcyhhbGwpIGxldCBhdmFpbGFibGVCYWxhbmNlOiBVRml4NjQKICBhY2Nlc3MoYWxsKSBsZXQgc3RvcmFnZVVzZWQ6IFVJbnQ2NAogIGFjY2VzcyhhbGwpIGxldCBzdG9yYWdlQ2FwYWNpdHk6IFVJbnQ2NAogIGFjY2VzcyhhbGwpIGxldCBzdG9yYWdlRmxvdzogVUZpeDY0CgogIGluaXQoCiAgICBhZGRyZXNzOiBBZGRyZXNzLAogICAgYmFsYW5jZTogVUZpeDY0LAogICAgYXZhaWxhYmxlQmFsYW5jZTogVUZpeDY0LAogICAgc3RvcmFnZVVzZWQ6IFVJbnQ2NCwKICAgIHN0b3JhZ2VDYXBhY2l0eTogVUludDY0LAogICAgc3RvcmFnZUZsb3c6IFVGaXg2NCwKICApIHsKICAgIHNlbGYuYWRkcmVzcyA9IGFkZHJlc3MKICAgIHNlbGYuYmFsYW5jZSA9IGJhbGFuY2UKICAgIHNlbGYuYXZhaWxhYmxlQmFsYW5jZSA9IGF2YWlsYWJsZUJhbGFuY2UKICAgIHNlbGYuc3RvcmFnZVVzZWQgPSBzdG9yYWdlVXNlZAogICAgc2VsZi5zdG9yYWdlQ2FwYWNpdHkgPSBzdG9yYWdlQ2FwYWNpdHkKICAgIHNlbGYuc3RvcmFnZUZsb3cgPSBzdG9yYWdlRmxvdwogIH0KfQoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IFJlc3VsdCB7CiAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgcmV0dXJuIFJlc3VsdCgKICAgIGFkZHJlc3M6IGFjY291bnQuYWRkcmVzcywKICAgIGJhbGFuY2U6IGFjY291bnQuYmFsYW5jZSwKICAgIGF2YWlsYWJsZUJhbGFuY2U6IGFjY291bnQuYXZhaWxhYmxlQmFsYW5jZSwKICAgIHN0b3JhZ2VVc2VkOiBhY2NvdW50LnN0b3JhZ2UudXNlZCwKICAgIHN0b3JhZ2VDYXBhY2l0eTogYWNjb3VudC5zdG9yYWdlLmNhcGFjaXR5LAogICAgc3RvcmFnZUZsb3c6IGFjY291bnQuYmFsYW5jZSAtIGFjY291bnQuYXZhaWxhYmxlQmFsYW5jZQogICkKfQ\u003d\u003d", + "getAccountMinFlow": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QWNjb3VudE1pbkZsb3cgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBVRml4NjQgewogIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogIHJldHVybiBhY2NvdW50LmJhbGFuY2UgLSBhY2NvdW50LmF2YWlsYWJsZUJhbGFuY2UKfQ\u003d\u003d", + "getAccountTotalFlowBalance": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QWNjb3VudFRvdGFsRmxvd0JhbGFuY2UgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHg3ZTYwZGYwNDJhOWMwODY4CgppbXBvcnQgTG9ja2VkVG9rZW5zIGZyb20gMHg5NWUwMTlhMTdkMGUyM2Q3CgovLyBpbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKLy8gaW1wb3J0IEZsb3dUb2tlbiBmcm9tIDB4N2U2MGRmMDQyYTljMDg2OAoKLy8gaW1wb3J0IExvY2tlZFRva2VucyBmcm9tIDB4OTVlMDE5YTE3ZDBlMjNkNwoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBVRml4NjQgewogICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICBsZXQgdW5sb2NrZWRWYXVsdCA9IGFjY291bnQKICAgICAgLmNhcGFiaWxpdGllcy5nZXQ8JntGdW5naWJsZVRva2VuLkJhbGFuY2V9PigvcHVibGljL2Zsb3dUb2tlbkJhbGFuY2UpIQogICAgICAuYm9ycm93KCkKICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBCYWxhbmNlIHJlZmVyZW5jZSB0byB0aGUgVmF1bHQiKQogICAgbGV0IHVubG9ja2VkQmFsYW5jZSA9IHVubG9ja2VkVmF1bHQuYmFsYW5jZQogICAgICAgIAogICAgbGV0IGxvY2tlZEFjY291bnRJbmZvQ2FwID0gYWNjb3VudAogICAgICAuY2FwYWJpbGl0aWVzLmdldAogICAgICA8JkxvY2tlZFRva2Vucy5Ub2tlbkhvbGRlcj4KICAgICAgKExvY2tlZFRva2Vucy5Mb2NrZWRBY2NvdW50SW5mb1B1YmxpY1BhdGgpCiAgICBpZiBsb2NrZWRBY2NvdW50SW5mb0NhcCA9PSBuaWwgfHwgIShsb2NrZWRBY2NvdW50SW5mb0NhcCEuY2hlY2soKSkgewogICAgICAgIHJldHVybiB1bmxvY2tlZEJhbGFuY2UKICAgIH0KICAgIAogICAgbGV0IGxvY2tlZEFjY291bnRJbmZvUmVmID0gbG9ja2VkQWNjb3VudEluZm9DYXAhLmJvcnJvdygpIQogICAgbGV0IGxvY2tlZEJhbGFuY2UgPSBsb2NrZWRBY2NvdW50SW5mb1JlZi5nZXRMb2NrZWRBY2NvdW50QmFsYW5jZSgpCiAgICAKICAgIHJldHVybiBsb2NrZWRCYWxhbmNlICsgdW5sb2NrZWRCYWxhbmNlCn0\u003d", + "getAccountTotalLockedFlowBalance": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QWNjb3VudFRvdGFsTG9ja2VkRmxvd0JhbGFuY2UgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHg3ZTYwZGYwNDJhOWMwODY4CgppbXBvcnQgTG9ja2VkVG9rZW5zIGZyb20gMHg5NWUwMTlhMTdkMGUyM2Q3CgoKLy8gaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCi8vIGltcG9ydCBGbG93VG9rZW4gZnJvbSAweDdlNjBkZjA0MmE5YzA4NjgKCi8vIGltcG9ydCBMb2NrZWRUb2tlbnMgZnJvbSAweDk1ZTAxOWExN2QwZTIzZDcKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzKTogVUZpeDY0IHsKICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQoKICAgIGxldCBsb2NrZWRBY2NvdW50SW5mb0NhcCA9IGFjY291bnQKICAgICAgLmNhcGFiaWxpdGllcy5nZXQKICAgICAgPCZMb2NrZWRUb2tlbnMuVG9rZW5Ib2xkZXI+CiAgICAgIChMb2NrZWRUb2tlbnMuTG9ja2VkQWNjb3VudEluZm9QdWJsaWNQYXRoKQogICAgaWYgbG9ja2VkQWNjb3VudEluZm9DYXAgPT0gbmlsIHx8ICEobG9ja2VkQWNjb3VudEluZm9DYXAhLmNoZWNrKCkpIHsKICAgICAgICByZXR1cm4gVUZpeDY0KDApCiAgICB9CiAgICAKICAgIGxldCBsb2NrZWRBY2NvdW50SW5mb1JlZiA9IGxvY2tlZEFjY291bnRJbmZvQ2FwIS5ib3Jyb3coKSEKICAgIGxldCBsb2NrZWRCYWxhbmNlID0gbG9ja2VkQWNjb3VudEluZm9SZWYuZ2V0TG9ja2VkQWNjb3VudEJhbGFuY2UoKQogICAgCiAgICByZXR1cm4gbG9ja2VkQmFsYW5jZQp9", + "getAccountTotalUnlockedFlowBalance": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QWNjb3VudFRvdGFsVW5sb2NrZWRGbG93QmFsYW5jZSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKLy8gaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCi8vIGltcG9ydCBGbG93VG9rZW4gZnJvbSAweDdlNjBkZjA0MmE5YzA4NjgKCi8vIGltcG9ydCBMb2NrZWRUb2tlbnMgZnJvbSAweDk1ZTAxOWExN2QwZTIzZDcKCgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKaW1wb3J0IEZsb3dUb2tlbiBmcm9tIDB4N2U2MGRmMDQyYTljMDg2OAoKaW1wb3J0IExvY2tlZFRva2VucyBmcm9tIDB4OTVlMDE5YTE3ZDBlMjNkNwoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBVRml4NjQgewogICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCgogICAgbGV0IHVubG9ja2VkVmF1bHQgPSBhY2NvdW50CiAgICAgIC5jYXBhYmlsaXRpZXMuZ2V0PCZGbG93VG9rZW4uVmF1bHQ+KC9wdWJsaWMvZmxvd1Rva2VuQmFsYW5jZSkhCiAgICAgIC5ib3Jyb3coKQogICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IEJhbGFuY2UgcmVmZXJlbmNlIHRvIHRoZSBWYXVsdCIpCiAgICBsZXQgdW5sb2NrZWRCYWxhbmNlID0gdW5sb2NrZWRWYXVsdC5iYWxhbmNlCgogICAgbGV0IGxvY2tlZEFjY291bnRJbmZvQ2FwID0gYWNjb3VudAogICAgICAuY2FwYWJpbGl0aWVzLmdldAogICAgICA8JkxvY2tlZFRva2Vucy5Ub2tlbkhvbGRlcj4KICAgICAgKExvY2tlZFRva2Vucy5Mb2NrZWRBY2NvdW50SW5mb1B1YmxpY1BhdGgpCiAgICBpZiBsb2NrZWRBY2NvdW50SW5mb0NhcCA9PSBuaWwgfHwgIShsb2NrZWRBY2NvdW50SW5mb0NhcCEuY2hlY2soKSkgewogICAgICAgIHJldHVybiB1bmxvY2tlZEJhbGFuY2UKICAgIH0KICAgIAogICAgbGV0IGxvY2tlZEFjY291bnRJbmZvUmVmID0gbG9ja2VkQWNjb3VudEluZm9DYXAhLmJvcnJvdygpIQogICAgbGV0IGxvY2tlZEJhbGFuY2UgPSBsb2NrZWRBY2NvdW50SW5mb1JlZi5nZXRMb2NrZWRBY2NvdW50QmFsYW5jZSgpCiAgICBsZXQgbG9ja2VkQmFsYW5jZVVubG9ja2VkID0gbG9ja2VkQWNjb3VudEluZm9SZWYuZ2V0VW5sb2NrTGltaXQoKQoKICAgIGlmIGxvY2tlZEJhbGFuY2UgPT0gVUZpeDY0KDApIHsKICAgICAgICByZXR1cm4gdW5sb2NrZWRCYWxhbmNlCiAgICB9CgogICAgaWYgbG9ja2VkQmFsYW5jZVVubG9ja2VkID4gbG9ja2VkQmFsYW5jZSB7CiAgICAgICAgcmV0dXJuIHVubG9ja2VkQmFsYW5jZSArIGxvY2tlZEJhbGFuY2UKICAgIH0KCiAgICByZXR1cm4gbG9ja2VkQmFsYW5jZVVubG9ja2VkICsgdW5sb2NrZWRCYWxhbmNlCn0\u003d", + "getAccountsDetail": "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", + "getFindAddress": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0RmluZEFkZHJlc3MgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGSU5EIGZyb20gMHhhMTZhYjFkMGFiZGUzNjI1CgovL0NoZWNrIHRoZSBzdGF0dXMgb2YgYSBmaW4gdXNlcgphY2Nlc3MoYWxsKSBmdW4gbWFpbihuYW1lOiBTdHJpbmcpIDogQWRkcmVzcz8gewogICAgbGV0IHN0YXR1cyA9IEZJTkQuc3RhdHVzKG5hbWUpCiAgICByZXR1cm4gc3RhdHVzLm93bmVyCn0\u003d", + "getFindDomainByAddress": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0RmluZERvbWFpbkJ5QWRkcmVzcyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZJTkQgZnJvbSAweGExNmFiMWQwYWJkZTM2MjUKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzKSA6IFN0cmluZz97CiAgICByZXR1cm4gRklORC5yZXZlcnNlTG9va3VwKGFkZHJlc3MpCn0\u003d", + "getFlowBalanceForAnyAccounts": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0Rmxvd0JhbGFuY2VGb3JBbnlBY2NvdW50cyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKCi8vIEdldCB0aGUgYWNjb3VudCBiYWxhbmNlIGZvciBhIENPQSBhY2NvdW50CmFjY2VzcyhhbGwpIGZ1biBnZXRFVk1CYWxhbmNlKF8gYWRkcmVzczogU3RyaW5nKTogVUZpeDY0PyB7CiAgICByZXR1cm4gRVZNLmFkZHJlc3NGcm9tU3RyaW5nKGFkZHJlc3MpLmJhbGFuY2UoKS5pbkZMT1coKQp9CgovLyBHZXQgdGhlIGF2YWlsYWJsZSBhY2NvdW50IGJhbGFuY2UgZm9yIGEgRmxvdyBhY2NvdW50CmFjY2VzcyhhbGwpIGZ1biBnZXRGbG93QmFsYW5jZShfIGFkZHJlc3M6IFN0cmluZyk6IFVGaXg2ND8gewogICAgaWYgbGV0IGFjY291bnQgPSBBZGRyZXNzLmZyb21TdHJpbmcoYWRkcmVzcykgewogICAgICAgIC8vIFVzZSBhdmFpbGFibGUgYmFsYW5jZSBpbnN0ZWFkIG9mIHRvdGFsIGJhbGFuY2UKICAgICAgICByZXR1cm4gZ2V0QWNjb3VudChhY2NvdW50KS5hdmFpbGFibGVCYWxhbmNlCiAgICB9CiAgICByZXR1cm4gbmlsCn0KCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3NlczogW1N0cmluZ10pOiB7U3RyaW5nOiBVRml4NjQ/fSB7CiAgICBsZXQgcmVzOiB7U3RyaW5nOiBVRml4NjQ/fSA9IHt9CgogICAgZm9yIGFkZHIgaW4gYWRkcmVzc2VzIHsKICAgICAgICBsZXQgaGV4ID0gYWRkclsxXSA9PSAieCIgPyBhZGRyIDogIjB4Ii5jb25jYXQoYWRkcikKICAgICAgICBpZiBsZXQgZmxvd0JhbGFuY2UgPSBnZXRGbG93QmFsYW5jZShoZXgpIHsKICAgICAgICAgICAgcmVzW2hleF0gPSBmbG93QmFsYW5jZQogICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgIGlmIGxldCBldm1CYWxhbmNlID0gZ2V0RVZNQmFsYW5jZShoZXgpIHsKICAgICAgICAgICAgICAgIHJlc1toZXhdID0gZXZtQmFsYW5jZQogICAgICAgICAgICB9CiAgICAgICAgfQogICAgfQogICAgcmV0dXJuIHJlcwp9", + "getFlownsAddress": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0Rmxvd25zQWRkcmVzcyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3ducyBmcm9tIDB4YjA1YjJhYmI0MjMzNWU4OAoKaW1wb3J0IERvbWFpbnMgZnJvbSAweGIwNWIyYWJiNDIzMzVlODgKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihuYW1lOiBTdHJpbmcsIHJvb3Q6IFN0cmluZykgOiBBZGRyZXNzPyB7CiAgICBsZXQgcHJlZml4ID0gIjB4IgogICAgbGV0IHJvb3RIYWhzaCA9IEZsb3ducy5oYXNoKG5vZGU6ICIiLCBsYWJsZTogcm9vdCkKICAgIGxldCBuYW1laGFzaCA9IHByZWZpeC5jb25jYXQoRmxvd25zLmhhc2gobm9kZTogcm9vdEhhaHNoLCBsYWJsZTogbmFtZSkpCiAgICB2YXIgYWRkcmVzcyA9IERvbWFpbnMuZ2V0UmVjb3JkcyhuYW1laGFzaCkKICAgIHJldHVybiBhZGRyZXNzCn0\u003d", + "getFlownsDomainsByAddress": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0Rmxvd25zRG9tYWluc0J5QWRkcmVzcyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IERvbWFpbnMgZnJvbSAweGIwNWIyYWJiNDIzMzVlODgKCi8vIGFkZHJlc3M6IEZsb3cgYWRkcmVzcwoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IFtEb21haW5zLkRvbWFpbkRldGFpbF0gewogICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICBsZXQgY29sbGVjdGlvbkNhcCA9IGFjY291bnQuZ2V0Q2FwYWJpbGl0eTwme0RvbWFpbnMuQ29sbGVjdGlvblB1YmxpY30+KERvbWFpbnMuQ29sbGVjdGlvblB1YmxpY1BhdGgpCiAgICBsZXQgY29sbGVjdGlvbiA9IGNvbGxlY3Rpb25DYXAuYm9ycm93KCkhCiAgICBsZXQgZG9tYWluczpbRG9tYWlucy5Eb21haW5EZXRhaWxdID0gW10KICAgIGxldCBpZHMgPSBjb2xsZWN0aW9uLmdldElEcygpCgogICAgZm9yIGlkIGluIGlkcyB7CiAgICAgICAgbGV0IGRvbWFpbiA9IGNvbGxlY3Rpb24uYm9ycm93RG9tYWluKGlkOiBpZCkKICAgICAgICBsZXQgZGV0YWlsID0gZG9tYWluLmdldERldGFpbCgpCiAgICAgICAgZG9tYWlucy5hcHBlbmQoZGV0YWlsKQogICAgfQoKICAgIHJldHVybiBkb21haW5zCn0\u003d", + "getStorageInfo": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0U3RvcmFnZUluZm8gLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCiBhY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyOiBBZGRyZXNzKToge1N0cmluZzogVUludDY0fSB7CiAgICBsZXQgYWNjdCA9IGdldEFjY291bnQoYWRkcikKICAgIGxldCByZXQ6IHtTdHJpbmc6IFVJbnQ2NH0gPSB7fQogICAgcmV0WyJjYXBhY2l0eSJdID0gYWNjdC5zdG9yYWdlLmNhcGFjaXR5CiAgICByZXRbInVzZWQiXSA9IGFjY3Quc3RvcmFnZS51c2VkCiAgICBpZiBhY2N0LnN0b3JhZ2UuY2FwYWNpdHkgPiAwIHsKICAgICAgICByZXRbImF2YWlsYWJsZSJdID0gYWNjdC5zdG9yYWdlLmNhcGFjaXR5IC0gIGFjY3Quc3RvcmFnZS51c2VkCiAgICB9IGVsc2UgewogICAgICAgIHJldFsiYXZhaWxhYmxlIl0gPSAwCiAgICB9CiAgICAKICAgIHJldHVybiByZXQKfQ\u003d\u003d", + "getTokenBalanceWithModel": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0VG9rZW5CYWxhbmNlV2l0aE1vZGVsIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKaW1wb3J0IDxUb2tlbj4gZnJvbSA8VG9rZW5BZGRyZXNzPgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IFVGaXg2NCB7CiAgICBsZXQgYWNjb3VudCA9IGdldEFjY291bnQoYWRkcmVzcykKCiAgICBsZXQgdmF1bHRSZWYgPSBhY2NvdW50LmNhcGFiaWxpdGllcy5ib3Jyb3c8JntGdW5naWJsZVRva2VuLkJhbGFuY2V9Pig8VG9rZW5CYWxhbmNlUGF0aD4pCiAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBCYWxhbmNlIGNhcGFiaWxpdHkiKQoKICAgIHJldHVybiB2YXVsdFJlZi5iYWxhbmNlCn0\u003d", + "isKeyHasFullAuth": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgaXNLZXlIYXNGdWxsQXV0aCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MsIHB1YmxpY0tleTogU3RyaW5nKTogQm9vbCB7CiAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgdmFyIGZsYWcgPSBmYWxzZQogIGZ1biBhY2NvdW50Rm4oYWNjb3VudEtleTogQWNjb3VudEtleSk6IEJvb2wgewogICAgbGV0IGtleSA9IFN0cmluZy5lbmNvZGVIZXgoYWNjb3VudEtleS5wdWJsaWNLZXkucHVibGljS2V5KQogICAgaWYgcHVibGljS2V5ID09IGtleSB7CiAgICAgIGZsYWcgPSBhY2NvdW50S2V5LndlaWdodCA+PSBVRml4NjQoMTAwMCkgJiYgIWFjY291bnRLZXkuaXNSZXZva2VkCiAgICB9CiAgICByZXR1cm4gZmFsc2UKICB9CiAgYWNjb3VudC5rZXlzLmZvckVhY2goYWNjb3VudEZuKQoKICByZXR1cm4gZmxhZwp9Cg\u003d\u003d", + "isKeysHasFullAuth": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgaXNLZXlzSGFzRnVsbEF1dGggLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzLCBwdWJsaWNLZXlzOiBbU3RyaW5nXSk6IEJvb2wgewogIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogIHZhciB3ZWlnaHQ6IFVGaXg2NCA9IDAuMAogIGZ1biBhY2NvdW50Rm4oYWNjb3VudEtleTogQWNjb3VudEtleSk6IEJvb2wgewogICAgbGV0IGtleSA9IFN0cmluZy5lbmNvZGVIZXgoYWNjb3VudEtleS5wdWJsaWNLZXkucHVibGljS2V5KQogICAgaWYgcHVibGljS2V5cy5jb250YWlucyhrZXkpICYmICFhY2NvdW50S2V5LmlzUmV2b2tlZCB7CiAgICAgIHdlaWdodCA9IHdlaWdodCArIGFjY291bnRLZXkud2VpZ2h0IAogICAgfQogICAgcmV0dXJuIGZhbHNlCiAgfQogIGFjY291bnQua2V5cy5mb3JFYWNoKGFjY291bnRGbikKCiAgcmV0dXJuIHdlaWdodCA+PSBVRml4NjQoMTAwMCkKfQo\u003d", + "isLockedFlowEnable": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgaXNMb2NrZWRGbG93RW5hYmxlIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTG9ja2VkVG9rZW5zIGZyb20gMHg5NWUwMTlhMTdkMGUyM2Q3CgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IEJvb2wgewogICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICByZXR1cm4gYWNjb3VudC5jYXBhYmlsaXRpZXMuZXhpc3RzKExvY2tlZFRva2Vucy5Mb2NrZWRBY2NvdW50SW5mb1B1YmxpY1BhdGgpCn0\u003d", + "isTokenStorageEnabled": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgaXNUb2tlblN0b3JhZ2VFbmFibGVkIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKaW1wb3J0IDxUb2tlbj4gZnJvbSA8VG9rZW5BZGRyZXNzPgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAKICAgIGxldCByZWNlaXZlciA9IGFjY291bnQuY2FwYWJpbGl0aWVzLmV4aXN0cyg8VG9rZW5SZWNlaXZlclBhdGg+KQogICAgbGV0IGJhbGFuY2UgPSBhY2NvdW50LmNhcGFiaWxpdGllcy5leGlzdHMoPFRva2VuQmFsYW5jZVBhdGg+KQoKICAgIHJldHVybiByZWNlaXZlciAmJiBiYWxhbmNlCn0\u003d", + "queryBalanceForAccounts": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcXVlcnlCYWxhbmNlRm9yQWNjb3VudHMgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBOb25GdW5naWJsZVRva2VuIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcnM6IFtBZGRyZXNzXSk6IHtBZGRyZXNzOiBBbnlTdHJ1Y3R9IHsKCiAgICB2YXIgcmVzdWx0OiB7QWRkcmVzczogQW55U3RydWN0fSA9IHt9CiAgICBmb3IgYWRkciBpbiBhZGRycyB7CiAgICAgICAgbGV0IGFjY291bnRJbmZvID0gZ2V0QWNjb3VudEluZm8oYWRkcmVzczogYWRkcikKICAgICAgICByZXN1bHRbYWRkcl0gPSBhY2NvdW50SW5mbwogICAgfQogICAgcmV0dXJuIHJlc3VsdAp9CgphY2Nlc3MoYWxsKSBmdW4gZ2V0QWNjb3VudEluZm8oYWRkcmVzczogQWRkcmVzcyk6IEFueVN0cnVjdCB7CiAgICBsZXQgYWNjID0gZ2V0QXV0aEFjY291bnQ8YXV0aChTdG9yYWdlKSAmQWNjb3VudD4oYWRkcmVzcykKICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgbGV0IGZvdW5kVHlwZXM6IFtUeXBlXSA9IFtdCiAgICB2YXIgbmZ0Q291bnRzID0gMAoKICAgICBhY2Muc3RvcmFnZS5mb3JFYWNoU3RvcmVkKGZ1biAocGF0aDogU3RvcmFnZVBhdGgsIHR5cGU6IFR5cGUpOiBCb29sIHsKICAgICAgaWYgdHlwZS5pc1N1YnR5cGUob2Y6IFR5cGU8QHtOb25GdW5naWJsZVRva2VuLkNvbGxlY3Rpb259PigpKSAmJiAhdHlwZS5pc1JlY292ZXJlZCB7CiAgICAgICAgICB2YXIgY29sbGVjdGlvbiA9IGFjYy5zdG9yYWdlLmJvcnJvdzwme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0+KGZyb206cGF0aCkhCiAgICAgICAgICBsZXQgaWRzID0gY29sbGVjdGlvbi5nZXRJRHMoKQogICAgICAgICAgICBuZnRDb3VudHMgPSBuZnRDb3VudHMgKyBpZHMubGVuZ3RoCiAgICAgICAgfQogICAgICAgIHJldHVybiB0cnVlCiAgICB9KQoKICAgIHJldHVybiB7CiAgICAgICAgImZsb3dCYWxhbmNlIjogYWNjb3VudC5iYWxhbmNlLAogICAgICAgICJuZnRDb3VudHMiOiBuZnRDb3VudHMKICAgIH0KfQo\u003d", + "queryCustomFT": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcXVlcnlDdXN0b21GVCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IE1ldGFkYXRhVmlld3MgZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCmltcG9ydCBWaWV3UmVzb2x2ZXIgZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCmltcG9ydCBOb25GdW5naWJsZVRva2VuIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgppbXBvcnQgRnVuZ2libGVUb2tlbk1ldGFkYXRhVmlld3MgZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKTWV0YWRhdGFWaWV3cwoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGNvbnRyYWN0QWRkcmVzczogQWRkcmVzcywgY29udHJhY3ROYW1lOiBTdHJpbmcpOiBGdW5naWJsZVRva2VuTWV0YWRhdGFWaWV3cy5GVFZhdWx0RGF0YSB7CiAgICAKICAgIGxldCB2aWV3UmVzb2x2ZXIgPSBnZXRBY2NvdW50KGNvbnRyYWN0QWRkcmVzcykuY29udHJhY3RzLmJvcnJvdzwme1ZpZXdSZXNvbHZlcn0+KG5hbWU6IGNvbnRyYWN0TmFtZSkKICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IFZpZXdSZXNvbHZlciBmcm9tIEZ1bmdpYmxlVG9rZW4gY29udHJhY3QiKQogICAgbGV0IHZhdWx0RGF0YSA9IHZpZXdSZXNvbHZlci5yZXNvbHZlQ29udHJhY3RWaWV3KAogICAgICAgIHJlc291cmNlVHlwZTogbmlsLAogICAgICAgIHZpZXdUeXBlOiBUeXBlPEZ1bmdpYmxlVG9rZW5NZXRhZGF0YVZpZXdzLkZUVmF1bHREYXRhPigpCiAgICApIGFzISBGdW5naWJsZVRva2VuTWV0YWRhdGFWaWV3cy5GVFZhdWx0RGF0YT8gPz8gcGFuaWMoIkNvdWxkIG5vdCByZXNvbHZlIEZUVmF1bHREYXRhIHZpZXciKQoKICAgIHJldHVybiB2YXVsdERhdGEKfQ\u003d\u003d", + "queryCustomNFT": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcXVlcnlDdXN0b21ORlQgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgppbXBvcnQgVmlld1Jlc29sdmVyIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4NjMxZTg4YWU3ZjFkN2MyMAoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGNvbnRyYWN0QWRkcmVzczogQWRkcmVzcywgY29udHJhY3ROYW1lOiBTdHJpbmcpOiBNZXRhZGF0YVZpZXdzLk5GVENvbGxlY3Rpb25EYXRhIHsKCiAgICBsZXQgdmlld1Jlc29sdmVyID0gZ2V0QWNjb3VudChjb250cmFjdEFkZHJlc3MpLmNvbnRyYWN0cy5ib3Jyb3c8JntWaWV3UmVzb2x2ZXJ9PihuYW1lOiBjb250cmFjdE5hbWUpCiAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgVmlld1Jlc29sdmVyIGZyb20gTkZUIGNvbnRyYWN0IikKICAgIGxldCBjb2xsZWN0aW9uRGF0YSA9IHZpZXdSZXNvbHZlci5yZXNvbHZlQ29udHJhY3RWaWV3KAogICAgICAgICAgICByZXNvdXJjZVR5cGU6IG5pbCwKICAgICAgICAgICAgdmlld1R5cGU6IFR5cGU8TWV0YWRhdGFWaWV3cy5ORlRDb2xsZWN0aW9uRGF0YT4oKQogICAgICAgICkgYXMhIE1ldGFkYXRhVmlld3MuTkZUQ29sbGVjdGlvbkRhdGE/ID8/IHBhbmljKCJDb3VsZCBub3QgcmVzb2x2ZSBORlRDb2xsZWN0aW9uRGF0YSB2aWV3IikKICAgIAogICAgcmV0dXJuIGNvbGxlY3Rpb25EYXRhCn0\u003d", + "queryFlowBalance": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcXVlcnlGbG93QmFsYW5jZSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDdlNjBkZjA0MmE5YzA4NjgKCgphY2Nlc3MoYWxsKSBmdW4gY2hlY2tGbG93VG9rZW5CYWxhbmNlKGFkZHJlc3M6IEFkZHJlc3MpIDogVUZpeDY0IHsKICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgbGV0IHZhdWx0UmVmID0gYWNjb3VudC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5CYWxhbmNlfT4oL3B1YmxpYy9mbG93VG9rZW5CYWxhbmNlKQogICAgPz8gbmlsCgogICAgCiAgICBpZiB2YXVsdFJlZiAhPSBuaWwgewogICAgICAgIHJldHVybiB2YXVsdFJlZiEuYmFsYW5jZQogICAgfQogICAgCiAgICByZXR1cm4gMC4wCn0KCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJzOiBbQWRkcmVzc10pOiBbVUZpeDY0XSB7CiAgICBsZXQgYmFsczogW1VGaXg2NF0gPSBbXQoKICAgIGZvciBhZGRyIGluIGFkZHJzIHsKICAgICAgICBsZXQgYmFsID0gY2hlY2tGbG93VG9rZW5CYWxhbmNlKGFkZHJlc3M6IGFkZHIpCiAgICAgICAgYmFscy5hcHBlbmQoYmFsKQogICAgfQogICAgCiAgICByZXR1cm4gYmFscwp9", + "removeAccountKeyByIndex": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcmVtb3ZlQWNjb3VudEtleUJ5SW5kZXggLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCnRyYW5zYWN0aW9uKGtleUluZGV4OiBJbnQpIHsKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKEtleXMpICZBY2NvdW50KSB7CiAgICAgICAgc2lnbmVyLmtleXMucmV2b2tlKGtleUluZGV4OiBrZXlJbmRleCkKICAgIH0KfQ\u003d\u003d", + "removeContractFromAccount": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcmVtb3ZlQ29udHJhY3RGcm9tQWNjb3VudCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKdHJhbnNhY3Rpb24obmFtZTogU3RyaW5nKSB7CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChSZW1vdmVDb250cmFjdCkgJkFjY291bnQpIHsKICAgICAgICBzaWduZXIuY29udHJhY3RzLnJlbW92ZShuYW1lOiBuYW1lKQogICAgfQp9", + "revokeKey": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcmV2b2tlS2V5IC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+Cgp0cmFuc2FjdGlvbihpbmRleDogSW50KSB7CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChLZXlzKSAmQWNjb3VudCkgewogICAgICAgIC8vIEdldCBhIGtleSBmcm9tIGFuIGF1dGggYWNjb3VudC4KICAgICAgICBsZXQga2V5QSA9IHNpZ25lci5rZXlzLnJldm9rZShrZXlJbmRleDogaW5kZXgpCiAgICB9Cn0\u003d", + "test": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdGVzdCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDdlNjBkZjA0MmE5YzA4NjgKCgp0cmFuc2FjdGlvbihhbW91bnQ6IFVGaXg2NCwgcmVjaXBpZW50OiBBZGRyZXNzKSB7CgogICAgLy8gVGhlIFZhdWx0IHJlc291cmNlIHRoYXQgaG9sZHMgdGhlIHRva2VucyB0aGF0IGFyZSBiZWluZyB0cmFuc2ZlcmVkCiAgICBsZXQgc2VudFZhdWx0OiBAe0Z1bmdpYmxlVG9rZW4uVmF1bHR9CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSwgQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgIC8vIEdldCBhIHJlZmVyZW5jZSB0byB0aGUgc2lnbmVyJ3Mgc3RvcmVkIHZhdWx0CiAgICAgICAgbGV0IHZhdWx0UmVmID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJkZsb3dUb2tlbi5WYXVsdD4oZnJvbTogL3N0b3JhZ2UvZmxvd1Rva2VuVmF1bHQpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IHJlZmVyZW5jZSB0byB0aGUgb3duZXIncyBWYXVsdCEiKQoKICAgICAgICAvLyBXaXRoZHJhdyB0b2tlbnMgZnJvbSB0aGUgc2lnbmVyJ3Mgc3RvcmVkIHZhdWx0CiAgICAgICAgc2VsZi5zZW50VmF1bHQgPC0gdmF1bHRSZWYud2l0aGRyYXcoYW1vdW50OiBhbW91bnQpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgLy8gR2V0IHRoZSByZWNpcGllbnQncyBwdWJsaWMgYWNjb3VudCBvYmplY3QKICAgICAgICBsZXQgcmVjaXBpZW50QWNjb3VudCA9IGdldEFjY291bnQocmVjaXBpZW50KQoKICAgICAgICAvLyBHZXQgYSByZWZlcmVuY2UgdG8gdGhlIHJlY2lwaWVudCdzIFJlY2VpdmVyCiAgICAgICAgbGV0IHJlY2VpdmVyUmVmID0gcmVjaXBpZW50QWNjb3VudC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5SZWNlaXZlcn0+KC9wdWJsaWMvZmxvd1Rva2VuUmVjZWl2ZXIpIQogICAgICAgICAgICAKICAgICAgICAvLyBEZXBvc2l0IHRoZSB3aXRoZHJhd24gdG9rZW5zIGluIHRoZSByZWNpcGllbnQncyByZWNlaXZlcgogICAgICAgIHJlY2VpdmVyUmVmLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKICAgIH0KfQ\u003d\u003d", + "updateContractOfAccount": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdXBkYXRlQ29udHJhY3RPZkFjY291bnQgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCnRyYW5zYWN0aW9uKG5hbWU6IFN0cmluZywgY29kZTogU3RyaW5nKSB7CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChVcGRhdGVDb250cmFjdCkgJkFjY291bnQpIHsKICAgICAgICBzaWduZXIuY29udHJhY3RzLnVwZGF0ZShuYW1lOiBuYW1lLCBjb2RlOiBjb2RlLnV0ZjgpCiAgICB9Cn0\u003d", + "verifyUserSignature": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdmVyaWZ5VXNlclNpZ25hdHVyZSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IENyeXB0bwoKYWNjZXNzKGFsbCkgZnVuIG1haW4oCiAgICBtZXNzYWdlOiBTdHJpbmcsCiAgICByYXdQdWJsaWNLZXlzOiBbU3RyaW5nXSwKICAgIHdlaWdodHM6IFtVRml4NjRdLAogICAgc2lnbkFsZ29zOiBbVUludDhdLAogICAgaGFzaEFsZ29zOiBbVUludDhdLAogICAgc2lnbmF0dXJlczogW1N0cmluZ10sCik6IEJvb2wgewoKICAgIGxldCBrZXlMaXN0ID0gQ3J5cHRvLktleUxpc3QoKQoKICAgIHZhciBpID0gMAogICAgZm9yIHJhd1B1YmxpY0tleSBpbiByYXdQdWJsaWNLZXlzIHsKICAgIGtleUxpc3QuYWRkKAogICAgICAgIFB1YmxpY0tleSgKICAgICAgICBwdWJsaWNLZXk6IHJhd1B1YmxpY0tleS5kZWNvZGVIZXgoKSwKICAgICAgICBzaWduYXR1cmVBbGdvcml0aG06IFNpZ25hdHVyZUFsZ29yaXRobShyYXdWYWx1ZTogc2lnbkFsZ29zW2ldKSEKICAgICAgICApLAogICAgICAgIGhhc2hBbGdvcml0aG06IEhhc2hBbGdvcml0aG0ocmF3VmFsdWU6IGhhc2hBbGdvc1tpXSkhLAogICAgICAgIHdlaWdodDogd2VpZ2h0c1tpXSwKICAgICkKICAgIGkgPSBpICsgMQogICAgfQoKICAgIGxldCBzaWduYXR1cmVTZXQ6IFtDcnlwdG8uS2V5TGlzdFNpZ25hdHVyZV0gPSBbXQoKICAgIHZhciBqID0gMAogICAgZm9yIHNpZ25hdHVyZSBpbiBzaWduYXR1cmVzIHsKICAgIHNpZ25hdHVyZVNldC5hcHBlbmQoCiAgICAgICAgQ3J5cHRvLktleUxpc3RTaWduYXR1cmUoCiAgICAgICAgICAgIGtleUluZGV4OiBqLAogICAgICAgICAgICBzaWduYXR1cmU6IHNpZ25hdHVyZS5kZWNvZGVIZXgoKQogICAgICAgICkKICAgICkKICAgICAgICBqID0gaiArIDEKICAgIH0KCiAgICBsZXQgc2lnbmVkRGF0YSA9IG1lc3NhZ2UuZGVjb2RlSGV4KCkKCiAgICByZXR1cm4ga2V5TGlzdC52ZXJpZnkoCiAgICAgICAgc2lnbmF0dXJlU2V0OiBzaWduYXR1cmVTZXQsCiAgICAgICAgc2lnbmVkRGF0YTogc2lnbmVkRGF0YSwKICAgICAgICBkb21haW5TZXBhcmF0aW9uVGFnOiAiRkxPVy1WMC4wLXVzZXIiCiAgICApCn0\u003d", + "withdrawAllUnlockedFlow": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgd2l0aGRyYXdBbGxVbmxvY2tlZEZsb3cgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHg3ZTYwZGYwNDJhOWMwODY4CgppbXBvcnQgTG9ja2VkVG9rZW5zIGZyb20gMHg5NWUwMTlhMTdkMGUyM2Q3CgovLyBpbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKLy8gaW1wb3J0IEZsb3dUb2tlbiBmcm9tIDB4N2U2MGRmMDQyYTljMDg2OAoKLy8gaW1wb3J0IExvY2tlZFRva2VucyBmcm9tIDB4OTVlMDE5YTE3ZDBlMjNkNwoKCnRyYW5zYWN0aW9uKCkgewoKICAgIGxldCBob2xkZXJSZWY6IGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJkxvY2tlZFRva2Vucy5Ub2tlbkhvbGRlcgogICAgbGV0IHZhdWx0UmVmOiAmRmxvd1Rva2VuLlZhdWx0CiAgICBsZXQgYW1vdW50OiBVRml4NjQKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChCb3Jyb3dWYWx1ZSkgJkFjY291bnQpIHsKICAgICAgICAgc2VsZi5ob2xkZXJSZWYgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAmTG9ja2VkVG9rZW5zLlRva2VuSG9sZGVyPihmcm9tOiBMb2NrZWRUb2tlbnMuVG9rZW5Ib2xkZXJTdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgYSByZWZlcmVuY2UgdG8gVG9rZW5Ib2xkZXIiKQoKCQkJCXNlbGYudmF1bHRSZWYgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8JkZsb3dUb2tlbi5WYXVsdD4oZnJvbTogL3N0b3JhZ2UvZmxvd1Rva2VuVmF1bHQpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IGZsb3cgdG9rZW4gdmF1bHQgcmVmIikKCiAgICAgICAgbGV0IGxvY2tlZEFjY291bnRJbmZvQ2FwID0gc2lnbmVyCiAgICAgICAgLmNhcGFiaWxpdGllcy5nZXQ8JkxvY2tlZFRva2Vucy5Ub2tlbkhvbGRlcj4KICAgICAgICAoTG9ja2VkVG9rZW5zLkxvY2tlZEFjY291bnRJbmZvUHVibGljUGF0aCkKCiAgICAgICAgaWYgbG9ja2VkQWNjb3VudEluZm9DYXAgPT0gbmlsIHx8ICEobG9ja2VkQWNjb3VudEluZm9DYXAhLmNoZWNrKCkpIHsKICAgICAgICAgICAgcGFuaWMoIkNvdWxkIG5vdCBnZXQgZmxvdyBsb2NrZWQgdG9rZW4gdmF1bHQiKQogICAgICAgIH0KCiAgICAgICAgbGV0IGxvY2tlZEFjY291bnRJbmZvUmVmID0gbG9ja2VkQWNjb3VudEluZm9DYXAhLmJvcnJvdygpIQogICAgICAgIGxldCBsb2NrZWRCYWxhbmNlID0gbG9ja2VkQWNjb3VudEluZm9SZWYuZ2V0TG9ja2VkQWNjb3VudEJhbGFuY2UoKQogICAgICAgIGxldCBsb2NrZWRCYWxhbmNlVW5sb2NrZWQgPSBsb2NrZWRBY2NvdW50SW5mb1JlZi5nZXRVbmxvY2tMaW1pdCgpCgogICAgICAgIC8vIGlmIGxvY2tlZEJhbGFuY2UgPT0gVUZpeDY0KDApIHsKICAgICAgICAvLyAgICAgcGFuaWMoIk5vdCBlbm91Z2ggYW1vdW50IHRvIHdpdGhkcmF3IikKICAgICAgICAvLyB9CgogICAgICAgIHNlbGYuYW1vdW50ID0gbG9ja2VkQmFsYW5jZVVubG9ja2VkCiAgICAKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBzZWxmLnZhdWx0UmVmLmRlcG9zaXQoZnJvbTogPC1zZWxmLmhvbGRlclJlZi53aXRoZHJhdyhhbW91bnQ6IHNlbGYuYW1vdW50KSkKICAgIH0KfQ\u003d\u003d", + "withdrawUnlockedFlow": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgd2l0aGRyYXdVbmxvY2tlZEZsb3cgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCi8vIGltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgovLyBpbXBvcnQgRmxvd1Rva2VuIGZyb20gMHg3ZTYwZGYwNDJhOWMwODY4CgovLyBpbXBvcnQgTG9ja2VkVG9rZW5zIGZyb20gMHg5NWUwMTlhMTdkMGUyM2Q3CgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDdlNjBkZjA0MmE5YzA4NjgKCmltcG9ydCBMb2NrZWRUb2tlbnMgZnJvbSAweDk1ZTAxOWExN2QwZTIzZDcKCgp0cmFuc2FjdGlvbihhbW91bnQ6IFVGaXg2NCkgewoKICAgIGxldCBob2xkZXJSZWY6IGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgICZMb2NrZWRUb2tlbnMuVG9rZW5Ib2xkZXIKICAgIGxldCB2YXVsdFJlZjogJkZsb3dUb2tlbi5WYXVsdAoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgIHNlbGYuaG9sZGVyUmVmID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJkxvY2tlZFRva2Vucy5Ub2tlbkhvbGRlcj4oZnJvbTogTG9ja2VkVG9rZW5zLlRva2VuSG9sZGVyU3RvcmFnZVBhdGgpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IGEgcmVmZXJlbmNlIHRvIFRva2VuSG9sZGVyIikKCiAgICAgICAgc2VsZi52YXVsdFJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzwmRmxvd1Rva2VuLlZhdWx0Pihmcm9tOiAvc3RvcmFnZS9mbG93VG9rZW5WYXVsdCkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgZmxvdyB0b2tlbiB2YXVsdCByZWYiKQogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIHNlbGYudmF1bHRSZWYuZGVwb3NpdChmcm9tOiA8LXNlbGYuaG9sZGVyUmVmLndpdGhkcmF3KGFtb3VudDogYW1vdW50KSkKICAgIH0KfQ\u003d\u003d" }, "bridge": { - "batchBridgeNFTFromEvm": "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", - "batchBridgeNFTFromEvmV2": "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\u003d\u003d", - "batchBridgeNFTFromEvmWithPayer": "// Flow Wallet - testnet Script  batchBridgeNFTFromEvmWithPayer - v2.72
// <platform_info>

import MetadataViews from 0x631e88ae7f1d7c20

import ViewResolver from 0x631e88ae7f1d7c20

import NonFungibleToken from 0x631e88ae7f1d7c20

import FungibleToken from 0x9a0766d93b6608b7

import FlowToken from 0x7e60df042a9c0868

import FungibleTokenMetadataViews from 0x9a0766d93b6608b7

import ScopedFTProviders from 0xdfc20aee650fcbdf

import EVM from 0x8c5303eaa26202d6

import FlowEVMBridgeUtils from 0xdfc20aee650fcbdf

import FlowEVMBridge from 0xdfc20aee650fcbdf

import FlowEVMBridgeConfig from 0xdfc20aee650fcbdf

import CrossVMMetadataViews from 0x631e88ae7f1d7c20


/// This transaction bridges an NFT from EVM to Cadence assuming it has already been onboarded to the FlowEVMBridge
/// NOTE: The ERC721 must have first been onboarded to the bridge. This can be checked via the method
///     FlowEVMBridge.evmAddressRequiresOnboarding(address: self.evmContractAddress)
///
/// @param nftIdentifier: The Cadence type identifier of the NFT to bridge - e.g. nft.getType().identifier
/// @param id: The ERC721 id of the NFT to bridge to Cadence from EVM
///
transaction(nftIdentifier: String, ids: [UInt256]) {

    let nftType: Type
    let collection: &{NonFungibleToken.Collection}
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let coa: auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount
    let viewResolver: &{ViewResolver}

    prepare(signer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account, payer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        /* --- Construct the NFT type --- */
        //
        // Construct the NFT type from the provided identifier
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        // Parse the NFT identifier into its components
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: self.nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Reference the signer's NFT Collection --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: self.nftType,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        if signer.storage.borrow<&{NonFungibleToken.Collection}>(from: collectionData.storagePath) == nil {
            signer.storage.save(<-collectionData.createEmptyCollection(), to: collectionData.storagePath)
            signer.capabilities.unpublish(collectionData.publicPath)
            let collectionCap = signer.capabilities.storage.issue<&{NonFungibleToken.Collection}>(collectionData.storagePath)
            signer.capabilities.publish(collectionCap, at: collectionData.publicPath)
        }
        self.collection = signer.storage.borrow<&{NonFungibleToken.Collection}>(from: collectionData.storagePath)
            ?? panic("Could not borrow collection from storage path")

        /* --- Configure a ScopedFTProvider --- */
        //
        // Calculate the bridge fee - bridging from EVM consumes no storage, so flat fee
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000) + (FlowEVMBridgeConfig.baseFee * UFix64(ids.length))
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if payer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = payer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            payer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = payer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
            provider: providerCapCopy,
            filters: [ providerFilter ],
            expiration: getCurrentBlock().timestamp + 1.0
        )
    }

    execute {
        // Unwrap NFTs from project-defined ERC721 wrapper contract if applicable
        unwrapNFTsIfApplicable(self.coa, nftIDs: ids, nftType: self.nftType, viewResolver: self.viewResolver)

        // Execute the bridge
        var idx = 0
        while idx < ids.length {
            let nftId = ids[idx]!
            // Execute the bridge
            let nft: @{NonFungibleToken.NFT} <- self.coa.withdrawNFT(
                type: self.nftType,
                id: nftId,
                feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
            // Ensure the bridged nft is the correct type
            assert(
                nft.getType() == self.nftType,
                message: "Bridged nft type mismatch - requested: ".concat(self.nftType.identifier)
                    .concat(", received: ").concat(nft.getType().identifier)
            )
            // Deposit the bridged NFT into the signer's collection
            self.collection.deposit(token: <-nft)
            idx = idx + 1
        }

        // Destroy the ScopedFTProvider
        destroy self.scopedProvider
    }
}

/// Unwraps NFTs from a project's custom ERC721 wrapper contract to bridged NFTs on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
///
access(all) fun unwrapNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt256],
    nftType: Type,
    viewResolver: &{ViewResolver}
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            for id in nftIDs {
                // Unwrap NFT if it is wrapped
                if isNFTWrapped(coa,
                    nftID: id,
                    underlying: underlyingAddress,
                    wrapper: crossVMPointer.evmContractAddress
                ) {
                    let res = mustCall(coa, crossVMPointer.evmContractAddress,
                        functionSig: "withdrawTo(address,uint256[])",
                        args: [coa.address(), [id]]
                    )
                    let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                    assert(decodedRes.length == 1, message: "Invalid response length")
                    assert(decodedRes[0] as! Bool, message: "Failed to unwrap NFT")
                }
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is wrapped in the underlying ERC721 contract
///
access(all) fun isNFTWrapped(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftID: UInt256,
    underlying: EVM.EVMAddress,
    wrapper: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: underlying,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return false
    if res.status != EVM.Status.successful || res.data.length == 0{
        return false
    }

    // Decode and compare the addresses
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    let owner = decodedResult[0] as! EVM.EVMAddress
    return owner.toString() == wrapper.toString()
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", - "batchBridgeNFTToEvm": "// Flow Wallet - testnet Script  batchBridgeNFTToEvm - v2.72
// <platform_info>

import FungibleToken from 0x9a0766d93b6608b7

import FlowToken from 0x7e60df042a9c0868

import MetadataViews from 0x631e88ae7f1d7c20

import ViewResolver from 0x631e88ae7f1d7c20

import NonFungibleToken from 0x631e88ae7f1d7c20

import ScopedFTProviders from 0xdfc20aee650fcbdf

import EVM from 0x8c5303eaa26202d6

import FlowEVMBridgeUtils from 0xdfc20aee650fcbdf

import FlowEVMBridge from 0xdfc20aee650fcbdf

import FlowEVMBridgeConfig from 0xdfc20aee650fcbdf

import CrossVMMetadataViews from 0x631e88ae7f1d7c20


transaction(nftContractAddress: Address, nftContractName: String, ids: [UInt64]) {

    let nfts: @{UInt64 : {NonFungibleToken.NFT}}
    let coa: auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let nftType: Type
    let viewResolver: &{ViewResolver}

    prepare(signer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account) {

        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        self.nfts <- {}
        /* --- Retrieve the NFT --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        
        // Initialize nftType from the contract
        let nftIdentifier = "A.".concat(nftContractAddress.toString().slice(from: 2, upTo: nftContractAddress.toString().length)).concat(".").concat(nftContractName).concat(".NFT")
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
            
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: nil,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        let collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            ) ?? panic("Could not access signer's NFT Collection")

        // Withdraw the requested NFT & calculate the approximate bridge fee based on NFT storage usage
        let currentStorageUsage = signer.storage.used
        for id in ids {
            let nft <- collection.withdraw(withdrawID: id)
            self.nfts[id] <-! nft
        }
        // self.nft <- collection.withdraw(withdrawID: id)
        let withdrawnStorageUsage = signer.storage.used
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(
                bytes: currentStorageUsage - withdrawnStorageUsage
            ) * 1.10 * UFix64(ids.length)

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    execute {
        // Execute the bridge
        var idx = 0
        while idx < ids.length {
            let nftId = ids[idx]!
            let nft <- self.nfts.remove(key: nftId)! as @{NonFungibleToken.NFT}
            self.coa.depositNFT(
                nft: <- nft!,
                feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
            idx = idx + 1
        }

        // Destroy the ScopedFTProvider
        destroy self.scopedProvider
        destroy self.nfts

        // Wrap NFTs if applicable
        wrapAndTransferNFTsIfApplicable(self.coa,
            nftIDs: ids,
            nftType: self.nftType,
            viewResolver: self.viewResolver,
            recipientIfNotCoa: nil
        )
    }
}

/// Wraps and transfers bridged NFTs into a project's custom ERC721 wrapper contract on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
/// @param recipientIfNotCoa: The EVM address to transfer the wrapped NFTs to, nil if the NFTs should stay in signer's COA
///
access(all) fun wrapAndTransferNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt64],
    nftType: Type,
    viewResolver: &{ViewResolver},
    recipientIfNotCoa: EVM.EVMAddress?
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            // Wrap NFTs if underlying ERC721 address matches bridge's associated address for NFT type
            if underlyingAddress.equals(FlowEVMBridgeConfig.getEVMAddressAssociated(with: nftType)!) {
                // Approve contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, true]
                )

                // Wrap NFTs with provided IDs, and check if the call was successful
                let res = mustCall(coa, crossVMPointer.evmContractAddress,
                    functionSig: "depositFor(address,uint256[])",
                    args: [coa.address(), nftIDs]
                )
                let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                assert(decodedRes.length == 1, message: "Invalid response length")
                assert(decodedRes[0] as! Bool, message: "Failed to wrap NFTs")

                // Transfer NFTs to recipient if provided
                if let to = recipientIfNotCoa {
                    mustTransferNFTs(coa, crossVMPointer.evmContractAddress, nftIDs: nftIDs, to: to)
                }

                // Revoke approval for contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, false]
                )
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is owned by the provided EVM address
///
access(all) fun isOwner(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    _ nftID: UInt64,
    _ ownerToCheck: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: erc721Address,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )
    assert(res.status == EVM.Status.successful, message: "Call to ERC721.ownerOf(uint256) failed")
    let decodedRes = EVM.decodeABI(types: [Type<EVM.EVMAddress>()], data: res.data)
    if decodedRes.length == 1 {
        let actualOwner = decodedRes[0] as! EVM.EVMAddress
        return actualOwner.equals(ownerToCheck)
    }
    return false
}

/// Transfers NFTs from the provided COA to the provided EVM address
///
access(all) fun mustTransferNFTs(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    nftIDs: [UInt64],
    to: EVM.EVMAddress
) {
    for id in nftIDs {
        assert(isOwner(coa, erc721Address, id, coa.address()), message: "NFT not owned by signer's COA")
        mustCall(coa, erc721Address,
            functionSig: "safeTransferFrom(address,address,uint256)",
            args: [coa.address(), to, id]
        )
        assert(isOwner(coa, erc721Address, id, to), message: "NFT not transferred to recipient")
    }
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", - "batchBridgeNFTToEvmAddress": "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\u003d", - "batchBridgeNFTToEvmAddressWithPayer": "// Flow Wallet - testnet Script  batchBridgeNFTToEvmAddressWithPayer - v2.72
// <platform_info>

import MetadataViews from 0x631e88ae7f1d7c20

import ViewResolver from 0x631e88ae7f1d7c20

import NonFungibleToken from 0x631e88ae7f1d7c20

import FungibleToken from 0x9a0766d93b6608b7

import FlowToken from 0x7e60df042a9c0868

import FungibleTokenMetadataViews from 0x9a0766d93b6608b7

import ScopedFTProviders from 0xdfc20aee650fcbdf

import EVM from 0x8c5303eaa26202d6

import FlowEVMBridgeUtils from 0xdfc20aee650fcbdf

import FlowEVMBridge from 0xdfc20aee650fcbdf

import FlowEVMBridgeConfig from 0xdfc20aee650fcbdf

import CrossVMMetadataViews from 0x631e88ae7f1d7c20


/// Bridges an NFT from the signer's collection in Cadence to the signer's COA in FlowEVM
///
/// NOTE: This transaction also onboards the NFT to the bridge if necessary which may incur additional fees
///     than bridging an asset that has already been onboarded.
///
/// @param nftIdentifier: The Cadence type identifier of the NFT to bridge - e.g. nft.getType().identifier
/// @param id: The Cadence NFT.id of the NFT to bridge to EVM
///
transaction(nftIdentifier: String, ids: [UInt64], recipient: String) {
    let nft: @{NonFungibleToken.NFT}
    let requiresOnboarding: Bool
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let collection: auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}
    let nftType: Type
    let coa: auth(EVM.Call) &EVM.CadenceOwnedAccount
    let viewResolver: &{ViewResolver}

    prepare(signer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account, payer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account) {
        // Retrieve or create COA
        if let coa = signer.storage.borrow<auth(EVM.Call) &EVM.CadenceOwnedAccount>(from: /storage/evm) {
            self.coa = coa
        } else {
            signer.storage.save<@EVM.CadenceOwnedAccount>(<- EVM.createCadenceOwnedAccount(), to: /storage/evm)
            signer.capabilities.publish(
                signer.capabilities.storage.issue<&EVM.CadenceOwnedAccount>(/storage/evm),
                at: /public/evm
            )
            self.coa = signer.storage.borrow<auth(EVM.Call) &EVM.CadenceOwnedAccount>(from: /storage/evm)!
        }

        /* --- Construct the NFT type --- */
        //
        // Construct the NFT type from the provided identifier
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        // Parse the NFT identifier into its components
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: self.nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Retrieve the NFT --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: nil,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        self.collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            ) ?? panic("Could not access signer's NFT Collection")

        // Withdraw the requested NFT & calculate the approximate bridge fee based on NFT storage usage
        let currentStorageUsage = signer.storage.used
        self.nft <- self.collection.withdraw(withdrawID: ids[0])
        let withdrawnStorageUsage = signer.storage.used
        var approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000) + (FlowEVMBridgeConfig.baseFee * UFix64(ids.length))

        // Determine if the NFT requires onboarding - this impacts the fee required
        self.requiresOnboarding = FlowEVMBridge.typeRequiresOnboarding(self.nft.getType())
            ?? panic("Bridge does not support this asset type")
        if self.requiresOnboarding {
            approxFee = approxFee + FlowEVMBridgeConfig.onboardFee
        }

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if payer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = payer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            payer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = payer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    pre {
        self.nft.getType().identifier == nftIdentifier:
            "Attempting to send invalid nft type - requested: ".concat(nftIdentifier)
            .concat(", sending: ").concat(self.nft.getType().identifier)
    }

    execute {
        if self.requiresOnboarding {
            // Onboard the NFT to the bridge
            FlowEVMBridge.onboardByType(
                self.nft.getType(),
                feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
        }
        // Execute the bridge transaction
        self.coa.depositNFT(
            nft: <- self.nft,
            feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )

        var idx = 0
        for id in ids {
            if idx == 0 {
                idx = idx + 1
                continue
            }

            self.coa.depositNFT(
                nft: <- self.collection.withdraw(withdrawID: id),
                feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
        }

        // Destroy the ScopedFTProvider
        destroy self.scopedProvider

        // Wrap NFTs if applicable
        wrapAndTransferNFTsIfApplicable(self.coa,
            nftIDs: ids,
            nftType: self.nftType,
            viewResolver: self.viewResolver,
            recipientIfNotCoa: EVM.addressFromString(recipient)
        )
    }
}

/// Wraps and transfers bridged NFTs into a project's custom ERC721 wrapper contract on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
/// @param recipientIfNotCoa: The EVM address to transfer the wrapped NFTs to, nil if the NFTs should stay in signer's COA
///
access(all) fun wrapAndTransferNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt64],
    nftType: Type,
    viewResolver: &{ViewResolver},
    recipientIfNotCoa: EVM.EVMAddress?
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            // Wrap NFTs if underlying ERC721 address matches bridge's associated address for NFT type

            if underlyingAddress.equals(FlowEVMBridgeConfig.getEVMAddressAssociated(with: nftType)!) {
                // Approve contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, true]
                )

                // Wrap NFTs with provided IDs, and check if the call was successful
                let res = mustCall(coa, crossVMPointer.evmContractAddress,
                    functionSig: "depositFor(address,uint256[])",
                    args: [coa.address(), nftIDs]
                )
                let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                assert(decodedRes.length == 1, message: "Invalid response length")
                assert(decodedRes[0] as! Bool, message: "Failed to wrap NFTs")

                // Transfer NFTs to recipient if provided
                if let to = recipientIfNotCoa {
                    mustTransferNFTs(coa, crossVMPointer.evmContractAddress, nftIDs: nftIDs, to: to)
                }

                // Revoke approval for contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, false]
                )
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is owned by the provided EVM address
///
access(all) fun isOwner(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    _ nftID: UInt64,
    _ ownerToCheck: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: erc721Address,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )
    assert(res.status == EVM.Status.successful, message: "Call to ERC721.ownerOf(uint256) failed")
    let decodedRes = EVM.decodeABI(types: [Type<EVM.EVMAddress>()], data: res.data)
    if decodedRes.length == 1 {
        let actualOwner = decodedRes[0] as! EVM.EVMAddress
        return actualOwner.equals(ownerToCheck)
    }
    return false
}

/// Transfers NFTs from the provided COA to the provided EVM address
///
access(all) fun mustTransferNFTs(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    nftIDs: [UInt64],
    to: EVM.EVMAddress
) {
    for id in nftIDs {
        assert(isOwner(coa, erc721Address, id, coa.address()), message: "NFT not owned by signer's COA")
        mustCall(coa, erc721Address,
            functionSig: "safeTransferFrom(address,address,uint256)",
            args: [coa.address(), to, id]
        )
        assert(isOwner(coa, erc721Address, id, to), message: "NFT not transferred to recipient")
    }
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", - "batchBridgeNFTToEvmV2": "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\u003d", - "batchBridgeNFTToEvmWithPayer": "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\u003d\u003d", - "batchEvmAddressRequiresOnboarding": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYmF0Y2hFdm1BZGRyZXNzUmVxdWlyZXNPbmJvYXJkaW5nIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRVZNVXRpbHMgZnJvbSAweGRmYzIwYWVlNjUwZmNiZGYKCmltcG9ydCBGbG93RVZNQnJpZGdlIGZyb20gMHhkZmMyMGFlZTY1MGZjYmRmCgoKLy8vIFJldHVybnMgd2hldGhlciBhIEVWTSBjb250cmFjdCBuZWVkcyB0byBiZSBvbmJvYXJkZWQgdG8gdGhlIEZsb3dFVk1CcmlkZ2UKLy8vCi8vLyBAcGFyYW0gZXZtQWRkcmVzc2VzOiBBcnJheSBvZiBoZXgtZW5jb2RlZCBhZGRyZXNzIG9mIHRoZSBFVk0gY29udHJhY3QgYXMgYSBTdHJpbmcgd2l0aG91dCAweCBwcmVmaXggdG8gY2hlY2sgZm9yCi8vLyAgICAgb25ib2FyZGluZyBzdGF0dXMKLy8vCi8vLyBAcmV0dXJuIFdoZXRoZXIgdGhlIGNvbnRyYWN0IHJlcXVpcmVzIG9uYm9hcmRpbmcgdG8gdGhlIEZsb3dFVk1CcmlkZ2UgaWYgdGhlIHR5cGUgaXMgYnJpZGdlYWJsZSwgb3RoZXJ3aXNlIG5pbAovLy8gICAgIGluZGV4ZWQgb24gdGhlIGhleC1lbmNvZGVkIGFkZHJlc3Mgb2YgdGhlIEVWTSBjb250cmFjdCB3aXRob3V0IDB4IHByZWZpeAovLy8KYWNjZXNzKGFsbCkgZnVuIG1haW4oZXZtQWRkcmVzc2VzOiBbU3RyaW5nXSk6IHtTdHJpbmc6IEJvb2w/fSB7CiAgICBsZXQgcmVzdWx0czoge1N0cmluZzogQm9vbD99ID0ge30KICAgIGZvciBhZGRyZXNzSGV4IGluIGV2bUFkZHJlc3NlcyB7CiAgICAgICAgaWYgcmVzdWx0c1thZGRyZXNzSGV4XSAhPSBuaWwgewogICAgICAgICAgICBjb250aW51ZQogICAgICAgIH0KICAgICAgICBpZiBsZXQgYWRkcmVzcyA9IEVWTVV0aWxzLmdldEVWTUFkZHJlc3NGcm9tSGV4U3RyaW5nKGFkZHJlc3M6IGFkZHJlc3NIZXgpIHsKICAgICAgICAgICAgbGV0IHJlcXVpcmVzT25ib2FyZGluZyA9IEZsb3dFVk1CcmlkZ2UuZXZtQWRkcmVzc1JlcXVpcmVzT25ib2FyZGluZyhhZGRyZXNzKQogICAgICAgICAgICByZXN1bHRzLmluc2VydChrZXk6IGFkZHJlc3NIZXgsIHJlcXVpcmVzT25ib2FyZGluZykKICAgICAgICB9CiAgICB9CiAgICByZXR1cm4gcmVzdWx0cwp9Cg\u003d\u003d", - "batchIdentifierRequiresOnboarding": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYmF0Y2hJZGVudGlmaWVyUmVxdWlyZXNPbmJvYXJkaW5nIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd0VWTUJyaWRnZSBmcm9tIDB4ZGZjMjBhZWU2NTBmY2JkZgoKCi8vLyBSZXR1cm5zIHdoZXRoZXIgYSB0eXBlIG5lZWRzIHRvIGJlIG9uYm9hcmRlZCB0byB0aGUgRmxvd0VWTUJyaWRnZQovLy8KLy8vIEBwYXJhbSBUeXBlczogVGhlIGFycmF5IG9mIHR5cGVzIHRvIGNoZWNrIGZvciBvbmJvYXJkaW5nIHN0YXR1cwovLy8KLy8vIEByZXR1cm4gV2hldGhlciB0aGUgdHlwZSByZXF1aXJlcyBvbmJvYXJkaW5nIHRvIHRoZSBGbG93RVZNQnJpZGdlIGlmIHRoZSB0eXBlIGlzIGJyaWRnZWFibGUsIG90aGVyd2lzZSBuaWwgaW5kZXhlZAovLy8gICAgIG9uIHRoZSB0eXBlCi8vLwphY2Nlc3MoYWxsKSBmdW4gbWFpbihpZGVudGlmaWVyczogW1N0cmluZ10pOiB7U3RyaW5nOiBCb29sP30gewogICAgbGV0IHJlc3VsdHM6IHtTdHJpbmc6IEJvb2w/fSA9IHt9CgogICAgZm9yIGlkZW50aWZpZXIgaW4gaWRlbnRpZmllcnMgewogICAgICAgIGlmIHJlc3VsdHNbaWRlbnRpZmllcl0gIT0gbmlsIHsKICAgICAgICAgICAgY29udGludWUKICAgICAgICB9CiAgICAgICAgbGV0IHR5cGU6IFR5cGUgPSBDb21wb3NpdGVUeXBlKGlkZW50aWZpZXIpID8/IHBhbmljKCJJbnZhbGlkIHR5cGUgaWRlbnRpZmllciIpCiAgICAgICAgcmVzdWx0cy5pbnNlcnQoa2V5OiBpZGVudGlmaWVyLCBGbG93RVZNQnJpZGdlLnR5cGVSZXF1aXJlc09uYm9hcmRpbmcodHlwZSkpCiAgICB9CiAgICByZXR1cm4gcmVzdWx0cwp9Cg\u003d\u003d", - "batchOnboardByEvmAddress": "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\u003d", - "batchOnboardByIdentifier": "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\u003d", - "batchOnboardByType": "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\u003d\u003d", - "batchTypeRequiresOnboarding": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYmF0Y2hUeXBlUmVxdWlyZXNPbmJvYXJkaW5nIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd0VWTUJyaWRnZSBmcm9tIDB4ZGZjMjBhZWU2NTBmY2JkZgoKCi8vLyBSZXR1cm5zIHdoZXRoZXIgYSB0eXBlIG5lZWRzIHRvIGJlIG9uYm9hcmRlZCB0byB0aGUgRmxvd0VWTUJyaWRnZQovLy8KLy8vIEBwYXJhbSBUeXBlczogVGhlIGFycmF5IG9mIHR5cGVzIHRvIGNoZWNrIGZvciBvbmJvYXJkaW5nIHN0YXR1cwovLy8KLy8vIEByZXR1cm4gV2hldGhlciB0aGUgdHlwZSByZXF1aXJlcyBvbmJvYXJkaW5nIHRvIHRoZSBGbG93RVZNQnJpZGdlIGlmIHRoZSB0eXBlIGlzIGJyaWRnZWFibGUsIG90aGVyd2lzZSBuaWwgaW5kZXhlZAovLy8gICAgIG9uIHRoZSB0eXBlCi8vLwphY2Nlc3MoYWxsKSBmdW4gbWFpbih0eXBlczogW1R5cGVdKToge1R5cGU6IEJvb2w/fSB7CiAgICBsZXQgcmVzdWx0czoge1R5cGU6IEJvb2w/fSA9IHt9CiAgICBmb3IgdHlwZSBpbiB0eXBlcyB7CiAgICAgICAgaWYgcmVzdWx0c1t0eXBlXSAhPSBuaWwgewogICAgICAgICAgICBjb250aW51ZQogICAgICAgIH0KICAgICAgICByZXN1bHRzLmluc2VydChrZXk6IHR5cGUsIEZsb3dFVk1CcmlkZ2UudHlwZVJlcXVpcmVzT25ib2FyZGluZyh0eXBlKSkKICAgIH0KICAgIHJldHVybiByZXN1bHRzCn0K", - "bridgeNFTFromEvm": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYnJpZGdlTkZURnJvbUV2bSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDdlNjBkZjA0MmE5YzA4NjgKCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgppbXBvcnQgVmlld1Jlc29sdmVyIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4NjMxZTg4YWU3ZjFkN2MyMAoKaW1wb3J0IFNjb3BlZEZUUHJvdmlkZXJzIGZyb20gMHhkZmMyMGFlZTY1MGZjYmRmCgoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKCmltcG9ydCBGbG93RVZNQnJpZGdlVXRpbHMgZnJvbSAweGRmYzIwYWVlNjUwZmNiZGYKCmltcG9ydCBGbG93RVZNQnJpZGdlIGZyb20gMHhkZmMyMGFlZTY1MGZjYmRmCgppbXBvcnQgRmxvd0VWTUJyaWRnZUNvbmZpZyBmcm9tIDB4ZGZjMjBhZWU2NTBmY2JkZgoKCi8vLyBUaGlzIHRyYW5zYWN0aW9uIGJyaWRnZXMgYW4gTkZUIGZyb20gRVZNIHRvIENhZGVuY2UgYXNzdW1pbmcgaXQgaGFzIGFscmVhZHkgYmVlbiBvbmJvYXJkZWQgdG8gdGhlIEZsb3dFVk1CcmlkZ2UKLy8vIE5PVEU6IFRoZSBFUkM3MjEgbXVzdCBoYXZlIGZpcnN0IGJlZW4gb25ib2FyZGVkIHRvIHRoZSBicmlkZ2UuIFRoaXMgY2FuIGJlIGNoZWNrZWQgdmlhIHRoZSBtZXRob2QKLy8vICAgICBGbG93RVZNQnJpZGdlLmV2bUFkZHJlc3NSZXF1aXJlc09uYm9hcmRpbmcoYWRkcmVzczogc2VsZi5ldm1Db250cmFjdEFkZHJlc3MpCi8vLwovLy8gQHBhcmFtIG5mdENvbnRyYWN0QWRkcmVzczogVGhlIEZsb3cgYWNjb3VudCBhZGRyZXNzIGhvc3RpbmcgdGhlIE5GVC1kZWZpbmluZyBDYWRlbmNlIGNvbnRyYWN0Ci8vLyBAcGFyYW0gbmZ0Q29udHJhY3ROYW1lOiBUaGUgbmFtZSBvZiB0aGUgTkZULWRlZmluaW5nIENhZGVuY2UgY29udHJhY3QKLy8vIEBwYXJhbSBpZDogVGhlIEVSQzcyMSBpZCBvZiB0aGUgTkZUIHRvIGJyaWRnZSB0byBDYWRlbmNlIGZyb20gRVZNCi8vLwp0cmFuc2FjdGlvbihuZnRDb250cmFjdEFkZHJlc3M6IEFkZHJlc3MsIG5mdENvbnRyYWN0TmFtZTogU3RyaW5nLCBpZDogVUludDI1NikgewoKICAgIGxldCBuZnRUeXBlOiBUeXBlCiAgICBsZXQgY29sbGVjdGlvbjogJntOb25GdW5naWJsZVRva2VuLkNvbGxlY3Rpb259CiAgICBsZXQgc2NvcGVkUHJvdmlkZXI6IEBTY29wZWRGVFByb3ZpZGVycy5TY29wZWRGVFByb3ZpZGVyCiAgICBsZXQgY29hOiBhdXRoKEVWTS5CcmlkZ2UpICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudAogICAgCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChCb3Jyb3dWYWx1ZSwgQ29weVZhbHVlLCBJc3N1ZVN0b3JhZ2VDYXBhYmlsaXR5Q29udHJvbGxlciwgUHVibGlzaENhcGFiaWxpdHksIFNhdmVWYWx1ZSwgVW5wdWJsaXNoQ2FwYWJpbGl0eSkgJkFjY291bnQpIHsKICAgICAgICAvKiAtLS0gUmVmZXJlbmNlIHRoZSBzaWduZXIncyBDYWRlbmNlT3duZWRBY2NvdW50IC0tLSAqLwogICAgICAgIC8vCiAgICAgICAgLy8gQm9ycm93IGEgcmVmZXJlbmNlIHRvIHRoZSBzaWduZXIncyBDT0EKICAgICAgICBzZWxmLmNvYSA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEVWTS5CcmlkZ2UpICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oZnJvbTogL3N0b3JhZ2UvZXZtKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBDT0EgZnJvbSBwcm92aWRlZCBnYXRld2F5IGFkZHJlc3MiKQoKICAgICAgICAvLyBHZXQgdGhlIEVSQzcyMSBjb250cmFjdCBhZGRyZXNzIGZvciB0aGUgZ2l2ZW4gTkZUIHR5cGUKICAgICAgICBzZWxmLm5mdFR5cGUgPSBGbG93RVZNQnJpZGdlVXRpbHMuYnVpbGRDb21wb3NpdGVUeXBlKAogICAgICAgICAgICAgICAgYWRkcmVzczogbmZ0Q29udHJhY3RBZGRyZXNzLAogICAgICAgICAgICAgICAgY29udHJhY3ROYW1lOiBuZnRDb250cmFjdE5hbWUsCiAgICAgICAgICAgICAgICByZXNvdXJjZU5hbWU6ICJORlQiCiAgICAgICAgICAgICkgPz8gcGFuaWMoIkNvdWxkIG5vdCBjb25zdHJ1Y3QgTkZUIHR5cGUiKQoKICAgICAgICAvKiAtLS0gUmVmZXJlbmNlIHRoZSBzaWduZXIncyBORlQgQ29sbGVjdGlvbiAtLS0gKi8KICAgICAgICAvLwogICAgICAgIC8vIEJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgTkZUIGNvbGxlY3Rpb24sIGNvbmZpZ3VyaW5nIGlmIG5lY2Vzc2FyeQogICAgICAgIGxldCB2aWV3UmVzb2x2ZXIgPSBnZXRBY2NvdW50KG5mdENvbnRyYWN0QWRkcmVzcykuY29udHJhY3RzLmJvcnJvdzwme1ZpZXdSZXNvbHZlcn0+KG5hbWU6IG5mdENvbnRyYWN0TmFtZSkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgVmlld1Jlc29sdmVyIGZyb20gTkZUIGNvbnRyYWN0IikKICAgICAgICBsZXQgY29sbGVjdGlvbkRhdGEgPSB2aWV3UmVzb2x2ZXIucmVzb2x2ZUNvbnRyYWN0VmlldygKICAgICAgICAgICAgICAgIHJlc291cmNlVHlwZTogc2VsZi5uZnRUeXBlLAogICAgICAgICAgICAgICAgdmlld1R5cGU6IFR5cGU8TWV0YWRhdGFWaWV3cy5ORlRDb2xsZWN0aW9uRGF0YT4oKQogICAgICAgICAgICApIGFzISBNZXRhZGF0YVZpZXdzLk5GVENvbGxlY3Rpb25EYXRhPyA/PyBwYW5pYygiQ291bGQgbm90IHJlc29sdmUgTkZUQ29sbGVjdGlvbkRhdGEgdmlldyIpCiAgICAgICAgaWYgc2lnbmVyLnN0b3JhZ2UuYm9ycm93PCZ7Tm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9ufT4oZnJvbTogY29sbGVjdGlvbkRhdGEuc3RvcmFnZVBhdGgpID09IG5pbCB7CiAgICAgICAgICAgIHNpZ25lci5zdG9yYWdlLnNhdmUoPC1jb2xsZWN0aW9uRGF0YS5jcmVhdGVFbXB0eUNvbGxlY3Rpb24oKSwgdG86IGNvbGxlY3Rpb25EYXRhLnN0b3JhZ2VQYXRoKQogICAgICAgICAgICBzaWduZXIuY2FwYWJpbGl0aWVzLnVucHVibGlzaChjb2xsZWN0aW9uRGF0YS5wdWJsaWNQYXRoKQogICAgICAgICAgICBsZXQgY29sbGVjdGlvbkNhcCA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTwme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0+KGNvbGxlY3Rpb25EYXRhLnN0b3JhZ2VQYXRoKQogICAgICAgICAgICBzaWduZXIuY2FwYWJpbGl0aWVzLnB1Ymxpc2goY29sbGVjdGlvbkNhcCwgYXQ6IGNvbGxlY3Rpb25EYXRhLnB1YmxpY1BhdGgpCiAgICAgICAgfQogICAgICAgIHNlbGYuY29sbGVjdGlvbiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzwme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0+KGZyb206IGNvbGxlY3Rpb25EYXRhLnN0b3JhZ2VQYXRoKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBjb2xsZWN0aW9uIGZyb20gc3RvcmFnZSBwYXRoIikKCiAgICAgICAgLyogLS0tIENvbmZpZ3VyZSBhIFNjb3BlZEZUUHJvdmlkZXIgLS0tICovCiAgICAgICAgLy8KICAgICAgICAvLyBDYWxjdWxhdGUgdGhlIGJyaWRnZSBmZWUgLSBicmlkZ2luZyBmcm9tIEVWTSBjb25zdW1lcyBubyBzdG9yYWdlLCBzbyBmbGF0IGZlZQogICAgICAgIGxldCBhcHByb3hGZWUgPSBGbG93RVZNQnJpZGdlVXRpbHMuY2FsY3VsYXRlQnJpZGdlRmVlKGJ5dGVzOiA0MDBfMDAwKQogICAgICAgIC8vIElzc3VlIGFuZCBzdG9yZSBicmlkZ2UtZGVkaWNhdGVkIFByb3ZpZGVyIENhcGFiaWxpdHkgaW4gc3RvcmFnZSBpZiBuZWNlc3NhcnkKICAgICAgICBpZiBzaWduZXIuc3RvcmFnZS50eXBlKGF0OiBGbG93RVZNQnJpZGdlQ29uZmlnLnByb3ZpZGVyQ2FwYWJpbGl0eVN0b3JhZ2VQYXRoKSA9PSBuaWwgewogICAgICAgICAgICBsZXQgcHJvdmlkZXJDYXAgPSBzaWduZXIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8YXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAme0Z1bmdpYmxlVG9rZW4uUHJvdmlkZXJ9PigKICAgICAgICAgICAgICAgIC9zdG9yYWdlL2Zsb3dUb2tlblZhdWx0CiAgICAgICAgICAgICkKICAgICAgICAgICAgc2lnbmVyLnN0b3JhZ2Uuc2F2ZShwcm92aWRlckNhcCwgdG86IEZsb3dFVk1CcmlkZ2VDb25maWcucHJvdmlkZXJDYXBhYmlsaXR5U3RvcmFnZVBhdGgpCiAgICAgICAgfQogICAgICAgIC8vIENvcHkgdGhlIHN0b3JlZCBQcm92aWRlciBjYXBhYmlsaXR5IGFuZCBjcmVhdGUgYSBTY29wZWRGVFByb3ZpZGVyCiAgICAgICAgbGV0IHByb3ZpZGVyQ2FwQ29weSA9IHNpZ25lci5zdG9yYWdlLmNvcHk8Q2FwYWJpbGl0eTxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+PigKICAgICAgICAgICAgICAgIGZyb206IEZsb3dFVk1CcmlkZ2VDb25maWcucHJvdmlkZXJDYXBhYmlsaXR5U3RvcmFnZVBhdGgKICAgICAgICAgICAgKSA/PyBwYW5pYygiSW52YWxpZCBQcm92aWRlciBDYXBhYmlsaXR5IGZvdW5kIGluIHN0b3JhZ2UuIikKICAgICAgICBsZXQgcHJvdmlkZXJGaWx0ZXIgPSBTY29wZWRGVFByb3ZpZGVycy5BbGxvd2FuY2VGaWx0ZXIoYXBwcm94RmVlKQogICAgICAgIHNlbGYuc2NvcGVkUHJvdmlkZXIgPC0gU2NvcGVkRlRQcm92aWRlcnMuY3JlYXRlU2NvcGVkRlRQcm92aWRlcigKICAgICAgICAgICAgICAgIHByb3ZpZGVyOiBwcm92aWRlckNhcENvcHksCiAgICAgICAgICAgICAgICBmaWx0ZXJzOiBbIHByb3ZpZGVyRmlsdGVyIF0sCiAgICAgICAgICAgICAgICBleHBpcmF0aW9uOiBnZXRDdXJyZW50QmxvY2soKS50aW1lc3RhbXAgKyAxLjAKICAgICAgICAgICAgKQogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIC8vIEV4ZWN1dGUgdGhlIGJyaWRnZQogICAgICAgIGxldCBuZnQ6IEB7Tm9uRnVuZ2libGVUb2tlbi5ORlR9IDwtIHNlbGYuY29hLndpdGhkcmF3TkZUKAogICAgICAgICAgICB0eXBlOiBzZWxmLm5mdFR5cGUsCiAgICAgICAgICAgIGlkOiBpZCwKICAgICAgICAgICAgZmVlUHJvdmlkZXI6ICZzZWxmLnNjb3BlZFByb3ZpZGVyIGFzIGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntGdW5naWJsZVRva2VuLlByb3ZpZGVyfQogICAgICAgICkKICAgICAgICAvLyBEZXBvc2l0IHRoZSBicmlkZ2VkIE5GVCBpbnRvIHRoZSBzaWduZXIncyBjb2xsZWN0aW9uCiAgICAgICAgc2VsZi5jb2xsZWN0aW9uLmRlcG9zaXQodG9rZW46IDwtbmZ0KQogICAgICAgIC8vIERlc3Ryb3kgdGhlIFNjb3BlZEZUUHJvdmlkZXIKICAgICAgICBkZXN0cm95IHNlbGYuc2NvcGVkUHJvdmlkZXIKICAgIH0KfQo\u003d", - "bridgeNFTFromEvmToFlow": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYnJpZGdlTkZURnJvbUV2bVRvRmxvdyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDdlNjBkZjA0MmE5YzA4NjgKCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgppbXBvcnQgVmlld1Jlc29sdmVyIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4NjMxZTg4YWU3ZjFkN2MyMAoKaW1wb3J0IFNjb3BlZEZUUHJvdmlkZXJzIGZyb20gMHhkZmMyMGFlZTY1MGZjYmRmCgoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKCmltcG9ydCBGbG93RVZNQnJpZGdlVXRpbHMgZnJvbSAweGRmYzIwYWVlNjUwZmNiZGYKCmltcG9ydCBGbG93RVZNQnJpZGdlIGZyb20gMHhkZmMyMGFlZTY1MGZjYmRmCgppbXBvcnQgRmxvd0VWTUJyaWRnZUNvbmZpZyBmcm9tIDB4ZGZjMjBhZWU2NTBmY2JkZgoKCi8vLyBUaGlzIHRyYW5zYWN0aW9uIGJyaWRnZXMgYW4gTkZUIGZyb20gRVZNIHRvIENhZGVuY2UgYXNzdW1pbmcgaXQgaGFzIGFscmVhZHkgYmVlbiBvbmJvYXJkZWQgdG8gdGhlIEZsb3dFVk1CcmlkZ2UKLy8vIE5PVEU6IFRoZSBFUkM3MjEgbXVzdCBoYXZlIGZpcnN0IGJlZW4gb25ib2FyZGVkIHRvIHRoZSBicmlkZ2UuIFRoaXMgY2FuIGJlIGNoZWNrZWQgdmlhIHRoZSBtZXRob2QKLy8vICAgICBGbG93RVZNQnJpZGdlLmV2bUFkZHJlc3NSZXF1aXJlc09uYm9hcmRpbmcoYWRkcmVzczogc2VsZi5ldm1Db250cmFjdEFkZHJlc3MpCi8vLwovLy8gQHBhcmFtIG5mdENvbnRyYWN0QWRkcmVzczogVGhlIEZsb3cgYWNjb3VudCBhZGRyZXNzIGhvc3RpbmcgdGhlIE5GVC1kZWZpbmluZyBDYWRlbmNlIGNvbnRyYWN0Ci8vLyBAcGFyYW0gbmZ0Q29udHJhY3ROYW1lOiBUaGUgbmFtZSBvZiB0aGUgTkZULWRlZmluaW5nIENhZGVuY2UgY29udHJhY3QKLy8vIEBwYXJhbSBpZDogVGhlIEVSQzcyMSBpZCBvZiB0aGUgTkZUIHRvIGJyaWRnZSB0byBDYWRlbmNlIGZyb20gRVZNCi8vLwp0cmFuc2FjdGlvbihuZnRDb250cmFjdEFkZHJlc3M6IEFkZHJlc3MsIG5mdENvbnRyYWN0TmFtZTogU3RyaW5nLCBpZDogVUludDI1NiwgcmVjZWl2ZXI6IEFkZHJlc3MpIHsKCiAgICBsZXQgbmZ0VHlwZTogVHlwZQogICAgbGV0IGNvbGxlY3Rpb246ICZ7Tm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9ufQogICAgbGV0IHNjb3BlZFByb3ZpZGVyOiBAU2NvcGVkRlRQcm92aWRlcnMuU2NvcGVkRlRQcm92aWRlcgogICAgbGV0IGNvYTogYXV0aChFVk0uQnJpZGdlKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQKICAgIAogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoQm9ycm93VmFsdWUsIENvcHlWYWx1ZSwgSXNzdWVTdG9yYWdlQ2FwYWJpbGl0eUNvbnRyb2xsZXIsIFB1Ymxpc2hDYXBhYmlsaXR5LCBTYXZlVmFsdWUsIFVucHVibGlzaENhcGFiaWxpdHkpICZBY2NvdW50KSB7CiAgICAgICAgLyogLS0tIFJlZmVyZW5jZSB0aGUgc2lnbmVyJ3MgQ2FkZW5jZU93bmVkQWNjb3VudCAtLS0gKi8KICAgICAgICAvLwogICAgICAgIC8vIEJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgc2lnbmVyJ3MgQ09BCiAgICAgICAgc2VsZi5jb2EgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChFVk0uQnJpZGdlKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KGZyb206IC9zdG9yYWdlL2V2bSkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgQ09BIGZyb20gcHJvdmlkZWQgZ2F0ZXdheSBhZGRyZXNzIikKCiAgICAgICAgLy8gR2V0IHRoZSBFUkM3MjEgY29udHJhY3QgYWRkcmVzcyBmb3IgdGhlIGdpdmVuIE5GVCB0eXBlCiAgICAgICAgc2VsZi5uZnRUeXBlID0gRmxvd0VWTUJyaWRnZVV0aWxzLmJ1aWxkQ29tcG9zaXRlVHlwZSgKICAgICAgICAgICAgICAgIGFkZHJlc3M6IG5mdENvbnRyYWN0QWRkcmVzcywKICAgICAgICAgICAgICAgIGNvbnRyYWN0TmFtZTogbmZ0Q29udHJhY3ROYW1lLAogICAgICAgICAgICAgICAgcmVzb3VyY2VOYW1lOiAiTkZUIgogICAgICAgICAgICApID8/IHBhbmljKCJDb3VsZCBub3QgY29uc3RydWN0IE5GVCB0eXBlIikKCiAgICAgICAgLyogLS0tIFJlZmVyZW5jZSB0aGUgc2lnbmVyJ3MgTkZUIENvbGxlY3Rpb24gLS0tICovCiAgICAgICAgLy8KICAgICAgICAvLyBCb3Jyb3cgYSByZWZlcmVuY2UgdG8gdGhlIE5GVCBjb2xsZWN0aW9uLCBjb25maWd1cmluZyBpZiBuZWNlc3NhcnkKICAgICAgICBsZXQgdmlld1Jlc29sdmVyID0gZ2V0QWNjb3VudChuZnRDb250cmFjdEFkZHJlc3MpLmNvbnRyYWN0cy5ib3Jyb3c8JntWaWV3UmVzb2x2ZXJ9PihuYW1lOiBuZnRDb250cmFjdE5hbWUpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IFZpZXdSZXNvbHZlciBmcm9tIE5GVCBjb250cmFjdCIpCiAgICAgICAgbGV0IGNvbGxlY3Rpb25EYXRhID0gdmlld1Jlc29sdmVyLnJlc29sdmVDb250cmFjdFZpZXcoCiAgICAgICAgICAgICAgICByZXNvdXJjZVR5cGU6IHNlbGYubmZ0VHlwZSwKICAgICAgICAgICAgICAgIHZpZXdUeXBlOiBUeXBlPE1ldGFkYXRhVmlld3MuTkZUQ29sbGVjdGlvbkRhdGE+KCkKICAgICAgICAgICAgKSBhcyEgTWV0YWRhdGFWaWV3cy5ORlRDb2xsZWN0aW9uRGF0YT8gPz8gcGFuaWMoIkNvdWxkIG5vdCByZXNvbHZlIE5GVENvbGxlY3Rpb25EYXRhIHZpZXciKQogICAgICAgIGlmIHNpZ25lci5zdG9yYWdlLmJvcnJvdzwme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0+KGZyb206IGNvbGxlY3Rpb25EYXRhLnN0b3JhZ2VQYXRoKSA9PSBuaWwgewogICAgICAgICAgICBzaWduZXIuc3RvcmFnZS5zYXZlKDwtY29sbGVjdGlvbkRhdGEuY3JlYXRlRW1wdHlDb2xsZWN0aW9uKCksIHRvOiBjb2xsZWN0aW9uRGF0YS5zdG9yYWdlUGF0aCkKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy51bnB1Ymxpc2goY29sbGVjdGlvbkRhdGEucHVibGljUGF0aCkKICAgICAgICAgICAgbGV0IGNvbGxlY3Rpb25DYXAgPSBzaWduZXIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8JntOb25GdW5naWJsZVRva2VuLkNvbGxlY3Rpb259Pihjb2xsZWN0aW9uRGF0YS5zdG9yYWdlUGF0aCkKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5wdWJsaXNoKGNvbGxlY3Rpb25DYXAsIGF0OiBjb2xsZWN0aW9uRGF0YS5wdWJsaWNQYXRoKQogICAgICAgIH0KCiAgICAgICAgbGV0IHJlY2VpdmVyQWNjdCA9IGdldEFjY291bnQocmVjZWl2ZXIpCiAgICAgICAgc2VsZi5jb2xsZWN0aW9uID0gcmVjZWl2ZXJBY2N0LmNhcGFiaWxpdGllcy5ib3Jyb3c8JntOb25GdW5naWJsZVRva2VuLkNvbGxlY3Rpb259Pihjb2xsZWN0aW9uRGF0YS5wdWJsaWNQYXRoKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBjb2xsZWN0aW9uIGNhcGFiaWxpdGllcyBmcm9tIHB1YmxpYyBwYXRoIikKCiAgICAgICAgLyogLS0tIENvbmZpZ3VyZSBhIFNjb3BlZEZUUHJvdmlkZXIgLS0tICovCiAgICAgICAgLy8KICAgICAgICAvLyBDYWxjdWxhdGUgdGhlIGJyaWRnZSBmZWUgLSBicmlkZ2luZyBmcm9tIEVWTSBjb25zdW1lcyBubyBzdG9yYWdlLCBzbyBmbGF0IGZlZQogICAgICAgIGxldCBhcHByb3hGZWUgPSBGbG93RVZNQnJpZGdlVXRpbHMuY2FsY3VsYXRlQnJpZGdlRmVlKGJ5dGVzOiA0MDBfMDAwKQogICAgICAgIC8vIElzc3VlIGFuZCBzdG9yZSBicmlkZ2UtZGVkaWNhdGVkIFByb3ZpZGVyIENhcGFiaWxpdHkgaW4gc3RvcmFnZSBpZiBuZWNlc3NhcnkKICAgICAgICBpZiBzaWduZXIuc3RvcmFnZS50eXBlKGF0OiBGbG93RVZNQnJpZGdlQ29uZmlnLnByb3ZpZGVyQ2FwYWJpbGl0eVN0b3JhZ2VQYXRoKSA9PSBuaWwgewogICAgICAgICAgICBsZXQgcHJvdmlkZXJDYXAgPSBzaWduZXIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8YXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAme0Z1bmdpYmxlVG9rZW4uUHJvdmlkZXJ9PigKICAgICAgICAgICAgICAgIC9zdG9yYWdlL2Zsb3dUb2tlblZhdWx0CiAgICAgICAgICAgICkKICAgICAgICAgICAgc2lnbmVyLnN0b3JhZ2Uuc2F2ZShwcm92aWRlckNhcCwgdG86IEZsb3dFVk1CcmlkZ2VDb25maWcucHJvdmlkZXJDYXBhYmlsaXR5U3RvcmFnZVBhdGgpCiAgICAgICAgfQogICAgICAgIC8vIENvcHkgdGhlIHN0b3JlZCBQcm92aWRlciBjYXBhYmlsaXR5IGFuZCBjcmVhdGUgYSBTY29wZWRGVFByb3ZpZGVyCiAgICAgICAgbGV0IHByb3ZpZGVyQ2FwQ29weSA9IHNpZ25lci5zdG9yYWdlLmNvcHk8Q2FwYWJpbGl0eTxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+PigKICAgICAgICAgICAgICAgIGZyb206IEZsb3dFVk1CcmlkZ2VDb25maWcucHJvdmlkZXJDYXBhYmlsaXR5U3RvcmFnZVBhdGgKICAgICAgICAgICAgKSA/PyBwYW5pYygiSW52YWxpZCBQcm92aWRlciBDYXBhYmlsaXR5IGZvdW5kIGluIHN0b3JhZ2UuIikKICAgICAgICBsZXQgcHJvdmlkZXJGaWx0ZXIgPSBTY29wZWRGVFByb3ZpZGVycy5BbGxvd2FuY2VGaWx0ZXIoYXBwcm94RmVlKQogICAgICAgIHNlbGYuc2NvcGVkUHJvdmlkZXIgPC0gU2NvcGVkRlRQcm92aWRlcnMuY3JlYXRlU2NvcGVkRlRQcm92aWRlcigKICAgICAgICAgICAgICAgIHByb3ZpZGVyOiBwcm92aWRlckNhcENvcHksCiAgICAgICAgICAgICAgICBmaWx0ZXJzOiBbIHByb3ZpZGVyRmlsdGVyIF0sCiAgICAgICAgICAgICAgICBleHBpcmF0aW9uOiBnZXRDdXJyZW50QmxvY2soKS50aW1lc3RhbXAgKyAxLjAKICAgICAgICAgICAgKQogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIC8vIEV4ZWN1dGUgdGhlIGJyaWRnZQogICAgICAgIGxldCBuZnQ6IEB7Tm9uRnVuZ2libGVUb2tlbi5ORlR9IDwtIHNlbGYuY29hLndpdGhkcmF3TkZUKAogICAgICAgICAgICB0eXBlOiBzZWxmLm5mdFR5cGUsCiAgICAgICAgICAgIGlkOiBpZCwKICAgICAgICAgICAgZmVlUHJvdmlkZXI6ICZzZWxmLnNjb3BlZFByb3ZpZGVyIGFzIGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntGdW5naWJsZVRva2VuLlByb3ZpZGVyfQogICAgICAgICkKICAgICAgICAvLyBEZXBvc2l0IHRoZSBicmlkZ2VkIE5GVCBpbnRvIHRoZSBzaWduZXIncyBjb2xsZWN0aW9uCiAgICAgICAgc2VsZi5jb2xsZWN0aW9uLmRlcG9zaXQodG9rZW46IDwtbmZ0KQogICAgICAgIC8vIERlc3Ryb3kgdGhlIFNjb3BlZEZUUHJvdmlkZXIKICAgICAgICBkZXN0cm95IHNlbGYuc2NvcGVkUHJvdmlkZXIKICAgIH0KfQo\u003d", - "bridgeNFTFromEvmToFlowV2": "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\u003d", - "bridgeNFTFromEvmToFlowV3": "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\u003d\u003d", - "bridgeNFTFromEvmToFlowWithPayer": "// Flow Wallet - testnet Script  bridgeNFTFromEvmToFlowWithPayer - v2.72
// <platform_info>

import MetadataViews from 0x631e88ae7f1d7c20

import ViewResolver from 0x631e88ae7f1d7c20

import NonFungibleToken from 0x631e88ae7f1d7c20

import FungibleToken from 0x9a0766d93b6608b7

import FlowToken from 0x7e60df042a9c0868

import FungibleTokenMetadataViews from 0x9a0766d93b6608b7

import ScopedFTProviders from 0xdfc20aee650fcbdf

import EVM from 0x8c5303eaa26202d6

import FlowEVMBridgeUtils from 0xdfc20aee650fcbdf

import FlowEVMBridge from 0xdfc20aee650fcbdf

import FlowEVMBridgeConfig from 0xdfc20aee650fcbdf

import StorageRent from 0xd50084a1a43b1507

import CrossVMMetadataViews from 0x631e88ae7f1d7c20


/// This transaction bridges an NFT from EVM to Cadence assuming it has already been onboarded to the FlowEVMBridge.
/// Also know that the recipient Flow account must have a Receiver capable of receiving the this bridged NFT accessible
/// via published Capability at the token's standard path.
/// NOTE: The ERC721 must have first been onboarded to the bridge. This can be checked via the method
///     FlowEVMBridge.evmAddressRequiresOnboarding(address: self.evmContractAddress)
///
/// @param nftIdentifier: The Cadence type identifier of the NFT to bridge - e.g. nft.getType().identifier
/// @param id: The ERC721 id of the NFT to bridge to Cadence from EVM
/// @param recipient: The Flow account address to receive the bridged NFT
///
transaction(nftIdentifier: String, id: UInt256, recipient: Address) {
    let nftType: Type
    let receiver: &{NonFungibleToken.Receiver}
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let coa: auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount
    let viewResolver: &{ViewResolver}

    prepare(signer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account, payer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        /* --- Construct the NFT type --- */
        //
        // Construct the NFT type from the provided identifier
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        // Parse the NFT identifier into its components
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: self.nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Reference the recipient's NFT Receiver --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: self.nftType,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        // Configure the signer's account for this NFT
        if signer.storage.borrow<&{NonFungibleToken.Collection}>(from: collectionData.storagePath) == nil {
            signer.storage.save(<-collectionData.createEmptyCollection(), to: collectionData.storagePath)
            signer.capabilities.unpublish(collectionData.publicPath)
            let collectionCap = signer.capabilities.storage.issue<&{NonFungibleToken.Collection}>(collectionData.storagePath)
            signer.capabilities.publish(collectionCap, at: collectionData.publicPath)
        }
        self.receiver = getAccount(recipient).capabilities.borrow<&{NonFungibleToken.Receiver}>(collectionData.publicPath)
            ?? panic("Could not borrow Receiver from recipient's public capability path")

        /* --- Configure a ScopedFTProvider --- */
        //
        // Calculate the bridge fee - bridging from EVM consumes no storage, so flat fee
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000)
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if payer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = payer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            payer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = payer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    execute {
        // Unwrap NFTs from project-defined ERC721 wrapper contract if applicable
        unwrapNFTsIfApplicable(self.coa, nftIDs: [id], nftType: self.nftType, viewResolver: self.viewResolver)

        // Execute the bridge
        let nft: @{NonFungibleToken.NFT} <- self.coa.withdrawNFT(
            type: self.nftType,
            id: id,
            feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        // Ensure the bridged nft is the correct type
        assert(
            nft.getType() == self.nftType,
            message: "Bridged nft type mismatch - requeswted: ".concat(self.nftType.identifier)
                .concat(", received: ").concat(nft.getType().identifier)
        )
        // Deposit the bridged NFT into the signer's collection
        self.receiver.deposit(token: <-nft)
        // Destroy the ScopedFTProvider
        destroy self.scopedProvider
        StorageRent.tryRefill(recipient)

    }
}

/// Unwraps NFTs from a project's custom ERC721 wrapper contract to bridged NFTs on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
///
access(all) fun unwrapNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt256],
    nftType: Type,
    viewResolver: &{ViewResolver}
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            for id in nftIDs {
                // Unwrap NFT if it is wrapped
                if isNFTWrapped(coa,
                    nftID: id,
                    underlying: underlyingAddress,
                    wrapper: crossVMPointer.evmContractAddress
                ) {
                    let res = mustCall(coa, crossVMPointer.evmContractAddress,
                        functionSig: "withdrawTo(address,uint256[])",
                        args: [coa.address(), [id]]
                    )
                    let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                    assert(decodedRes.length == 1, message: "Invalid response length")
                    assert(decodedRes[0] as! Bool, message: "Failed to unwrap NFT")
                }
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is wrapped in the underlying ERC721 contract
///
access(all) fun isNFTWrapped(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftID: UInt256,
    underlying: EVM.EVMAddress,
    wrapper: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: underlying,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return false
    if res.status != EVM.Status.successful || res.data.length == 0{
        return false
    }

    // Decode and compare the addresses
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")

    let owner = decodedResult[0] as! EVM.EVMAddress
    return owner.toString() == wrapper.toString()
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", - "bridgeNFTFromEvmV2": "// Flow Wallet - testnet Script  bridgeNFTFromEvmV2 - v2.72
// <platform_info>

import MetadataViews from 0x631e88ae7f1d7c20

import ViewResolver from 0x631e88ae7f1d7c20

import NonFungibleToken from 0x631e88ae7f1d7c20

import FungibleToken from 0x9a0766d93b6608b7

import FlowToken from 0x7e60df042a9c0868

import FungibleTokenMetadataViews from 0x9a0766d93b6608b7

import ScopedFTProviders from 0xdfc20aee650fcbdf

import EVM from 0x8c5303eaa26202d6

import FlowEVMBridgeUtils from 0xdfc20aee650fcbdf

import FlowEVMBridge from 0xdfc20aee650fcbdf

import FlowEVMBridgeConfig from 0xdfc20aee650fcbdf

import CrossVMMetadataViews from 0x631e88ae7f1d7c20


/// This transaction bridges an NFT from EVM to Cadence assuming it has already been onboarded to the FlowEVMBridge
/// NOTE: The ERC721 must have first been onboarded to the bridge. This can be checked via the method
///     FlowEVMBridge.evmAddressRequiresOnboarding(address: self.evmContractAddress)
///
/// @param nftIdentifier: The Cadence type identifier of the NFT to bridge - e.g. nft.getType().identifier
/// @param id: The ERC721 id of the NFT to bridge to Cadence from EVM
///
transaction(nftIdentifier: String, id: UInt256) {

    let nftType: Type
    let collection: &{NonFungibleToken.Collection}
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let coa: auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount
    let viewResolver: &{ViewResolver}

    prepare(signer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        /* --- Construct the NFT type --- */
        //
        // Construct the NFT type from the provided identifier
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        // Parse the NFT identifier into its components
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: self.nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Reference the signer's NFT Collection --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: self.nftType,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        if signer.storage.borrow<&{NonFungibleToken.Collection}>(from: collectionData.storagePath) == nil {
            signer.storage.save(<-collectionData.createEmptyCollection(), to: collectionData.storagePath)
            signer.capabilities.unpublish(collectionData.publicPath)
            let collectionCap = signer.capabilities.storage.issue<&{NonFungibleToken.Collection}>(collectionData.storagePath)
            signer.capabilities.publish(collectionCap, at: collectionData.publicPath)
        }
        self.collection = signer.storage.borrow<&{NonFungibleToken.Collection}>(from: collectionData.storagePath)
            ?? panic("Could not borrow collection from storage path")

        /* --- Configure a ScopedFTProvider --- */
        //
        // Calculate the bridge fee - bridging from EVM consumes no storage, so flat fee
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000)
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    execute {
        // Unwrap NFTs from project-defined ERC721 wrapper contract if applicable
        unwrapNFTsIfApplicable(self.coa, nftIDs: [id], nftType: self.nftType, viewResolver: self.viewResolver)

        // Execute the bridge
        let nft: @{NonFungibleToken.NFT} <- self.coa.withdrawNFT(
            type: self.nftType,
            id: id,
            feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        // Ensure the bridged nft is the correct type
        assert(
            nft.getType() == self.nftType,
            message: "Bridged nft type mismatch - requeswted: ".concat(self.nftType.identifier)
                .concat(", received: ").concat(nft.getType().identifier)
        )
        // Deposit the bridged NFT into the signer's collection
        self.collection.deposit(token: <-nft)
        // Destroy the ScopedFTProvider
        destroy self.scopedProvider
    }
}

/// Unwraps NFTs from a project's custom ERC721 wrapper contract to bridged NFTs on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
///
access(all) fun unwrapNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt256],
    nftType: Type,
    viewResolver: &{ViewResolver}
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            for id in nftIDs {
                // Unwrap NFT if it is wrapped
                if isNFTWrapped(coa,
                    nftID: id,
                    underlying: underlyingAddress,
                    wrapper: crossVMPointer.evmContractAddress
                ) {
                    let res = mustCall(coa, crossVMPointer.evmContractAddress,
                        functionSig: "withdrawTo(address,uint256[])",
                        args: [coa.address(), [id]]
                    )
                    let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                    assert(decodedRes.length == 1, message: "Invalid response length")
                    assert(decodedRes[0] as! Bool, message: "Failed to unwrap NFT")
                }
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is wrapped in the underlying ERC721 contract
///
access(all) fun isNFTWrapped(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftID: UInt256,
    underlying: EVM.EVMAddress,
    wrapper: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: underlying,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return false
    if res.status != EVM.Status.successful || res.data.length == 0{
        return false
    }

    // Decode and compare the addresses
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    let owner = decodedResult[0] as! EVM.EVMAddress
    return owner.toString() == wrapper.toString()
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", - "bridgeNFTFromEvmWithPayer": "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\u003d", - "bridgeNFTToEvm": "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\u003d", - "bridgeNFTToEvmAddress": "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\u003d", - "bridgeNFTToEvmAddressV2": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYnJpZGdlTkZUVG9Fdm1BZGRyZXNzVjIgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgppbXBvcnQgVmlld1Jlc29sdmVyIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4NjMxZTg4YWU3ZjFkN2MyMAoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDdlNjBkZjA0MmE5YzA4NjgKCmltcG9ydCBGdW5naWJsZVRva2VuTWV0YWRhdGFWaWV3cyBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKaW1wb3J0IFNjb3BlZEZUUHJvdmlkZXJzIGZyb20gMHhkZmMyMGFlZTY1MGZjYmRmCgppbXBvcnQgRVZNIGZyb20gMHg4YzUzMDNlYWEyNjIwMmQ2CgppbXBvcnQgRmxvd0VWTUJyaWRnZVV0aWxzIGZyb20gMHhkZmMyMGFlZTY1MGZjYmRmCgppbXBvcnQgRmxvd0VWTUJyaWRnZSBmcm9tIDB4ZGZjMjBhZWU2NTBmY2JkZgoKaW1wb3J0IEZsb3dFVk1CcmlkZ2VDb25maWcgZnJvbSAweGRmYzIwYWVlNjUwZmNiZGYKCmltcG9ydCBDcm9zc1ZNTWV0YWRhdGFWaWV3cyBmcm9tIDB4NjMxZTg4YWU3ZjFkN2MyMAoKCi8vLyBCcmlkZ2VzIGFuIE5GVCBmcm9tIHRoZSBzaWduZXIncyBjb2xsZWN0aW9uIGluIENhZGVuY2UgdG8gdGhlIG5hbWVkIHJlY2lwaWVudCBpbiBFVk0uCi8vLwovLy8gTk9URTogVGhpcyB0cmFuc2FjdGlvbiBhbHNvIG9uYm9hcmRzIHRoZSBORlQgdG8gdGhlIGJyaWRnZSBpZiBuZWNlc3Nhcnkgd2hpY2ggbWF5IGluY3VyIGFkZGl0aW9uYWwgZmVlcwovLy8gICAgIHRoYW4gYnJpZGdpbmcgYW4gYXNzZXQgdGhhdCBoYXMgYWxyZWFkeSBiZWVuIG9uYm9hcmRlZC4KLy8vCi8vLyBAcGFyYW0gbmZ0SWRlbnRpZmllcjogVGhlIENhZGVuY2UgdHlwZSBpZGVudGlmaWVyIG9mIHRoZSBORlQgdG8gYnJpZGdlIC0gZS5nLiBuZnQuZ2V0VHlwZSgpLmlkZW50aWZpZXIKLy8vIEBwYXJhbSBpZDogVGhlIENhZGVuY2UgTkZULmlkIG9mIHRoZSBORlQgdG8gYnJpZGdlIHRvIEVWTQovLy8gQHBhcmFtIHJlY2lwaWVudDogVGhlIGhleC1lbmNvZGVkIEVWTSBhZGRyZXNzIHRvIHJlY2VpdmUgdGhlIE5GVAovLy8KdHJhbnNhY3Rpb24obmZ0SWRlbnRpZmllcjogU3RyaW5nLCBpZDogVUludDY0LCByZWNpcGllbnQ6IFN0cmluZykgewogICAgbGV0IG5mdDogQHtOb25GdW5naWJsZVRva2VuLk5GVH0KICAgIGxldCByZXF1aXJlc09uYm9hcmRpbmc6IEJvb2wKICAgIGxldCBzY29wZWRQcm92aWRlcjogQFNjb3BlZEZUUHJvdmlkZXJzLlNjb3BlZEZUUHJvdmlkZXIKICAgIGxldCBjb2E6IGF1dGgoRVZNLkNhbGwpICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudAogICAgbGV0IG5mdFR5cGU6IFR5cGUKICAgIGxldCB2aWV3UmVzb2x2ZXI6ICZ7Vmlld1Jlc29sdmVyfQoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKENvcHlWYWx1ZSwgQm9ycm93VmFsdWUsIElzc3VlU3RvcmFnZUNhcGFiaWxpdHlDb250cm9sbGVyLCBQdWJsaXNoQ2FwYWJpbGl0eSwgU2F2ZVZhbHVlKSAmQWNjb3VudCkgewogICAgICAgIC8vIFJldHJpZXZlIG9yIGNyZWF0ZSBDT0EKICAgICAgICBpZiBsZXQgY29hID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoRVZNLkNhbGwpICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oZnJvbTogL3N0b3JhZ2UvZXZtKSB7CiAgICAgICAgICAgIHNlbGYuY29hID0gY29hCiAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgc2lnbmVyLnN0b3JhZ2Uuc2F2ZTxARVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KDwtIEVWTS5jcmVhdGVDYWRlbmNlT3duZWRBY2NvdW50KCksIHRvOiAvc3RvcmFnZS9ldm0pCiAgICAgICAgICAgIHNpZ25lci5jYXBhYmlsaXRpZXMucHVibGlzaCgKICAgICAgICAgICAgICAgIHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTwmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KC9zdG9yYWdlL2V2bSksCiAgICAgICAgICAgICAgICBhdDogL3B1YmxpYy9ldm0KICAgICAgICAgICAgKQogICAgICAgICAgICBzZWxmLmNvYSA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEVWTS5DYWxsKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KGZyb206IC9zdG9yYWdlL2V2bSkhCiAgICAgICAgfQoKICAgICAgICAvKiAtLS0gQ29uc3RydWN0IHRoZSBORlQgdHlwZSAtLS0gKi8KICAgICAgICAvLwogICAgICAgIC8vIENvbnN0cnVjdCB0aGUgTkZUIHR5cGUgZnJvbSB0aGUgcHJvdmlkZWQgaWRlbnRpZmllcgogICAgICAgIHNlbGYubmZ0VHlwZSA9IENvbXBvc2l0ZVR5cGUobmZ0SWRlbnRpZmllcikKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBjb25zdHJ1Y3QgTkZUIHR5cGUgZnJvbSBpZGVudGlmaWVyOiAiLmNvbmNhdChuZnRJZGVudGlmaWVyKSkKICAgICAgICAvLyBQYXJzZSB0aGUgTkZUIGlkZW50aWZpZXIgaW50byBpdHMgY29tcG9uZW50cwogICAgICAgIGxldCBuZnRDb250cmFjdEFkZHJlc3MgPSBGbG93RVZNQnJpZGdlVXRpbHMuZ2V0Q29udHJhY3RBZGRyZXNzKGZyb21UeXBlOiBzZWxmLm5mdFR5cGUpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgZ2V0IGNvbnRyYWN0IGFkZHJlc3MgZnJvbSBpZGVudGlmaWVyOiAiLmNvbmNhdChuZnRJZGVudGlmaWVyKSkKICAgICAgICBsZXQgbmZ0Q29udHJhY3ROYW1lID0gRmxvd0VWTUJyaWRnZVV0aWxzLmdldENvbnRyYWN0TmFtZShmcm9tVHlwZTogc2VsZi5uZnRUeXBlKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGdldCBjb250cmFjdCBuYW1lIGZyb20gaWRlbnRpZmllcjogIi5jb25jYXQobmZ0SWRlbnRpZmllcikpCgogICAgICAgIC8qIC0tLSBSZXRyaWV2ZSB0aGUgTkZUIC0tLSAqLwogICAgICAgIC8vCiAgICAgICAgLy8gQm9ycm93IGEgcmVmZXJlbmNlIHRvIHRoZSBORlQgY29sbGVjdGlvbiwgY29uZmlndXJpbmcgaWYgbmVjZXNzYXJ5CiAgICAgICAgc2VsZi52aWV3UmVzb2x2ZXIgPSBnZXRBY2NvdW50KG5mdENvbnRyYWN0QWRkcmVzcykuY29udHJhY3RzLmJvcnJvdzwme1ZpZXdSZXNvbHZlcn0+KG5hbWU6IG5mdENvbnRyYWN0TmFtZSkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgVmlld1Jlc29sdmVyIGZyb20gTkZUIGNvbnRyYWN0IikKICAgICAgICBsZXQgY29sbGVjdGlvbkRhdGEgPSBzZWxmLnZpZXdSZXNvbHZlci5yZXNvbHZlQ29udHJhY3RWaWV3KAogICAgICAgICAgICAgICAgcmVzb3VyY2VUeXBlOiBuaWwsCiAgICAgICAgICAgICAgICB2aWV3VHlwZTogVHlwZTxNZXRhZGF0YVZpZXdzLk5GVENvbGxlY3Rpb25EYXRhPigpCiAgICAgICAgICAgICkgYXMhIE1ldGFkYXRhVmlld3MuTkZUQ29sbGVjdGlvbkRhdGE/ID8/IHBhbmljKCJDb3VsZCBub3QgcmVzb2x2ZSBORlRDb2xsZWN0aW9uRGF0YSB2aWV3IikKICAgICAgICBsZXQgY29sbGVjdGlvbiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKE5vbkZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7Tm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9ufT4oCiAgICAgICAgICAgICAgICBmcm9tOiBjb2xsZWN0aW9uRGF0YS5zdG9yYWdlUGF0aAogICAgICAgICAgICApID8/IHBhbmljKCJDb3VsZCBub3QgYWNjZXNzIHNpZ25lcidzIE5GVCBDb2xsZWN0aW9uIikKCiAgICAgICAgLy8gV2l0aGRyYXcgdGhlIHJlcXVlc3RlZCBORlQgJiBjYWxjdWxhdGUgdGhlIGFwcHJveGltYXRlIGJyaWRnZSBmZWUgYmFzZWQgb24gTkZUIHN0b3JhZ2UgdXNhZ2UKICAgICAgICBsZXQgY3VycmVudFN0b3JhZ2VVc2FnZSA9IHNpZ25lci5zdG9yYWdlLnVzZWQKICAgICAgICBzZWxmLm5mdCA8LSBjb2xsZWN0aW9uLndpdGhkcmF3KHdpdGhkcmF3SUQ6IGlkKQogICAgICAgIGxldCB3aXRoZHJhd25TdG9yYWdlVXNhZ2UgPSBzaWduZXIuc3RvcmFnZS51c2VkCiAgICAgICAgdmFyIGFwcHJveEZlZSA9IEZsb3dFVk1CcmlkZ2VVdGlscy5jYWxjdWxhdGVCcmlkZ2VGZWUoYnl0ZXM6IDQwMF8wMDApICsgRmxvd0VWTUJyaWRnZUNvbmZpZy5iYXNlRmVlCiAgICAgICAgLy8gRGV0ZXJtaW5lIGlmIHRoZSBORlQgcmVxdWlyZXMgb25ib2FyZGluZyAtIHRoaXMgaW1wYWN0cyB0aGUgZmVlIHJlcXVpcmVkCiAgICAgICAgc2VsZi5yZXF1aXJlc09uYm9hcmRpbmcgPSBGbG93RVZNQnJpZGdlLnR5cGVSZXF1aXJlc09uYm9hcmRpbmcoc2VsZi5uZnQuZ2V0VHlwZSgpKQogICAgICAgICAgICA/PyBwYW5pYygiQnJpZGdlIGRvZXMgbm90IHN1cHBvcnQgdGhpcyBhc3NldCB0eXBlIikKICAgICAgICBpZiBzZWxmLnJlcXVpcmVzT25ib2FyZGluZyB7CiAgICAgICAgICAgIGFwcHJveEZlZSA9IGFwcHJveEZlZSArIEZsb3dFVk1CcmlkZ2VDb25maWcub25ib2FyZEZlZQogICAgICAgIH0KCiAgICAgICAgLyogLS0tIENvbmZpZ3VyZSBhIFNjb3BlZEZUUHJvdmlkZXIgLS0tICovCiAgICAgICAgLy8KICAgICAgICAvLyBJc3N1ZSBhbmQgc3RvcmUgYnJpZGdlLWRlZGljYXRlZCBQcm92aWRlciBDYXBhYmlsaXR5IGluIHN0b3JhZ2UgaWYgbmVjZXNzYXJ5CiAgICAgICAgaWYgc2lnbmVyLnN0b3JhZ2UudHlwZShhdDogRmxvd0VWTUJyaWRnZUNvbmZpZy5wcm92aWRlckNhcGFiaWxpdHlTdG9yYWdlUGF0aCkgPT0gbmlsIHsKICAgICAgICAgICAgbGV0IHByb3ZpZGVyQ2FwID0gc2lnbmVyLmNhcGFiaWxpdGllcy5zdG9yYWdlLmlzc3VlPGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntGdW5naWJsZVRva2VuLlByb3ZpZGVyfT4oCiAgICAgICAgICAgICAgICAvc3RvcmFnZS9mbG93VG9rZW5WYXVsdAogICAgICAgICAgICApCiAgICAgICAgICAgIHNpZ25lci5zdG9yYWdlLnNhdmUocHJvdmlkZXJDYXAsIHRvOiBGbG93RVZNQnJpZGdlQ29uZmlnLnByb3ZpZGVyQ2FwYWJpbGl0eVN0b3JhZ2VQYXRoKQogICAgICAgIH0KICAgICAgICAvLyBDb3B5IHRoZSBzdG9yZWQgUHJvdmlkZXIgY2FwYWJpbGl0eSBhbmQgY3JlYXRlIGEgU2NvcGVkRlRQcm92aWRlcgogICAgICAgIGxldCBwcm92aWRlckNhcENvcHkgPSBzaWduZXIuc3RvcmFnZS5jb3B5PENhcGFiaWxpdHk8YXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAme0Z1bmdpYmxlVG9rZW4uUHJvdmlkZXJ9Pj4oCiAgICAgICAgICAgICAgICBmcm9tOiBGbG93RVZNQnJpZGdlQ29uZmlnLnByb3ZpZGVyQ2FwYWJpbGl0eVN0b3JhZ2VQYXRoCiAgICAgICAgICAgICkgPz8gcGFuaWMoIkludmFsaWQgUHJvdmlkZXIgQ2FwYWJpbGl0eSBmb3VuZCBpbiBzdG9yYWdlLiIpCiAgICAgICAgbGV0IHByb3ZpZGVyRmlsdGVyID0gU2NvcGVkRlRQcm92aWRlcnMuQWxsb3dhbmNlRmlsdGVyKGFwcHJveEZlZSkKICAgICAgICBzZWxmLnNjb3BlZFByb3ZpZGVyIDwtIFNjb3BlZEZUUHJvdmlkZXJzLmNyZWF0ZVNjb3BlZEZUUHJvdmlkZXIoCiAgICAgICAgICAgICAgICBwcm92aWRlcjogcHJvdmlkZXJDYXBDb3B5LAogICAgICAgICAgICAgICAgZmlsdGVyczogWyBwcm92aWRlckZpbHRlciBdLAogICAgICAgICAgICAgICAgZXhwaXJhdGlvbjogZ2V0Q3VycmVudEJsb2NrKCkudGltZXN0YW1wICsgMS4wCiAgICAgICAgICAgICkKICAgIH0KCiAgICBwcmUgewogICAgICAgIHNlbGYubmZ0LmdldFR5cGUoKS5pZGVudGlmaWVyID09IG5mdElkZW50aWZpZXI6CiAgICAgICAgICAgICJBdHRlbXB0aW5nIHRvIHNlbmQgaW52YWxpZCBuZnQgdHlwZSAtIHJlcXVlc3RlZDogIi5jb25jYXQobmZ0SWRlbnRpZmllcikKICAgICAgICAgICAgLmNvbmNhdCgiLCBzZW5kaW5nOiAiKS5jb25jYXQoc2VsZi5uZnQuZ2V0VHlwZSgpLmlkZW50aWZpZXIpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgaWYgc2VsZi5yZXF1aXJlc09uYm9hcmRpbmcgewogICAgICAgICAgICAvLyBPbmJvYXJkIHRoZSBORlQgdG8gdGhlIGJyaWRnZQogICAgICAgICAgICBGbG93RVZNQnJpZGdlLm9uYm9hcmRCeVR5cGUoCiAgICAgICAgICAgICAgICBzZWxmLm5mdC5nZXRUeXBlKCksCiAgICAgICAgICAgICAgICBmZWVQcm92aWRlcjogJnNlbGYuc2NvcGVkUHJvdmlkZXIgYXMgYXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAme0Z1bmdpYmxlVG9rZW4uUHJvdmlkZXJ9CiAgICAgICAgICAgICkKICAgICAgICB9CgogICAgICAgIC8vIEV4ZWN1dGUgdGhlIGJyaWRnZSB0cmFuc2FjdGlvbgogICAgICAgIHNlbGYuY29hLmRlcG9zaXRORlQoCiAgICAgICAgICAgIG5mdDogPC1zZWxmLm5mdCwKICAgICAgICAgICAgZmVlUHJvdmlkZXI6ICZzZWxmLnNjb3BlZFByb3ZpZGVyIGFzIGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntGdW5naWJsZVRva2VuLlByb3ZpZGVyfQogICAgICAgICkKCiAgICAgICAgLy8gRGVzdHJveSB0aGUgU2NvcGVkRlRQcm92aWRlcgogICAgICAgIGRlc3Ryb3kgc2VsZi5zY29wZWRQcm92aWRlcgoKICAgICAgICAvLyBXcmFwIE5GVHMgaWYgYXBwbGljYWJsZQogICAgICAgIHdyYXBBbmRUcmFuc2Zlck5GVHNJZkFwcGxpY2FibGUoc2VsZi5jb2EsCiAgICAgICAgICAgIG5mdElEczogW2lkXSwKICAgICAgICAgICAgbmZ0VHlwZTogc2VsZi5uZnRUeXBlLAogICAgICAgICAgICB2aWV3UmVzb2x2ZXI6IHNlbGYudmlld1Jlc29sdmVyLAogICAgICAgICAgICByZWNpcGllbnRJZk5vdENvYTogRVZNLmFkZHJlc3NGcm9tU3RyaW5nKHJlY2lwaWVudCkKICAgICAgICApCiAgICB9Cn0KCi8vLyBXcmFwcyBhbmQgdHJhbnNmZXJzIGJyaWRnZWQgTkZUcyBpbnRvIGEgcHJvamVjdCdzIGN1c3RvbSBFUkM3MjEgd3JhcHBlciBjb250cmFjdCBvbiBFVk0sIGlmIGFwcGxpY2FibGUuCi8vLyBFbmFibGVzIHByb2plY3RzIHRvIHVzZSB0aGVpciBvd24gRVJDNzIxIGNvbnRyYWN0IHdoaWxlIGxldmVyYWdpbmcgdGhlIGJyaWRnZSdzIHVuZGVybHlpbmcgY29udHJhY3QsCi8vLyB1bnRpbCBkaXJlY3QgY3VzdG9tIGNvbnRyYWN0IHN1cHBvcnQgaXMgYWRkZWQgdG8gdGhlIGJyaWRnZS4KLy8vCi8vLyBAcGFyYW0gY29hOiBUaGUgQ09BIG9mIHRoZSBzaWduZXIKLy8vIEBwYXJhbSBuZnRJRHM6IFRoZSBJRHMgb2YgdGhlIE5GVHMgdG8gd3JhcAovLy8gQHBhcmFtIG5mdFR5cGU6IFRoZSB0eXBlIG9mIHRoZSBORlRzIHRvIHdyYXAKLy8vIEBwYXJhbSB2aWV3UmVzb2x2ZXI6IFRoZSBWaWV3UmVzb2x2ZXIgb2YgdGhlIE5GVCBjb250cmFjdAovLy8gQHBhcmFtIHJlY2lwaWVudElmTm90Q29hOiBUaGUgRVZNIGFkZHJlc3MgdG8gdHJhbnNmZXIgdGhlIHdyYXBwZWQgTkZUcyB0bywgbmlsIGlmIHRoZSBORlRzIHNob3VsZCBzdGF5IGluIHNpZ25lcidzIENPQQovLy8KYWNjZXNzKGFsbCkgZnVuIHdyYXBBbmRUcmFuc2Zlck5GVHNJZkFwcGxpY2FibGUoCiAgICBfIGNvYTogYXV0aChFVk0uQ2FsbCkgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50LAogICAgbmZ0SURzOiBbVUludDY0XSwKICAgIG5mdFR5cGU6IFR5cGUsCiAgICB2aWV3UmVzb2x2ZXI6ICZ7Vmlld1Jlc29sdmVyfSwKICAgIHJlY2lwaWVudElmTm90Q29hOiBFVk0uRVZNQWRkcmVzcz8KKSB7CiAgICAvLyBHZXQgdGhlIHByb2plY3QtZGVmaW5lZCBFUkM3MjEgYWRkcmVzcyBpZiBpdCBleGlzdHMKICAgIGlmIGxldCBjcm9zc1ZNUG9pbnRlciA9IHZpZXdSZXNvbHZlci5yZXNvbHZlQ29udHJhY3RWaWV3KAogICAgICAgICAgICByZXNvdXJjZVR5cGU6IG5mdFR5cGUsCiAgICAgICAgICAgIHZpZXdUeXBlOiBUeXBlPENyb3NzVk1NZXRhZGF0YVZpZXdzLkVWTVBvaW50ZXI+KCkKICAgICkgYXMhIENyb3NzVk1NZXRhZGF0YVZpZXdzLkVWTVBvaW50ZXI/IHsKICAgICAgICAvLyBHZXQgdGhlIHVuZGVybHlpbmcgRVJDNzIxIGFkZHJlc3MgaWYgaXQgZXhpc3RzCiAgICAgICAgaWYgbGV0IHVuZGVybHlpbmdBZGRyZXNzID0gZ2V0VW5kZXJseWluZ0VSQzcyMUFkZHJlc3MoY29hLCBjcm9zc1ZNUG9pbnRlci5ldm1Db250cmFjdEFkZHJlc3MpIHsKICAgICAgICAgICAgLy8gV3JhcCBORlRzIGlmIHVuZGVybHlpbmcgRVJDNzIxIGFkZHJlc3MgbWF0Y2hlcyBicmlkZ2UncyBhc3NvY2lhdGVkIGFkZHJlc3MgZm9yIE5GVCB0eXBlCiAgICAgICAgICAgIGlmIHVuZGVybHlpbmdBZGRyZXNzLmVxdWFscyhGbG93RVZNQnJpZGdlQ29uZmlnLmdldEVWTUFkZHJlc3NBc3NvY2lhdGVkKHdpdGg6IG5mdFR5cGUpISkgewogICAgICAgICAgICAgICAgLy8gQXBwcm92ZSBjb250cmFjdCB0byB3aXRoZHJhdyB1bmRlcmx5aW5nIE5GVHMgZnJvbSBzaWduZXIncyBjb2EKICAgICAgICAgICAgICAgIG11c3RDYWxsKGNvYSwgdW5kZXJseWluZ0FkZHJlc3MsCiAgICAgICAgICAgICAgICAgICAgZnVuY3Rpb25TaWc6ICJzZXRBcHByb3ZhbEZvckFsbChhZGRyZXNzLGJvb2wpIiwKICAgICAgICAgICAgICAgICAgICBhcmdzOiBbY3Jvc3NWTVBvaW50ZXIuZXZtQ29udHJhY3RBZGRyZXNzLCB0cnVlXQogICAgICAgICAgICAgICAgKQoKICAgICAgICAgICAgICAgIC8vIFdyYXAgTkZUcyB3aXRoIHByb3ZpZGVkIElEcywgYW5kIGNoZWNrIGlmIHRoZSBjYWxsIHdhcyBzdWNjZXNzZnVsCiAgICAgICAgICAgICAgICBsZXQgcmVzID0gbXVzdENhbGwoY29hLCBjcm9zc1ZNUG9pbnRlci5ldm1Db250cmFjdEFkZHJlc3MsCiAgICAgICAgICAgICAgICAgICAgZnVuY3Rpb25TaWc6ICJkZXBvc2l0Rm9yKGFkZHJlc3MsdWludDI1NltdKSIsCiAgICAgICAgICAgICAgICAgICAgYXJnczogW2NvYS5hZGRyZXNzKCksIG5mdElEc10KICAgICAgICAgICAgICAgICkKICAgICAgICAgICAgICAgIGxldCBkZWNvZGVkUmVzID0gRVZNLmRlY29kZUFCSSh0eXBlczogW1R5cGU8Qm9vbD4oKV0sIGRhdGE6IHJlcy5kYXRhKQogICAgICAgICAgICAgICAgYXNzZXJ0KGRlY29kZWRSZXMubGVuZ3RoID09IDEsIG1lc3NhZ2U6ICJJbnZhbGlkIHJlc3BvbnNlIGxlbmd0aCIpCiAgICAgICAgICAgICAgICBhc3NlcnQoZGVjb2RlZFJlc1swXSBhcyEgQm9vbCwgbWVzc2FnZTogIkZhaWxlZCB0byB3cmFwIE5GVHMiKQoKICAgICAgICAgICAgICAgIC8vIFRyYW5zZmVyIE5GVHMgdG8gcmVjaXBpZW50IGlmIHByb3ZpZGVkCiAgICAgICAgICAgICAgICBpZiBsZXQgdG8gPSByZWNpcGllbnRJZk5vdENvYSB7CiAgICAgICAgICAgICAgICAgICAgbXVzdFRyYW5zZmVyTkZUcyhjb2EsIGNyb3NzVk1Qb2ludGVyLmV2bUNvbnRyYWN0QWRkcmVzcywgbmZ0SURzOiBuZnRJRHMsIHRvOiB0bykKICAgICAgICAgICAgICAgIH0KCiAgICAgICAgICAgICAgICAvLyBSZXZva2UgYXBwcm92YWwgZm9yIGNvbnRyYWN0IHRvIHdpdGhkcmF3IHVuZGVybHlpbmcgTkZUcyBmcm9tIHNpZ25lcidzIGNvYQogICAgICAgICAgICAgICAgbXVzdENhbGwoY29hLCB1bmRlcmx5aW5nQWRkcmVzcywKICAgICAgICAgICAgICAgICAgICBmdW5jdGlvblNpZzogInNldEFwcHJvdmFsRm9yQWxsKGFkZHJlc3MsYm9vbCkiLAogICAgICAgICAgICAgICAgICAgIGFyZ3M6IFtjcm9zc1ZNUG9pbnRlci5ldm1Db250cmFjdEFkZHJlc3MsIGZhbHNlXQogICAgICAgICAgICAgICAgKQogICAgICAgICAgICB9CiAgICAgICAgfQogICAgfQp9CgovLy8gR2V0cyB0aGUgdW5kZXJseWluZyBFUkM3MjEgYWRkcmVzcyBpZiBpdCBleGlzdHMgKGkuZS4gaWYgdGhlIEVSQzcyMSBpcyBhIHdyYXBwZXIpCi8vLwphY2Nlc3MoYWxsKSBmdW4gZ2V0VW5kZXJseWluZ0VSQzcyMUFkZHJlc3MoCiAgICBfIGNvYTogYXV0aChFVk0uQ2FsbCkgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50LAogICAgXyB3cmFwcGVyQWRkcmVzczogRVZNLkVWTUFkZHJlc3MKKTogRVZNLkVWTUFkZHJlc3M/IHsKICAgIGxldCByZXMgPSBjb2EuY2FsbCgKICAgICAgICB0bzogd3JhcHBlckFkZHJlc3MsCiAgICAgICAgZGF0YTogRVZNLmVuY29kZUFCSVdpdGhTaWduYXR1cmUoInVuZGVybHlpbmcoKSIsIFtdKSwKICAgICAgICBnYXNMaW1pdDogMTAwXzAwMCwKICAgICAgICB2YWx1ZTogRVZNLkJhbGFuY2UoYXR0b2Zsb3c6IDApCiAgICApCgogICAgLy8gSWYgdGhlIGNhbGwgZmFpbHMsIHJldHVybiBuaWwKICAgIGlmIHJlcy5zdGF0dXMgIT0gRVZNLlN0YXR1cy5zdWNjZXNzZnVsIHx8IHJlcy5kYXRhLmxlbmd0aCA9PSAwIHsKICAgICAgICByZXR1cm4gbmlsCiAgICB9CgogICAgLy8gRGVjb2RlIGFuZCByZXR1cm4gdGhlIHVuZGVybHlpbmcgRVJDNzIxIGFkZHJlc3MKICAgIGxldCBkZWNvZGVkUmVzdWx0ID0gRVZNLmRlY29kZUFCSSgKICAgICAgICB0eXBlczogW1R5cGU8RVZNLkVWTUFkZHJlc3M+KCldLAogICAgICAgIGRhdGE6IHJlcy5kYXRhCiAgICApCiAgICBhc3NlcnQoZGVjb2RlZFJlc3VsdC5sZW5ndGggPT0gMSwgbWVzc2FnZTogIkludmFsaWQgcmVzcG9uc2UgbGVuZ3RoIikKICAgIHJldHVybiBkZWNvZGVkUmVzdWx0WzBdIGFzISBFVk0uRVZNQWRkcmVzcwp9CgovLy8gQ2hlY2tzIGlmIHRoZSBwcm92aWRlZCBORlQgaXMgb3duZWQgYnkgdGhlIHByb3ZpZGVkIEVWTSBhZGRyZXNzCi8vLwphY2Nlc3MoYWxsKSBmdW4gaXNPd25lcigKICAgIF8gY29hOiBhdXRoKEVWTS5DYWxsKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQsCiAgICBfIGVyYzcyMUFkZHJlc3M6IEVWTS5FVk1BZGRyZXNzLAogICAgXyBuZnRJRDogVUludDY0LAogICAgXyBvd25lclRvQ2hlY2s6IEVWTS5FVk1BZGRyZXNzCik6IEJvb2wgewogICAgbGV0IHJlcyA9IGNvYS5jYWxsKAogICAgICAgIHRvOiBlcmM3MjFBZGRyZXNzLAogICAgICAgIGRhdGE6IEVWTS5lbmNvZGVBQklXaXRoU2lnbmF0dXJlKCJvd25lck9mKHVpbnQyNTYpIiwgW25mdElEXSksCiAgICAgICAgZ2FzTGltaXQ6IDEwMF8wMDAsCiAgICAgICAgdmFsdWU6IEVWTS5CYWxhbmNlKGF0dG9mbG93OiAwKQogICAgKQogICAgYXNzZXJ0KHJlcy5zdGF0dXMgPT0gRVZNLlN0YXR1cy5zdWNjZXNzZnVsLCBtZXNzYWdlOiAiQ2FsbCB0byBFUkM3MjEub3duZXJPZih1aW50MjU2KSBmYWlsZWQiKQogICAgbGV0IGRlY29kZWRSZXMgPSBFVk0uZGVjb2RlQUJJKHR5cGVzOiBbVHlwZTxFVk0uRVZNQWRkcmVzcz4oKV0sIGRhdGE6IHJlcy5kYXRhKQogICAgaWYgZGVjb2RlZFJlcy5sZW5ndGggPT0gMSB7CiAgICAgICAgbGV0IGFjdHVhbE93bmVyID0gZGVjb2RlZFJlc1swXSBhcyEgRVZNLkVWTUFkZHJlc3MKICAgICAgICByZXR1cm4gYWN0dWFsT3duZXIuZXF1YWxzKG93bmVyVG9DaGVjaykKICAgIH0KICAgIHJldHVybiBmYWxzZQp9CgovLy8gVHJhbnNmZXJzIE5GVHMgZnJvbSB0aGUgcHJvdmlkZWQgQ09BIHRvIHRoZSBwcm92aWRlZCBFVk0gYWRkcmVzcwovLy8KYWNjZXNzKGFsbCkgZnVuIG11c3RUcmFuc2Zlck5GVHMoCiAgICBfIGNvYTogYXV0aChFVk0uQ2FsbCkgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50LAogICAgXyBlcmM3MjFBZGRyZXNzOiBFVk0uRVZNQWRkcmVzcywKICAgIG5mdElEczogW1VJbnQ2NF0sCiAgICB0bzogRVZNLkVWTUFkZHJlc3MKKSB7CiAgICBmb3IgaWQgaW4gbmZ0SURzIHsKICAgICAgICBhc3NlcnQoaXNPd25lcihjb2EsIGVyYzcyMUFkZHJlc3MsIGlkLCBjb2EuYWRkcmVzcygpKSwgbWVzc2FnZTogIk5GVCBub3Qgb3duZWQgYnkgc2lnbmVyJ3MgQ09BIikKICAgICAgICBtdXN0Q2FsbChjb2EsIGVyYzcyMUFkZHJlc3MsCiAgICAgICAgICAgIGZ1bmN0aW9uU2lnOiAic2FmZVRyYW5zZmVyRnJvbShhZGRyZXNzLGFkZHJlc3MsdWludDI1NikiLAogICAgICAgICAgICBhcmdzOiBbY29hLmFkZHJlc3MoKSwgdG8sIGlkXQogICAgICAgICkKICAgICAgICBhc3NlcnQoaXNPd25lcihjb2EsIGVyYzcyMUFkZHJlc3MsIGlkLCB0byksIG1lc3NhZ2U6ICJORlQgbm90IHRyYW5zZmVycmVkIHRvIHJlY2lwaWVudCIpCiAgICB9Cn0KCi8vLyBDYWxscyBhIGZ1bmN0aW9uIG9uIGFuIEVWTSBjb250cmFjdCBmcm9tIHByb3ZpZGVkIGNvYQovLy8KYWNjZXNzKGFsbCkgZnVuIG11c3RDYWxsKAogICAgXyBjb2E6IGF1dGgoRVZNLkNhbGwpICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudCwKICAgIF8gY29udHJhY3RBZGRyOiBFVk0uRVZNQWRkcmVzcywKICAgIGZ1bmN0aW9uU2lnOiBTdHJpbmcsCiAgICBhcmdzOiBbQW55U3RydWN0XQopOiBFVk0uUmVzdWx0IHsKICAgIGxldCByZXMgPSBjb2EuY2FsbCgKICAgICAgICB0bzogY29udHJhY3RBZGRyLAogICAgICAgIGRhdGE6IEVWTS5lbmNvZGVBQklXaXRoU2lnbmF0dXJlKGZ1bmN0aW9uU2lnLCBhcmdzKSwKICAgICAgICBnYXNMaW1pdDogNF8wMDBfMDAwLAogICAgICAgIHZhbHVlOiBFVk0uQmFsYW5jZShhdHRvZmxvdzogMCkKICAgICkKCiAgICBhc3NlcnQocmVzLnN0YXR1cyA9PSBFVk0uU3RhdHVzLnN1Y2Nlc3NmdWwsCiAgICAgICAgbWVzc2FnZTogIkZhaWxlZCB0byBjYWxsICciLmNvbmNhdChmdW5jdGlvblNpZykKICAgICAgICAgICAgLmNvbmNhdCgiXG5cdCBlcnJvciBjb2RlOiAiKS5jb25jYXQocmVzLmVycm9yQ29kZS50b1N0cmluZygpKQogICAgICAgICAgICAuY29uY2F0KCJcblx0IGVycm9yIG1lc3NhZ2U6ICIpLmNvbmNhdChyZXMuZXJyb3JNZXNzYWdlKQogICAgICAgICAgICAuY29uY2F0KCJcblx0IGdhcyB1c2VkOiAiKS5jb25jYXQocmVzLmdhc1VzZWQudG9TdHJpbmcoKSkKICAgICAgICAgICAgLmNvbmNhdCgiXG5cdCBjYWxsZXIgYWRkcmVzczogMHgiKS5jb25jYXQoY29hLmFkZHJlc3MoKS50b1N0cmluZygpKQogICAgICAgICAgICAuY29uY2F0KCJcblx0IGNvbnRyYWN0IGFkZHJlc3M6IDB4IikuY29uY2F0KGNvbnRyYWN0QWRkci50b1N0cmluZygpKQogICAgKQoKICAgIHJldHVybiByZXMKfQo\u003d", - "bridgeNFTToEvmAddressWithPayer": "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\u003d\u003d", - "bridgeNFTToEvmV2": "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\u003d\u003d", - "bridgeNFTToEvmWithPayer": "// Flow Wallet - testnet Script  bridgeNFTToEvmWithPayer - v2.72
// <platform_info>

import MetadataViews from 0x631e88ae7f1d7c20

import ViewResolver from 0x631e88ae7f1d7c20

import NonFungibleToken from 0x631e88ae7f1d7c20

import FungibleToken from 0x9a0766d93b6608b7

import FlowToken from 0x7e60df042a9c0868

import FungibleTokenMetadataViews from 0x9a0766d93b6608b7

import ScopedFTProviders from 0xdfc20aee650fcbdf

import EVM from 0x8c5303eaa26202d6

import FlowEVMBridgeUtils from 0xdfc20aee650fcbdf

import FlowEVMBridge from 0xdfc20aee650fcbdf

import FlowEVMBridgeConfig from 0xdfc20aee650fcbdf

import CrossVMMetadataViews from 0x631e88ae7f1d7c20


/// Bridges an NFT from the signer's collection in Cadence to the signer's COA in FlowEVM
///
/// NOTE: This transaction also onboards the NFT to the bridge if necessary which may incur additional fees
///     than bridging an asset that has already been onboarded.
///
/// @param nftIdentifier: The Cadence type identifier of the NFT to bridge - e.g. nft.getType().identifier
/// @param id: The Cadence NFT.id of the NFT to bridge to EVM
///
transaction(nftIdentifier: String, id: UInt64) {

    let nft: @{NonFungibleToken.NFT}
    let coa: auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount
    let requiresOnboarding: Bool
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let nftType: Type
    let viewResolver: &{ViewResolver}

    prepare(signer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account, payer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        /* --- Construct the NFT type --- */
        //
        // Construct the NFT type from the provided identifier
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        // Parse the NFT identifier into its components
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: self.nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Retrieve the NFT --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: self.nftType,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        let collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            ) ?? panic("Could not access signer's NFT Collection")

        // Withdraw the requested NFT & calculate the approximate bridge fee based on NFT storage usage
        let currentStorageUsage = signer.storage.used
        self.nft <- collection.withdraw(withdrawID: id)
        let withdrawnStorageUsage = signer.storage.used
        var approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000) + FlowEVMBridgeConfig.baseFee
        // Determine if the NFT requires onboarding - this impacts the fee required
        self.requiresOnboarding = FlowEVMBridge.typeRequiresOnboarding(self.nft.getType())
            ?? panic("Bridge does not support this asset type")
        if self.requiresOnboarding {
            approxFee = approxFee + FlowEVMBridgeConfig.onboardFee
        }

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if payer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = payer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            payer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = payer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    pre {
        self.nft.getType().identifier == nftIdentifier:
            "Attempting to send invalid nft type - requested: ".concat(nftIdentifier)
            .concat(", sending: ").concat(self.nft.getType().identifier)
    }

    execute {
        if self.requiresOnboarding {
            // Onboard the NFT to the bridge
            FlowEVMBridge.onboardByType(
                self.nft.getType(),
                feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
        }

        // Execute the bridge
        self.coa.depositNFT(
            nft: <-self.nft,
            feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        // Destroy the ScopedFTProvider
        destroy self.scopedProvider

        // Wrap NFTs if applicable
        wrapAndTransferNFTsIfApplicable(self.coa,
            nftIDs: [id],
            nftType: self.nftType,
            viewResolver: self.viewResolver,
            recipientIfNotCoa: nil
        )
    }
}

/// Wraps and transfers bridged NFTs into a project's custom ERC721 wrapper contract on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
/// @param recipientIfNotCoa: The EVM address to transfer the wrapped NFTs to, nil if the NFTs should stay in signer's COA
///
access(all) fun wrapAndTransferNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt64],
    nftType: Type,
    viewResolver: &{ViewResolver},
    recipientIfNotCoa: EVM.EVMAddress?
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            // Wrap NFTs if underlying ERC721 address matches bridge's associated address for NFT type
            if underlyingAddress.equals(FlowEVMBridgeConfig.getEVMAddressAssociated(with: nftType)!) {
                // Approve contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, true]
                )

                // Wrap NFTs with provided IDs, and check if the call was successful
                let res = mustCall(coa, crossVMPointer.evmContractAddress,
                    functionSig: "depositFor(address,uint256[])",
                    args: [coa.address(), nftIDs]
                )
                let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                assert(decodedRes.length == 1, message: "Invalid response length")
                assert(decodedRes[0] as! Bool, message: "Failed to wrap NFTs")

                // Transfer NFTs to recipient if provided
                if let to = recipientIfNotCoa {
                    mustTransferNFTs(coa, crossVMPointer.evmContractAddress, nftIDs: nftIDs, to: to)
                }

                // Revoke approval for contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, false]
                )
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is owned by the provided EVM address
///
access(all) fun isOwner(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    _ nftID: UInt64,
    _ ownerToCheck: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: erc721Address,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )
    assert(res.status == EVM.Status.successful, message: "Call to ERC721.ownerOf(uint256) failed")
    let decodedRes = EVM.decodeABI(types: [Type<EVM.EVMAddress>()], data: res.data)
    if decodedRes.length == 1 {
        let actualOwner = decodedRes[0] as! EVM.EVMAddress
        return actualOwner.equals(ownerToCheck)
    }
    return false
}

/// Transfers NFTs from the provided COA to the provided EVM address
///
access(all) fun mustTransferNFTs(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    nftIDs: [UInt64],
    to: EVM.EVMAddress
) {
    for id in nftIDs {
        assert(isOwner(coa, erc721Address, id, coa.address()), message: "NFT not owned by signer's COA")
        mustCall(coa, erc721Address,
            functionSig: "safeTransferFrom(address,address,uint256)",
            args: [coa.address(), to, id]
        )
        assert(isOwner(coa, erc721Address, id, to), message: "NFT not transferred to recipient")
    }
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", - "bridgeTokensFromEvm": "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\u003d\u003d", - "bridgeTokensFromEvmToFlow": "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\u003d", - "bridgeTokensFromEvmToFlowV2": "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\u003d\u003d", - "bridgeTokensFromEvmToFlowV3": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYnJpZGdlVG9rZW5zRnJvbUV2bVRvRmxvd1YzIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTWV0YWRhdGFWaWV3cyBmcm9tIDB4NjMxZTg4YWU3ZjFkN2MyMAoKaW1wb3J0IFZpZXdSZXNvbHZlciBmcm9tIDB4NjMxZTg4YWU3ZjFkN2MyMAoKaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKaW1wb3J0IEZsb3dUb2tlbiBmcm9tIDB4N2U2MGRmMDQyYTljMDg2OAoKaW1wb3J0IEZ1bmdpYmxlVG9rZW5NZXRhZGF0YVZpZXdzIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgoKaW1wb3J0IFNjb3BlZEZUUHJvdmlkZXJzIGZyb20gMHhkZmMyMGFlZTY1MGZjYmRmCgoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKCmltcG9ydCBGbG93RVZNQnJpZGdlVXRpbHMgZnJvbSAweGRmYzIwYWVlNjUwZmNiZGYKCmltcG9ydCBGbG93RVZNQnJpZGdlIGZyb20gMHhkZmMyMGFlZTY1MGZjYmRmCgppbXBvcnQgRmxvd0VWTUJyaWRnZUNvbmZpZyBmcm9tIDB4ZGZjMjBhZWU2NTBmY2JkZgoKaW1wb3J0IFN0b3JhZ2VSZW50IGZyb20gMHhkNTAwODRhMWE0M2IxNTA3CgoKLy8vIFRoaXMgdHJhbnNhY3Rpb24gYnJpZGdlcyBmdW5naWJsZSB0b2tlbnMgZnJvbSBFVk0gdG8gQ2FkZW5jZSBhc3N1bWluZyBpdCBoYXMgYWxyZWFkeSBiZWVuIG9uYm9hcmRlZCB0byB0aGUKLy8vIEZsb3dFVk1CcmlkZ2UuIFRoZSBmdWxsIGFtb3VudCB0byBiZSB0cmFuc2ZlcnJlZCBpcyBzb3VyY2VkIGZyb20gRVZNLCBzbyBpdCdzIGFzc3VtZWQgdGhlIHNpZ25lciBoYXMgc3VmZmljaWVudAovLy8gYmFsYW5jZSBvZiB0aGUgRVJDMjAgdG8gYnJpZGdpbmcgaW50byBDYWRlbmNlLiBBbHNvIGtub3cgdGhhdCB0aGUgcmVjaXBpZW50IEZsb3cgYWNjb3VudCBtdXN0IGhhdmUgYSBSZWNlaXZlcgovLy8gY2FwYWJsZSBvZiByZWNlaXZpbmcgdGhlIGJyaWRnZWQgdG9rZW5zIGFjY2Vzc2libGUgdmlhIHB1Ymxpc2hlZCBDYXBhYmlsaXR5IGF0IHRoZSB0b2tlbidzIHN0YW5kYXJkIHBhdGguCi8vLwovLy8gTk9URTogVGhlIEVSQzIwIG11c3QgaGF2ZSBmaXJzdCBiZWVuIG9uYm9hcmRlZCB0byB0aGUgYnJpZGdlLiBUaGlzIGNhbiBiZSBjaGVja2VkIHZpYSB0aGUgbWV0aG9kCi8vLyAgICAgRmxvd0VWTUJyaWRnZS5ldm1BZGRyZXNzUmVxdWlyZXNPbmJvYXJkaW5nKGFkZHJlc3M6IHNlbGYuZXZtQ29udHJhY3RBZGRyZXNzKQovLy8KLy8vIEBwYXJhbSB2YXVsdElkZW50aWZpZXI6IFRoZSBDYWRlbmNlIHR5cGUgaWRlbnRpZmllciBvZiB0aGUgRnVuZ2libGVUb2tlbiBWYXVsdCB0byBicmlkZ2UKLy8vICAgICAtIGUuZy4gdmF1bHQuZ2V0VHlwZSgpLmlkZW50aWZpZXIKLy8vIEBwYXJhbSBhbW91bnQ6IFRoZSBhbW91bnQgb2YgdG9rZW5zIHRvIGJyaWRnZSBmcm9tIEVWTSBhbmQgdHJhbnNmZXIgdG8gdGhlIHJlY2lwaWVudAovLy8gQHBhcmFtIHJlY2lwaWVudDogVGhlIEZsb3cgYWNjb3VudCBhZGRyZXNzIHRvIHJlY2VpdmUgdGhlIGJyaWRnZWQgdG9rZW5zCi8vLwp0cmFuc2FjdGlvbih2YXVsdElkZW50aWZpZXI6IFN0cmluZywgYW1vdW50OiBVSW50MjU2LCByZWNpcGllbnQ6IEFkZHJlc3MpIHsKCiAgICBsZXQgdmF1bHRUeXBlOiBUeXBlCiAgICBsZXQgcmVjZWl2ZXI6ICZ7RnVuZ2libGVUb2tlbi5SZWNlaXZlcn0KICAgIGxldCBzY29wZWRQcm92aWRlcjogQFNjb3BlZEZUUHJvdmlkZXJzLlNjb3BlZEZUUHJvdmlkZXIKICAgIGxldCBjb2E6IGF1dGgoRVZNLkJyaWRnZSkgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoQm9ycm93VmFsdWUsIENvcHlWYWx1ZSwgSXNzdWVTdG9yYWdlQ2FwYWJpbGl0eUNvbnRyb2xsZXIsIFB1Ymxpc2hDYXBhYmlsaXR5LCBTYXZlVmFsdWUsIFVucHVibGlzaENhcGFiaWxpdHkpICZBY2NvdW50KSB7CiAgICAgICAgLyogLS0tIFJlZmVyZW5jZSB0aGUgc2lnbmVyJ3MgQ2FkZW5jZU93bmVkQWNjb3VudCAtLS0gKi8KICAgICAgICAvLwogICAgICAgIC8vIEJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgc2lnbmVyJ3MgQ09BCiAgICAgICAgc2VsZi5jb2EgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChFVk0uQnJpZGdlKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KGZyb206IC9zdG9yYWdlL2V2bSkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgQ09BIGZyb20gcHJvdmlkZWQgZ2F0ZXdheSBhZGRyZXNzIikKCiAgICAgICAgLyogLS0tIENvbnN0cnVjdCB0aGUgVmF1bHQgdHlwZSAtLS0gKi8KICAgICAgICAvLwogICAgICAgIC8vIENvbnN0cnVjdCB0aGUgVmF1bHQgdHlwZSBmcm9tIHRoZSBwcm92aWRlZCBpZGVudGlmaWVyCiAgICAgICAgc2VsZi52YXVsdFR5cGUgPSBDb21wb3NpdGVUeXBlKHZhdWx0SWRlbnRpZmllcikKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBjb25zdHJ1Y3QgVmF1bHQgdHlwZSBmcm9tIGlkZW50aWZpZXI6ICIuY29uY2F0KHZhdWx0SWRlbnRpZmllcikpCiAgICAgICAgLy8gUGFyc2UgdGhlIFZhdWx0IGlkZW50aWZpZXIgaW50byBpdHMgY29tcG9uZW50cwogICAgICAgIGxldCB0b2tlbkNvbnRyYWN0QWRkcmVzcyA9IEZsb3dFVk1CcmlkZ2VVdGlscy5nZXRDb250cmFjdEFkZHJlc3MoZnJvbVR5cGU6IHNlbGYudmF1bHRUeXBlKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGdldCBjb250cmFjdCBhZGRyZXNzIGZyb20gaWRlbnRpZmllcjogIi5jb25jYXQodmF1bHRJZGVudGlmaWVyKSkKICAgICAgICBsZXQgdG9rZW5Db250cmFjdE5hbWUgPSBGbG93RVZNQnJpZGdlVXRpbHMuZ2V0Q29udHJhY3ROYW1lKGZyb21UeXBlOiBzZWxmLnZhdWx0VHlwZSkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBnZXQgY29udHJhY3QgbmFtZSBmcm9tIGlkZW50aWZpZXI6ICIuY29uY2F0KHZhdWx0SWRlbnRpZmllcikpCgogICAgICAgIC8qIC0tLSBSZWZlcmVuY2UgdGhlIHNpZ25lcidzIFZhdWx0IC0tLSAqLwogICAgICAgIC8vCiAgICAgICAgLy8gQm9ycm93IGEgcmVmZXJlbmNlIHRvIHRoZSBGdW5naWJsZVRva2VuIFZhdWx0LCBjb25maWd1cmluZyBpZiBuZWNlc3NhcnkKICAgICAgICBsZXQgdmlld1Jlc29sdmVyID0gZ2V0QWNjb3VudCh0b2tlbkNvbnRyYWN0QWRkcmVzcykuY29udHJhY3RzLmJvcnJvdzwme1ZpZXdSZXNvbHZlcn0+KG5hbWU6IHRva2VuQ29udHJhY3ROYW1lKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBWaWV3UmVzb2x2ZXIgZnJvbSBGdW5naWJsZVRva2VuIGNvbnRyYWN0IikKICAgICAgICBsZXQgdmF1bHREYXRhID0gdmlld1Jlc29sdmVyLnJlc29sdmVDb250cmFjdFZpZXcoCiAgICAgICAgICAgICAgICByZXNvdXJjZVR5cGU6IHNlbGYudmF1bHRUeXBlLAogICAgICAgICAgICAgICAgdmlld1R5cGU6IFR5cGU8RnVuZ2libGVUb2tlbk1ldGFkYXRhVmlld3MuRlRWYXVsdERhdGE+KCkKICAgICAgICAgICAgKSBhcyEgRnVuZ2libGVUb2tlbk1ldGFkYXRhVmlld3MuRlRWYXVsdERhdGE/ID8/IHBhbmljKCJDb3VsZCBub3QgcmVzb2x2ZSBGVFZhdWx0RGF0YSB2aWV3IikKICAgICAgICAvLyBJZiB0aGUgdmF1bHQgZG9lcyBub3QgZXhpc3QsIGNyZWF0ZSBpdCBhbmQgcHVibGlzaCBhY2NvcmRpbmcgdG8gdGhlIGNvbnRyYWN0J3MgZGVmaW5lZCBjb25maWd1cmF0aW9uCiAgICAgICAgaWYgc2lnbmVyLnN0b3JhZ2UuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5WYXVsdH0+KGZyb206IHZhdWx0RGF0YS5zdG9yYWdlUGF0aCkgPT0gbmlsIHsKICAgICAgICAgICAgc2lnbmVyLnN0b3JhZ2Uuc2F2ZSg8LXZhdWx0RGF0YS5jcmVhdGVFbXB0eVZhdWx0KCksIHRvOiB2YXVsdERhdGEuc3RvcmFnZVBhdGgpCgogICAgICAgICAgICBzaWduZXIuY2FwYWJpbGl0aWVzLnVucHVibGlzaCh2YXVsdERhdGEucmVjZWl2ZXJQYXRoKQogICAgICAgICAgICBzaWduZXIuY2FwYWJpbGl0aWVzLnVucHVibGlzaCh2YXVsdERhdGEubWV0YWRhdGFQYXRoKQoKICAgICAgICAgICAgbGV0IHJlY2VpdmVyQ2FwID0gc2lnbmVyLmNhcGFiaWxpdGllcy5zdG9yYWdlLmlzc3VlPCZ7RnVuZ2libGVUb2tlbi5WYXVsdH0+KHZhdWx0RGF0YS5zdG9yYWdlUGF0aCkKICAgICAgICAgICAgbGV0IG1ldGFkYXRhQ2FwID0gc2lnbmVyLmNhcGFiaWxpdGllcy5zdG9yYWdlLmlzc3VlPCZ7RnVuZ2libGVUb2tlbi5WYXVsdH0+KHZhdWx0RGF0YS5zdG9yYWdlUGF0aCkKCiAgICAgICAgICAgIHNpZ25lci5jYXBhYmlsaXRpZXMucHVibGlzaChyZWNlaXZlckNhcCwgYXQ6IHZhdWx0RGF0YS5yZWNlaXZlclBhdGgpCiAgICAgICAgICAgIHNpZ25lci5jYXBhYmlsaXRpZXMucHVibGlzaChtZXRhZGF0YUNhcCwgYXQ6IHZhdWx0RGF0YS5tZXRhZGF0YVBhdGgpCiAgICAgICAgfQogICAgICAgIHNlbGYucmVjZWl2ZXIgPSBnZXRBY2NvdW50KHJlY2lwaWVudCkuY2FwYWJpbGl0aWVzLmJvcnJvdzwme0Z1bmdpYmxlVG9rZW4uUmVjZWl2ZXJ9Pih2YXVsdERhdGEucmVjZWl2ZXJQYXRoKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBWYXVsdCBmcm9tIHJlY2lwaWVudCdzIGFjY291bnQiKQoKICAgICAgICAvKiAtLS0gQ29uZmlndXJlIGEgU2NvcGVkRlRQcm92aWRlciAtLS0gKi8KICAgICAgICAvLwogICAgICAgIC8vIENhbGN1bGF0ZSB0aGUgYnJpZGdlIGZlZSAtIGJyaWRnaW5nIGZyb20gRVZNIGNvbnN1bWVzIG5vIHN0b3JhZ2UsIHNvIGZsYXQgZmVlCiAgICAgICAgbGV0IGFwcHJveEZlZSA9IEZsb3dFVk1CcmlkZ2VVdGlscy5jYWxjdWxhdGVCcmlkZ2VGZWUoYnl0ZXM6IDQwMF8wMDApCiAgICAgICAgLy8gSXNzdWUgYW5kIHN0b3JlIGJyaWRnZS1kZWRpY2F0ZWQgUHJvdmlkZXIgQ2FwYWJpbGl0eSBpbiBzdG9yYWdlIGlmIG5lY2Vzc2FyeQogICAgICAgIGlmIHNpZ25lci5zdG9yYWdlLnR5cGUoYXQ6IEZsb3dFVk1CcmlkZ2VDb25maWcucHJvdmlkZXJDYXBhYmlsaXR5U3RvcmFnZVBhdGgpID09IG5pbCB7CiAgICAgICAgICAgIGxldCBwcm92aWRlckNhcCA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+KAogICAgICAgICAgICAgICAgL3N0b3JhZ2UvZmxvd1Rva2VuVmF1bHQKICAgICAgICAgICAgKQogICAgICAgICAgICBzaWduZXIuc3RvcmFnZS5zYXZlKHByb3ZpZGVyQ2FwLCB0bzogRmxvd0VWTUJyaWRnZUNvbmZpZy5wcm92aWRlckNhcGFiaWxpdHlTdG9yYWdlUGF0aCkKICAgICAgICB9CiAgICAgICAgLy8gQ29weSB0aGUgc3RvcmVkIFByb3ZpZGVyIGNhcGFiaWxpdHkgYW5kIGNyZWF0ZSBhIFNjb3BlZEZUUHJvdmlkZXIKICAgICAgICBsZXQgcHJvdmlkZXJDYXBDb3B5ID0gc2lnbmVyLnN0b3JhZ2UuY29weTxDYXBhYmlsaXR5PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntGdW5naWJsZVRva2VuLlByb3ZpZGVyfT4+KAogICAgICAgICAgICAgICAgZnJvbTogRmxvd0VWTUJyaWRnZUNvbmZpZy5wcm92aWRlckNhcGFiaWxpdHlTdG9yYWdlUGF0aAogICAgICAgICAgICApID8/IHBhbmljKCJJbnZhbGlkIFByb3ZpZGVyIENhcGFiaWxpdHkgZm91bmQgaW4gc3RvcmFnZS4iKQogICAgICAgIGxldCBwcm92aWRlckZpbHRlciA9IFNjb3BlZEZUUHJvdmlkZXJzLkFsbG93YW5jZUZpbHRlcihhcHByb3hGZWUpCiAgICAgICAgc2VsZi5zY29wZWRQcm92aWRlciA8LSBTY29wZWRGVFByb3ZpZGVycy5jcmVhdGVTY29wZWRGVFByb3ZpZGVyKAogICAgICAgICAgICAgICAgcHJvdmlkZXI6IHByb3ZpZGVyQ2FwQ29weSwKICAgICAgICAgICAgICAgIGZpbHRlcnM6IFsgcHJvdmlkZXJGaWx0ZXIgXSwKICAgICAgICAgICAgICAgIGV4cGlyYXRpb246IGdldEN1cnJlbnRCbG9jaygpLnRpbWVzdGFtcCArIDEuMAogICAgICAgICAgICApCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgLy8gRXhlY3V0ZSB0aGUgYnJpZGdlIHJlcXVlc3QKICAgICAgICBsZXQgdmF1bHQ6IEB7RnVuZ2libGVUb2tlbi5WYXVsdH0gPC0gc2VsZi5jb2Eud2l0aGRyYXdUb2tlbnMoCiAgICAgICAgICAgIHR5cGU6IHNlbGYudmF1bHRUeXBlLAogICAgICAgICAgICBhbW91bnQ6IGFtb3VudCwKICAgICAgICAgICAgZmVlUHJvdmlkZXI6ICZzZWxmLnNjb3BlZFByb3ZpZGVyIGFzIGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntGdW5naWJsZVRva2VuLlByb3ZpZGVyfQogICAgICAgICkKICAgICAgICAvLyBFbnN1cmUgdGhlIGJyaWRnZWQgdmF1bHQgaXMgdGhlIGNvcnJlY3QgdHlwZQogICAgICAgIGFzc2VydCh2YXVsdC5nZXRUeXBlKCkgPT0gc2VsZi52YXVsdFR5cGUsIG1lc3NhZ2U6ICJCcmlkZ2VkIHZhdWx0IHR5cGUgbWlzbWF0Y2giKQogICAgICAgIC8vIERlcG9zaXQgdGhlIGJyaWRnZWQgdG9rZW4gaW50byB0aGUgc2lnbmVyJ3MgdmF1bHQKICAgICAgICBzZWxmLnJlY2VpdmVyLmRlcG9zaXQoZnJvbTogPC12YXVsdCkKICAgICAgICAvLyBEZXN0cm95IHRoZSBTY29wZWRGVFByb3ZpZGVyCiAgICAgICAgZGVzdHJveSBzZWxmLnNjb3BlZFByb3ZpZGVyCiAgICAgICAgU3RvcmFnZVJlbnQudHJ5UmVmaWxsKHJlY2lwaWVudCkKICAgIH0KfQ\u003d\u003d", - "bridgeTokensFromEvmV2": "// Flow Wallet - testnet Script  bridgeTokensFromEvmV2 - v2.72
// <platform_info>

import MetadataViews from 0x631e88ae7f1d7c20

import ViewResolver from 0x631e88ae7f1d7c20

import NonFungibleToken from 0x631e88ae7f1d7c20


import FungibleToken from 0x9a0766d93b6608b7

import FlowToken from 0x7e60df042a9c0868

import FungibleTokenMetadataViews from 0x9a0766d93b6608b7


import ScopedFTProviders from 0xdfc20aee650fcbdf


import EVM from 0x8c5303eaa26202d6


import FlowEVMBridgeUtils from 0xdfc20aee650fcbdf

import FlowEVMBridge from 0xdfc20aee650fcbdf

import FlowEVMBridgeConfig from 0xdfc20aee650fcbdf


/// This transaction bridges fungible tokens from EVM to Cadence assuming it has already been onboarded to the
/// FlowEVMBridge.
///
/// NOTE: The ERC20 must have first been onboarded to the bridge. This can be checked via the method
///     FlowEVMBridge.evmAddressRequiresOnboarding(address: self.evmContractAddress)
///
/// @param vaultIdentifier: The Cadence type identifier of the FungibleToken Vault to bridge
///     - e.g. vault.getType().identifier
/// @param amount: The amount of tokens to bridge from EVM
///
transaction(vaultIdentifier: String, amount: UInt256) {
    let vaultType: Type
    let receiver: &{FungibleToken.Vault}
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let coa: auth(EVM.Bridge) &EVM.CadenceOwnedAccount

    prepare(signer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        /* --- Construct the Vault type --- */
        //
        // Construct the Vault type from the provided identifier
        self.vaultType = CompositeType(vaultIdentifier)
            ?? panic("Could not construct Vault type from identifier: ".concat(vaultIdentifier))
        // Parse the Vault identifier into its components
        let tokenContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.vaultType)
            ?? panic("Could not get contract address from identifier: ".concat(vaultIdentifier))
        let tokenContractName = FlowEVMBridgeUtils.getContractName(fromType: self.vaultType)
            ?? panic("Could not get contract name from identifier: ".concat(vaultIdentifier))

        /* --- Reference the signer's Vault --- */
        //
        // Borrow a reference to the FungibleToken Vault, configuring if necessary
        let viewResolver = getAccount(tokenContractAddress).contracts.borrow<&{ViewResolver}>(name: tokenContractName)
            ?? panic("Could not borrow ViewResolver from FungibleToken contract")
        let vaultData = viewResolver.resolveContractView(
                resourceType: self.vaultType,
                viewType: Type<FungibleTokenMetadataViews.FTVaultData>()
            ) as! FungibleTokenMetadataViews.FTVaultData? ?? panic("Could not resolve FTVaultData view")
        // If the vault does not exist, create it and publish according to the contract's defined configuration
        if signer.storage.borrow<&{FungibleToken.Vault}>(from: vaultData.storagePath) == nil {
            signer.storage.save(<-vaultData.createEmptyVault(), to: vaultData.storagePath)

            signer.capabilities.unpublish(vaultData.receiverPath)
            signer.capabilities.unpublish(vaultData.metadataPath)

            let receiverCap = signer.capabilities.storage.issue<&{FungibleToken.Vault}>(vaultData.storagePath)
            let metadataCap = signer.capabilities.storage.issue<&{FungibleToken.Vault}>(vaultData.storagePath)

            signer.capabilities.publish(receiverCap, at: vaultData.receiverPath)
            signer.capabilities.publish(metadataCap, at: vaultData.metadataPath)
        }
        self.receiver = signer.storage.borrow<&{FungibleToken.Vault}>(from: vaultData.storagePath)
            ?? panic("Could not borrow Vault from storage path")

        /* --- Configure a ScopedFTProvider --- */
        //
        // Calculate the bridge fee - bridging from EVM consumes no storage, so flat fee
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000)
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    execute {
        // Execute the bridge request
        let vault: @{FungibleToken.Vault} <- self.coa.withdrawTokens(
            type: self.vaultType,
            amount: amount,
            feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        // Ensure the bridged vault is the correct type
        assert(vault.getType() == self.vaultType, message: "Bridged vault type mismatch")
        // Deposit the bridged token into the signer's vault
        self.receiver.deposit(from: <-vault)
        // Destroy the ScopedFTProvider
        destroy self.scopedProvider
    }
}", - "bridgeTokensToEvm": "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", - "bridgeTokensToEvmAddress": "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", - "bridgeTokensToEvmAddressV2": "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\u003d\u003d", - "bridgeTokensToEvmV2": "// Flow Wallet - testnet Script  bridgeTokensToEvmV2 - v2.72
// <platform_info>

import MetadataViews from 0x631e88ae7f1d7c20

import ViewResolver from 0x631e88ae7f1d7c20

import NonFungibleToken from 0x631e88ae7f1d7c20


import FungibleToken from 0x9a0766d93b6608b7

import FlowToken from 0x7e60df042a9c0868

import FungibleTokenMetadataViews from 0x9a0766d93b6608b7


import ScopedFTProviders from 0xdfc20aee650fcbdf


import EVM from 0x8c5303eaa26202d6


import FlowEVMBridgeUtils from 0xdfc20aee650fcbdf

import FlowEVMBridge from 0xdfc20aee650fcbdf

import FlowEVMBridgeConfig from 0xdfc20aee650fcbdf

/// Bridges a Vault from the signer's storage to the signer's COA in EVM.Account.
///
/// NOTE: This transaction also onboards the Vault to the bridge if necessary which may incur additional fees
///     than bridging an asset that has already been onboarded.
///
/// @param vaultIdentifier: The Cadence type identifier of the FungibleToken Vault to bridge
///     - e.g. vault.getType().identifier
/// @param amount: The amount of tokens to bridge from EVM
///
transaction(vaultIdentifier: String, amount: UFix64) {
    let sentVault: @{FungibleToken.Vault}
    let coa: auth(EVM.Bridge) &EVM.CadenceOwnedAccount
    let requiresOnboarding: Bool
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider

    prepare(signer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        /* --- Construct the Vault type --- */
        //
        // Construct the Vault type from the provided identifier
        let vaultType = CompositeType(vaultIdentifier)
            ?? panic("Could not construct Vault type from identifier: ".concat(vaultIdentifier))
        // Parse the Vault identifier into its components
        let tokenContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: vaultType)
            ?? panic("Could not get contract address from identifier: ".concat(vaultIdentifier))
        let tokenContractName = FlowEVMBridgeUtils.getContractName(fromType: vaultType)
            ?? panic("Could not get contract name from identifier: ".concat(vaultIdentifier))

        /* --- Retrieve the funds --- */
        //
        // Borrow a reference to the FungibleToken Vault
        let viewResolver = getAccount(tokenContractAddress).contracts.borrow<&{ViewResolver}>(name: tokenContractName)
            ?? panic("Could not borrow ViewResolver from FungibleToken contract")
        let vaultData = viewResolver.resolveContractView(
                resourceType: vaultType,
                viewType: Type<FungibleTokenMetadataViews.FTVaultData>()
            ) as! FungibleTokenMetadataViews.FTVaultData? ?? panic("Could not resolve FTVaultData view")
        let vault = signer.storage.borrow<auth(FungibleToken.Withdraw) &{FungibleToken.Vault}>(
                from: vaultData.storagePath
            ) ?? panic("Could not access signer's FungibleToken Vault")

        // Withdraw the requested balance & calculate the approximate bridge fee based on storage usage
        let currentStorageUsage = signer.storage.used
        self.sentVault <- vault.withdraw(amount: amount)
        let withdrawnStorageUsage = signer.storage.used
        // Approximate the bridge fee based on the difference in storage usage with some buffer
        var approxFee = FlowEVMBridgeUtils.calculateBridgeFee(
                bytes: currentStorageUsage - withdrawnStorageUsage
            ) * 1.10
        // Determine if the Vault requires onboarding - this impacts the fee required
        self.requiresOnboarding = FlowEVMBridge.typeRequiresOnboarding(self.sentVault.getType())
            ?? panic("Bridge does not support this asset type")
        if self.requiresOnboarding {
            approxFee = approxFee + FlowEVMBridgeConfig.onboardFee
        }

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    pre {
        self.sentVault.getType().identifier == vaultIdentifier:
            "Attempting to send invalid vault type - requested: ".concat(vaultIdentifier)
            .concat(", sending: ").concat(self.sentVault.getType().identifier)
    }

    execute {
        if self.requiresOnboarding {
            // Onboard the Vault to the bridge
            FlowEVMBridge.onboardByType(
                self.sentVault.getType(),
                feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
        }
        // Execute the bridge
        self.coa.depositTokens(
            vault: <-self.sentVault,
            feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        // Destroy the ScopedFTProvider
        destroy self.scopedProvider
    }
}", - "calculateBridgeFee": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY2FsY3VsYXRlQnJpZGdlRmVlIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd0VWTUJyaWRnZVV0aWxzIGZyb20gMHhkZmMyMGFlZTY1MGZjYmRmCgoKLy8vIFJldHVybnMgdGhlIGNhbGN1bGF0ZWQgZmVlIGJhc2VkIG9uIHRoZSBudW1iZXIgb2YgYnl0ZXMgdXNlZCB0byBlc2Nyb3cgYW4gYXNzZXQgcGx1cyB0aGUgYmFzZSBmZWUuCi8vLwovLy8gQHBhcmFtIGJ5dGVzOiBUaGUgbnVtYmVyIG9mIGJ5dGVzIHVzZWQgdG8gZXNjcm93IGFuIGFzc2V0LgovLy8KLy8vIEByZXR1cm4gVGhlIGNhbGN1bGF0ZWQgZmVlIHRvIGJlIHBhaWQgaW4gRmxvd1Rva2VuCi8vLwphY2Nlc3MoYWxsKQpmdW4gbWFpbihieXRlcyB1c2VkOiBVSW50NjQpOiBVRml4NjQgewogICAgcmV0dXJuIEZsb3dFVk1CcmlkZ2VVdGlscy5jYWxjdWxhdGVCcmlkZ2VGZWUoYnl0ZXM6IHVzZWQpCn0K", - "evmAddressRequiresOnboarding": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZXZtQWRkcmVzc1JlcXVpcmVzT25ib2FyZGluZyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTVV0aWxzIGZyb20gMHhkZmMyMGFlZTY1MGZjYmRmCgppbXBvcnQgRmxvd0VWTUJyaWRnZSBmcm9tIDB4ZGZjMjBhZWU2NTBmY2JkZgoKCi8vLyBSZXR1cm5zIHdoZXRoZXIgYSBFVk0gY29udHJhY3QgbmVlZHMgdG8gYmUgb25ib2FyZGVkIHRvIHRoZSBGbG93RVZNQnJpZGdlCi8vLwovLy8gQHBhcmFtIGV2bUFkZHJlc3NIZXg6IFRoZSBoZXgtZW5jb2RlZCBhZGRyZXNzIG9mIHRoZSBFVk0gY29udHJhY3QgYXMgYSBTdHJpbmcgd2l0aG91dCAweCBwcmVmaXgKLy8vCi8vLyBAcmV0dXJuIFdoZXRoZXIgdGhlIGNvbnRyYWN0IHJlcXVpcmVzIG9uYm9hcmRpbmcgdG8gdGhlIEZsb3dFVk1CcmlkZ2UgaWYgdGhlIHR5cGUgaXMgYnJpZGdlYWJsZSwgb3RoZXJ3aXNlIG5pbAovLy8KYWNjZXNzKGFsbCkgZnVuIG1haW4oZXZtQWRkcmVzc0hleDogU3RyaW5nKTogQm9vbD8gewogICAgaWYgbGV0IGFkZHJlc3MgPSBFVk1VdGlscy5nZXRFVk1BZGRyZXNzRnJvbUhleFN0cmluZyhhZGRyZXNzOiBldm1BZGRyZXNzSGV4KSB7CiAgICAgICAgcmV0dXJuIEZsb3dFVk1CcmlkZ2UuZXZtQWRkcmVzc1JlcXVpcmVzT25ib2FyZGluZyhhZGRyZXNzKQogICAgfQogICAgcmV0dXJuIG5pbAp9Cg\u003d\u003d", - "getAssociatedEvmAddress": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QXNzb2NpYXRlZEV2bUFkZHJlc3MgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBFVk0gZnJvbSAweDhjNTMwM2VhYTI2MjAyZDYKCgppbXBvcnQgRVZNVXRpbHMgZnJvbSAweGRmYzIwYWVlNjUwZmNiZGYKCmltcG9ydCBGbG93RVZNQnJpZGdlQ29uZmlnIGZyb20gMHhkZmMyMGFlZTY1MGZjYmRmCgoKLy8vIFJldHVybnMgdGhlIEVWTSBhZGRyZXNzIGFzc29jaWF0ZWQgd2l0aCB0aGUgZ2l2ZW4gQ2FkZW5jZSB0eXBlIChhcyBpdHMgaWRlbnRpZmllciBTdHJpbmcpCi8vLwovLy8gQHBhcmFtIHR5cGVJZGVudGlmaWVyIFRoZSBDYWRlbmNlIHR5cGUgaWRlbnRpZmllciBTdHJpbmcKLy8vCi8vLyBAcmV0dXJuIFRoZSBFVk0gYWRkcmVzcyBhcyBhIGhleCBzdHJpbmcgaWYgdGhlIHR5cGUgaGFzIGFuIGFzc29jaWF0ZWQgRVZNQWRkcmVzcywgb3RoZXJ3aXNlIG5pbAovLy8KYWNjZXNzKGFsbCkKZnVuIG1haW4oaWRlbnRpZmllcjogU3RyaW5nKTogU3RyaW5nPyB7CiAgICBpZiBsZXQgdHlwZSA9IENvbXBvc2l0ZVR5cGUoaWRlbnRpZmllcikgewogICAgICAgIGlmIGxldCBhZGRyZXNzID0gRmxvd0VWTUJyaWRnZUNvbmZpZy5nZXRFVk1BZGRyZXNzQXNzb2NpYXRlZCh3aXRoOiB0eXBlKSB7CiAgICAgICAgICAgIHJldHVybiBFVk1VdGlscy5nZXRFVk1BZGRyZXNzQXNIZXhTdHJpbmcoYWRkcmVzczogYWRkcmVzcykKICAgICAgICB9CiAgICB9CiAgICByZXR1cm4gbmlsCn0\u003d", - "getAssociatedFlowIdentifier": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QXNzb2NpYXRlZEZsb3dJZGVudGlmaWVyIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRVZNIGZyb20gMHg4YzUzMDNlYWEyNjIwMmQ2CgppbXBvcnQgRmxvd0VWTUJyaWRnZUNvbmZpZyBmcm9tIDB4ZGZjMjBhZWU2NTBmY2JkZgoKCmFjY2VzcyhhbGwpCmZ1biBtYWluKGFkZHJlc3M6IFN0cmluZyk6IFN0cmluZz8gewogICAgaWYgbGV0IHR5cGVJbmZvID0gRmxvd0VWTUJyaWRnZUNvbmZpZy5nZXRUeXBlQXNzb2NpYXRlZCh3aXRoOiBFVk0uYWRkcmVzc0Zyb21TdHJpbmcoYWRkcmVzcykpIHsKICAgICAgICByZXR1cm4gdHlwZUluZm8uaWRlbnRpZmllcgogICAgfQogICAgcmV0dXJuIG5pbAp9", - "getBridgeCoaAddress": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QnJpZGdlQ29hQWRkcmVzcyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKCmltcG9ydCBFVk1VdGlscyBmcm9tIDB4ZGZjMjBhZWU2NTBmY2JkZgoKaW1wb3J0IEZsb3dFVk1CcmlkZ2VDb25maWcgZnJvbSAweGRmYzIwYWVlNjUwZmNiZGYKCgovLy8gUmV0dXJucyB0aGUgRVZNIGFkZHJlc3MgYXNzb2NpYXRlZCB3aXRoIHRoZSBGbG93RVZNQnJpZGdlCi8vLwovLy8gQHJldHVybiBUaGUgRVZNIGFkZHJlc3MgYXNzb2NpYXRlZCB3aXRoIHRoZSBGbG93RVZNQnJpZGdlJ3MgY29vcmRpbmF0aW5nIENhZGVuY2VPd25lZEFjY291bnQKLy8vCmFjY2VzcyhhbGwpIGZ1biBtYWluKCk6IFN0cmluZyB7CiAgICBsZXQgYWRkcmVzczogRVZNLkVWTUFkZHJlc3MgPSBGbG93RVZNQnJpZGdlLmdldEJyaWRnZUNPQUVWTUFkZHJlc3MoKQogICAgcmV0dXJuIEVWTVV0aWxzLmdldEVWTUFkZHJlc3NBc0hleFN0cmluZyhhZGRyZXNzOiBhZGRyZXNzKQp9", - "onboardByEvmAddress": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgb25ib2FyZEJ5RXZtQWRkcmVzcyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDdlNjBkZjA0MmE5YzA4NjgKCgppbXBvcnQgU2NvcGVkRlRQcm92aWRlcnMgZnJvbSAweGRmYzIwYWVlNjUwZmNiZGYKCgppbXBvcnQgRVZNIGZyb20gMHg4YzUzMDNlYWEyNjIwMmQ2CgoKaW1wb3J0IEVWTVV0aWxzIGZyb20gMHhkZmMyMGFlZTY1MGZjYmRmCgppbXBvcnQgRmxvd0VWTUJyaWRnZSBmcm9tIDB4ZGZjMjBhZWU2NTBmY2JkZgoKaW1wb3J0IEZsb3dFVk1CcmlkZ2VDb25maWcgZnJvbSAweGRmYzIwYWVlNjUwZmNiZGYKCgovLy8gVGhpcyB0cmFuc2FjdGlvbiBvbmJvYXJkcyB0aGUgTkZUIHR5cGUgdG8gdGhlIGJyaWRnZSwgY29uZmlndXJpbmcgdGhlIGJyaWRnZSB0byBtb3ZlIE5GVHMgYmV0d2VlbiBlbnZpcm9ubWVudHMKLy8vIE5PVEU6IFRoaXMgbXVzdCBiZSBkb25lIGJlZm9yZSBicmlkZ2luZyBhIENhZGVuY2UtbmF0aXZlIE5GVCB0byBFVk0KLy8vCi8vLyBAcGFyYW0gY29udHJhY3RBZGRyZXNzSGV4OiBUaGUgRVZNIGFkZHJlc3Mgb2YgdGhlIGNvbnRyYWN0IChhcyBoZXggc3RyaW5nIHdpdGhvdXQgMHggcHJlZml4KSBkZWZpbmluZyB0aGUgCi8vLyAgICAgYnJpZGdlYWJsZSBhc3NldCB0byBiZSBvbmJvYXJkZWQKLy8vCnRyYW5zYWN0aW9uKGNvbnRyYWN0QWRkcmVzc0hleDogU3RyaW5nKSB7CgogICAgbGV0IGNvbnRyYWN0QWRkcmVzczogRVZNLkVWTUFkZHJlc3MKICAgIGxldCBzY29wZWRQcm92aWRlcjogQFNjb3BlZEZUUHJvdmlkZXJzLlNjb3BlZEZUUHJvdmlkZXIKICAgIAogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoQ29weVZhbHVlLCBCb3Jyb3dWYWx1ZSwgSXNzdWVTdG9yYWdlQ2FwYWJpbGl0eUNvbnRyb2xsZXIsIFB1Ymxpc2hDYXBhYmlsaXR5LCBTYXZlVmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgLyogLS0tIENvbnN0cnVjdCBFVk1BZGRyZXNzIGZyb20gaGV4IHN0cmluZyAobm8gbGVhZGluZyBgIjB4ImApIC0tLSAqLwogICAgICAgIC8vCiAgICAgICAgc2VsZi5jb250cmFjdEFkZHJlc3MgPSBFVk1VdGlscy5nZXRFVk1BZGRyZXNzRnJvbUhleFN0cmluZyhhZGRyZXNzOiBjb250cmFjdEFkZHJlc3NIZXgpCiAgICAgICAgICAgID8/IHBhbmljKCJJbnZhbGlkIEVWTSBhZGRyZXNzIHN0cmluZyBwcm92aWRlZCIpCgogICAgICAgIC8qIC0tLSBDb25maWd1cmUgYSBTY29wZWRGVFByb3ZpZGVyIC0tLSAqLwogICAgICAgIC8vCiAgICAgICAgLy8gSXNzdWUgYW5kIHN0b3JlIGJyaWRnZS1kZWRpY2F0ZWQgUHJvdmlkZXIgQ2FwYWJpbGl0eSBpbiBzdG9yYWdlIGlmIG5lY2Vzc2FyeQogICAgICAgIGlmIHNpZ25lci5zdG9yYWdlLnR5cGUoYXQ6IEZsb3dFVk1CcmlkZ2VDb25maWcucHJvdmlkZXJDYXBhYmlsaXR5U3RvcmFnZVBhdGgpID09IG5pbCB7CiAgICAgICAgICAgIGxldCBwcm92aWRlckNhcCA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+KAogICAgICAgICAgICAgICAgL3N0b3JhZ2UvZmxvd1Rva2VuVmF1bHQKICAgICAgICAgICAgKQogICAgICAgICAgICBzaWduZXIuc3RvcmFnZS5zYXZlKHByb3ZpZGVyQ2FwLCB0bzogRmxvd0VWTUJyaWRnZUNvbmZpZy5wcm92aWRlckNhcGFiaWxpdHlTdG9yYWdlUGF0aCkKICAgICAgICB9CiAgICAgICAgLy8gQ29weSB0aGUgc3RvcmVkIFByb3ZpZGVyIGNhcGFiaWxpdHkgYW5kIGNyZWF0ZSBhIFNjb3BlZEZUUHJvdmlkZXIKICAgICAgICBsZXQgcHJvdmlkZXJDYXBDb3B5ID0gc2lnbmVyLnN0b3JhZ2UuY29weTxDYXBhYmlsaXR5PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntGdW5naWJsZVRva2VuLlByb3ZpZGVyfT4+KAogICAgICAgICAgICAgICAgZnJvbTogRmxvd0VWTUJyaWRnZUNvbmZpZy5wcm92aWRlckNhcGFiaWxpdHlTdG9yYWdlUGF0aAogICAgICAgICAgICApID8/IHBhbmljKCJJbnZhbGlkIFByb3ZpZGVyIENhcGFiaWxpdHkgZm91bmQgaW4gc3RvcmFnZS4iKQogICAgICAgIGxldCBwcm92aWRlckZpbHRlciA9IFNjb3BlZEZUUHJvdmlkZXJzLkFsbG93YW5jZUZpbHRlcihGbG93RVZNQnJpZGdlQ29uZmlnLm9uYm9hcmRGZWUpCiAgICAgICAgc2VsZi5zY29wZWRQcm92aWRlciA8LSBTY29wZWRGVFByb3ZpZGVycy5jcmVhdGVTY29wZWRGVFByb3ZpZGVyKAogICAgICAgICAgICAgICAgcHJvdmlkZXI6IHByb3ZpZGVyQ2FwQ29weSwKICAgICAgICAgICAgICAgIGZpbHRlcnM6IFsgcHJvdmlkZXJGaWx0ZXIgXSwKICAgICAgICAgICAgICAgIGV4cGlyYXRpb246IGdldEN1cnJlbnRCbG9jaygpLnRpbWVzdGFtcCArIDEuMAogICAgICAgICAgICApCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgLy8gT25ib2FyZCB0aGUgRVZNIGNvbnRyYWN0CiAgICAgICAgRmxvd0VWTUJyaWRnZS5vbmJvYXJkQnlFVk1BZGRyZXNzKAogICAgICAgICAgICBzZWxmLmNvbnRyYWN0QWRkcmVzcywKICAgICAgICAgICAgZmVlUHJvdmlkZXI6ICZzZWxmLnNjb3BlZFByb3ZpZGVyIGFzIGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntGdW5naWJsZVRva2VuLlByb3ZpZGVyfQogICAgICAgICkKICAgICAgICBkZXN0cm95IHNlbGYuc2NvcGVkUHJvdmlkZXIKICAgIH0KfQo\u003d", - "onboardByType": "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\u003d\u003d", - "onboardByTypeIdentifier": "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\u003d\u003d", - "typeRequiresOnboarding": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdHlwZVJlcXVpcmVzT25ib2FyZGluZyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dFVk1CcmlkZ2UgZnJvbSAweGRmYzIwYWVlNjUwZmNiZGYKCgovLy8gUmV0dXJucyB3aGV0aGVyIGEgdHlwZSBuZWVkcyB0byBiZSBvbmJvYXJkZWQgdG8gdGhlIEZsb3dFVk1CcmlkZ2UKLy8vCi8vLyBAcGFyYW0gdHlwZTogVGhlIENhZGVuY2UgVHlwZSBpbiBxdWVzdGlvbgovLy8KLy8vIEByZXR1cm4gV2hldGhlciB0aGUgdHlwZSByZXF1aXJlcyBvbmJvYXJkaW5nIHRvIHRoZSBGbG93RVZNQnJpZGdlIGlmIHRoZSB0eXBlIGlzIGJyaWRnZWFibGUsIG90aGVyd2lzZSBuaWwKLy8vCmFjY2VzcyhhbGwpIGZ1biBtYWluKHR5cGU6IFR5cGUpOiBCb29sPyB7CiAgICByZXR1cm4gRmxvd0VWTUJyaWRnZS50eXBlUmVxdWlyZXNPbmJvYXJkaW5nKHR5cGUpCn0K", - "typeRequiresOnboardingByIdentifier": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdHlwZVJlcXVpcmVzT25ib2FyZGluZ0J5SWRlbnRpZmllciAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dFVk1CcmlkZ2UgZnJvbSAweGRmYzIwYWVlNjUwZmNiZGYKCgovLy8gUmV0dXJucyB3aGV0aGVyIGEgdHlwZSBuZWVkcyB0byBiZSBvbmJvYXJkZWQgdG8gdGhlIEZsb3dFVk1CcmlkZ2UKLy8vCi8vLyBAcGFyYW0gaWRlbnRpZmllcjogVGhlIGlkZW50aWZpZXIgb2YgdGhlIENhZGVuY2UgVHlwZSBpbiBxdWVzdGlvbgovLy8KLy8vIEByZXR1cm4gV2hldGhlciB0aGUgdHlwZSByZXF1aXJlcyBvbmJvYXJkaW5nIHRvIHRoZSBGbG93RVZNQnJpZGdlIGlmIHRoZSB0eXBlIGlzIGJyaWRnZWFibGUsIG90aGVyd2lzZSBuaWwKLy8vCmFjY2VzcyhhbGwpIGZ1biBtYWluKGlkZW50aWZpZXI6IFN0cmluZyk6IEJvb2w/IHsKICAgIGlmIGxldCB0eXBlID0gQ29tcG9zaXRlVHlwZShpZGVudGlmaWVyKSB7CiAgICAgICAgcmV0dXJuIEZsb3dFVk1CcmlkZ2UudHlwZVJlcXVpcmVzT25ib2FyZGluZyh0eXBlKQogICAgfQogICAgcmV0dXJuIG5pbAp9Cg\u003d\u003d" + "batchBridgeChildNFTFromEoaWithPayer": "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\u003d\u003d", + "batchBridgeChildNFTFromEvmWithPayer": "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\u003d", + "batchBridgeChildNFTToEvmAddressWithPayer": "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\u003d", + "batchBridgeChildNFTToEvmWithPayer": "// Flow Wallet - testnet Script  batchBridgeChildNFTToEvmWithPayer - v2.78
// <platform_info>

import MetadataViews from 0x631e88ae7f1d7c20

import ViewResolver from 0x631e88ae7f1d7c20

import NonFungibleToken from 0x631e88ae7f1d7c20

import FungibleToken from 0x9a0766d93b6608b7

import FlowToken from 0x7e60df042a9c0868

import FungibleTokenMetadataViews from 0x9a0766d93b6608b7

import ScopedFTProviders from 0xdfc20aee650fcbdf

import EVM from 0x8c5303eaa26202d6

import FlowEVMBridgeUtils from 0xdfc20aee650fcbdf

import FlowEVMBridge from 0xdfc20aee650fcbdf

import FlowEVMBridgeConfig from 0xdfc20aee650fcbdf

import HybridCustody from 0x294e44e1ec6993c6

import CapabilityFilter from 0x294e44e1ec6993c6

import CrossVMMetadataViews from 0x631e88ae7f1d7c20


transaction(nftIdentifier: String, child: Address, ids: [UInt64]) {
    prepare(signer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, Capabilities, SaveValue) &Account, payer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        let coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        let m = signer.storage.borrow<auth(HybridCustody.Manage) &HybridCustody.Manager>(from: HybridCustody.ManagerStoragePath)
            ?? panic("manager does not exist")
        let childAcct = m.borrowAccount(addr: child) ?? panic("child account not found")

         // Construct the NFT type from the provided identifier
        let nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Retrieve the NFT --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        let viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = viewResolver.resolveContractView(
                resourceType: nil,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        var collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            )

        // Create collection if it doesn't exist
        if collection == nil {
            signer.storage.save(<- collectionData.createEmptyCollection(), to: collectionData.storagePath)
            signer.capabilities.unpublish(collectionData.publicPath)
            signer.capabilities.publish(
                signer.capabilities.storage.issue<&{NonFungibleToken.Collection}>(collectionData.storagePath),
                at: collectionData.publicPath
            )

            // Borrow authorized withdraw reference to the signer's collection
            collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            )!
        }

        let capType = Type<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider}>()
        let controllerID = childAcct.getControllerIDForType(type: capType, forPath: collectionData.storagePath)
            ?? panic("no controller found for capType")

        let cap = childAcct.getCapability(controllerID: controllerID, type: capType) ?? panic("no cap found")
        let providerCap = cap as! Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider}>
        assert(providerCap.check(), message: "invalid provider capability")

        let id = ids[0]
        // Get a reference to the child's stored vault
        let collectionRef = providerCap.borrow()!
        let childNft <- collectionRef.withdraw(withdrawID: id)
        collection!.deposit(token: <-childNft)
        // // Withdraw tokens from the signer's stored vault
        let currentStorageUsage = signer.storage.used
        let nft <- collection!.withdraw(withdrawID: id)
        let withdrawnStorageUsage = signer.storage.used
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(
                bytes: 400_000
            ) + (FlowEVMBridgeConfig.baseFee * UFix64(ids.length))

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if payer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = payer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            payer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = payer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        let scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )

        // Execute the bridge
        coa.depositNFT(
            nft: <- nft,
            feeProvider: &scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        var idx = 0
        for nftId in ids {
            if idx == 0 {
                idx = idx + 1
                continue
            }

            let nft <- collectionRef.withdraw(withdrawID: nftId)
            coa.depositNFT(
                nft: <- nft,
                feeProvider: &scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
            idx = idx + 1
        }
        // Destroy the ScopedFTProvider
        destroy scopedProvider

        // Wrap NFTs if applicable
        wrapAndTransferNFTsIfApplicable(coa,
            nftIDs: ids,
            nftType: nftType,
            viewResolver: viewResolver,
            recipientIfNotCoa: nil
        )
    }
}

/// Wraps and transfers bridged NFTs into a project's custom ERC721 wrapper contract on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
/// @param recipientIfNotCoa: The EVM address to transfer the wrapped NFTs to, nil if the NFTs should stay in signer's COA
///
access(all) fun wrapAndTransferNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt64],
    nftType: Type,
    viewResolver: &{ViewResolver},
    recipientIfNotCoa: EVM.EVMAddress?
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            // Wrap NFTs if underlying ERC721 address matches bridge's associated address for NFT type
            if underlyingAddress.equals(FlowEVMBridgeConfig.getEVMAddressAssociated(with: nftType)!) {
                // Approve contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, true]
                )

                // Wrap NFTs with provided IDs, and check if the call was successful
                let res = mustCall(coa, crossVMPointer.evmContractAddress,
                    functionSig: "depositFor(address,uint256[])",
                    args: [coa.address(), nftIDs]
                )
                let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                assert(decodedRes.length == 1, message: "Invalid response length")
                assert(decodedRes[0] as! Bool, message: "Failed to wrap NFTs")

                // Transfer NFTs to recipient if provided
                if let to = recipientIfNotCoa {
                    mustTransferNFTs(coa, crossVMPointer.evmContractAddress, nftIDs: nftIDs, to: to)
                }

                // Revoke approval for contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, false]
                )
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is owned by the provided EVM address
///
access(all) fun isOwner(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    _ nftID: UInt64,
    _ ownerToCheck: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: erc721Address,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )
    assert(res.status == EVM.Status.successful, message: "Call to ERC721.ownerOf(uint256) failed")
    let decodedRes = EVM.decodeABI(types: [Type<EVM.EVMAddress>()], data: res.data)
    if decodedRes.length == 1 {
        let actualOwner = decodedRes[0] as! EVM.EVMAddress
        return actualOwner.equals(ownerToCheck)
    }
    return false
}

/// Transfers NFTs from the provided COA to the provided EVM address
///
access(all) fun mustTransferNFTs(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    nftIDs: [UInt64],
    to: EVM.EVMAddress
) {
    for id in nftIDs {
        assert(isOwner(coa, erc721Address, id, coa.address()), message: "NFT not owned by signer's COA")
        mustCall(coa, erc721Address,
            functionSig: "safeTransferFrom(address,address,uint256)",
            args: [coa.address(), to, id]
        )
        assert(isOwner(coa, erc721Address, id, to), message: "NFT not transferred to recipient")
    }
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}", + "batchBridgeNFTFromEoaToFlowWithPayer": "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\u003d\u003d", + "batchBridgeNFTFromEvm": "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", + "batchBridgeNFTFromEvmToFlow": "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\u003d", + "batchBridgeNFTFromEvmToFlowWithPayer": "// Flow Wallet - testnet Script  batchBridgeNFTFromEvmToFlowWithPayer - v2.78
// <platform_info>

import MetadataViews from 0x631e88ae7f1d7c20

import ViewResolver from 0x631e88ae7f1d7c20

import NonFungibleToken from 0x631e88ae7f1d7c20

import FungibleToken from 0x9a0766d93b6608b7

import FlowToken from 0x7e60df042a9c0868

import FungibleTokenMetadataViews from 0x9a0766d93b6608b7

import ScopedFTProviders from 0xdfc20aee650fcbdf

import EVM from 0x8c5303eaa26202d6

import FlowEVMBridgeUtils from 0xdfc20aee650fcbdf

import FlowEVMBridge from 0xdfc20aee650fcbdf

import FlowEVMBridgeConfig from 0xdfc20aee650fcbdf

import StorageRent from 0xd50084a1a43b1507

import CrossVMMetadataViews from 0x631e88ae7f1d7c20


/// This transaction bridges an NFT from EVM to Cadence assuming it has already been onboarded to the FlowEVMBridge.
/// Also know that the recipient Flow account must have a Receiver capable of receiving the this bridged NFT accessible
/// via published Capability at the token's standard path.
/// NOTE: The ERC721 must have first been onboarded to the bridge. This can be checked via the method
///     FlowEVMBridge.evmAddressRequiresOnboarding(address: self.evmContractAddress)
///
/// @param nftIdentifier: The Cadence type identifier of the NFT to bridge - e.g. nft.getType().identifier
/// @param id: The ERC721 id of the NFT to bridge to Cadence from EVM
/// @param recipient: The Flow account address to receive the bridged NFT
///
transaction(nftIdentifier: String, ids: [UInt256], recipient: Address) {
    let nftType: Type
    let receiver: &{NonFungibleToken.Collection}
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let coa: auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount
    let viewResolver: &{ViewResolver}

    prepare(signer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account, payer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        /* --- Construct the NFT type --- */
        //
        // Construct the NFT type from the provided identifier
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        // Parse the NFT identifier into its components
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: self.nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Reference the recipient's NFT Receiver --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: self.nftType,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        // Configure the signer's account for this NFT
        if signer.storage.borrow<&{NonFungibleToken.Collection}>(from: collectionData.storagePath) == nil {
            signer.storage.save(<-collectionData.createEmptyCollection(), to: collectionData.storagePath)
            signer.capabilities.unpublish(collectionData.publicPath)
            let collectionCap = signer.capabilities.storage.issue<&{NonFungibleToken.Collection}>(collectionData.storagePath)
            signer.capabilities.publish(collectionCap, at: collectionData.publicPath)
        }
                
        self.receiver = getAccount(recipient).capabilities.borrow<&{NonFungibleToken.Collection}>(collectionData.publicPath) ?? panic("Could not borrow Receiver from recipient's public capability path")

        /* --- Configure a ScopedFTProvider --- */
        //
        // Calculate the bridge fee - bridging from EVM consumes no storage, so flat fee
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000) + (FlowEVMBridgeConfig.baseFee * UFix64(ids.length))
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if payer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = payer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            payer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = payer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    execute {
        // Unwrap NFTs from project-defined ERC721 wrapper contract if applicable
        unwrapNFTsIfApplicable(self.coa, nftIDs: ids, nftType: self.nftType, viewResolver: self.viewResolver)

        // Execute the bridge
        var idx = 0
        while idx < ids.length {
            let nftId = ids[idx]!
            // Execute the bridge
            let nft: @{NonFungibleToken.NFT} <- self.coa.withdrawNFT(
                type: self.nftType,
                id: nftId,
                feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
            // Ensure the bridged nft is the correct type
            assert(
                nft.getType() == self.nftType,
                message: "Bridged nft type mismatch - requested: ".concat(self.nftType.identifier)
                    .concat(", received: ").concat(nft.getType().identifier)
            )
            // Deposit the bridged NFT into the recipient's collection
            self.receiver.deposit(token: <-nft)
            idx = idx + 1
        }
        destroy self.scopedProvider

        StorageRent.tryRefill(recipient)

    }
}

/// Unwraps NFTs from a project's custom ERC721 wrapper contract to bridged NFTs on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
///
access(all) fun unwrapNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt256],
    nftType: Type,
    viewResolver: &{ViewResolver}
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            for id in nftIDs {
                // Unwrap NFT if it is wrapped
                if isNFTWrapped(coa,
                    nftID: id,
                    underlying: underlyingAddress,
                    wrapper: crossVMPointer.evmContractAddress
                ) {
                    let res = mustCall(coa, crossVMPointer.evmContractAddress,
                        functionSig: "withdrawTo(address,uint256[])",
                        args: [coa.address(), [id]]
                    )
                    let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                    assert(decodedRes.length == 1, message: "Invalid response length")
                    assert(decodedRes[0] as! Bool, message: "Failed to unwrap NFT")
                }
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is wrapped in the underlying ERC721 contract
///
access(all) fun isNFTWrapped(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftID: UInt256,
    underlying: EVM.EVMAddress,
    wrapper: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: underlying,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return false
    if res.status != EVM.Status.successful || res.data.length == 0{
        return false
    }

    // Decode and compare the addresses
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")

    let owner = decodedResult[0] as! EVM.EVMAddress
    return owner.toString() == wrapper.toString()
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}", + "batchBridgeNFTFromEvmV2": "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\u003d\u003d", + "batchBridgeNFTFromEvmWithPayer": "// Flow Wallet - testnet Script  batchBridgeNFTFromEvmWithPayer - v2.78
// <platform_info>

import MetadataViews from 0x631e88ae7f1d7c20

import ViewResolver from 0x631e88ae7f1d7c20

import NonFungibleToken from 0x631e88ae7f1d7c20

import FungibleToken from 0x9a0766d93b6608b7

import FlowToken from 0x7e60df042a9c0868

import FungibleTokenMetadataViews from 0x9a0766d93b6608b7

import ScopedFTProviders from 0xdfc20aee650fcbdf

import EVM from 0x8c5303eaa26202d6

import FlowEVMBridgeUtils from 0xdfc20aee650fcbdf

import FlowEVMBridge from 0xdfc20aee650fcbdf

import FlowEVMBridgeConfig from 0xdfc20aee650fcbdf

import CrossVMMetadataViews from 0x631e88ae7f1d7c20


/// This transaction bridges an NFT from EVM to Cadence assuming it has already been onboarded to the FlowEVMBridge
/// NOTE: The ERC721 must have first been onboarded to the bridge. This can be checked via the method
///     FlowEVMBridge.evmAddressRequiresOnboarding(address: self.evmContractAddress)
///
/// @param nftIdentifier: The Cadence type identifier of the NFT to bridge - e.g. nft.getType().identifier
/// @param id: The ERC721 id of the NFT to bridge to Cadence from EVM
///
transaction(nftIdentifier: String, ids: [UInt256]) {

    let nftType: Type
    let collection: &{NonFungibleToken.Collection}
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let coa: auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount
    let viewResolver: &{ViewResolver}

    prepare(signer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account, payer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        /* --- Construct the NFT type --- */
        //
        // Construct the NFT type from the provided identifier
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        // Parse the NFT identifier into its components
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: self.nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Reference the signer's NFT Collection --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: self.nftType,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        if signer.storage.borrow<&{NonFungibleToken.Collection}>(from: collectionData.storagePath) == nil {
            signer.storage.save(<-collectionData.createEmptyCollection(), to: collectionData.storagePath)
            signer.capabilities.unpublish(collectionData.publicPath)
            let collectionCap = signer.capabilities.storage.issue<&{NonFungibleToken.Collection}>(collectionData.storagePath)
            signer.capabilities.publish(collectionCap, at: collectionData.publicPath)
        }
        self.collection = signer.storage.borrow<&{NonFungibleToken.Collection}>(from: collectionData.storagePath)
            ?? panic("Could not borrow collection from storage path")

        /* --- Configure a ScopedFTProvider --- */
        //
        // Calculate the bridge fee - bridging from EVM consumes no storage, so flat fee
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000) + (FlowEVMBridgeConfig.baseFee * UFix64(ids.length))
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if payer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = payer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            payer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = payer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
            provider: providerCapCopy,
            filters: [ providerFilter ],
            expiration: getCurrentBlock().timestamp + 1.0
        )
    }

    execute {
        // Unwrap NFTs from project-defined ERC721 wrapper contract if applicable
        unwrapNFTsIfApplicable(self.coa, nftIDs: ids, nftType: self.nftType, viewResolver: self.viewResolver)

        // Execute the bridge
        var idx = 0
        while idx < ids.length {
            let nftId = ids[idx]!
            // Execute the bridge
            let nft: @{NonFungibleToken.NFT} <- self.coa.withdrawNFT(
                type: self.nftType,
                id: nftId,
                feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
            // Ensure the bridged nft is the correct type
            assert(
                nft.getType() == self.nftType,
                message: "Bridged nft type mismatch - requested: ".concat(self.nftType.identifier)
                    .concat(", received: ").concat(nft.getType().identifier)
            )
            // Deposit the bridged NFT into the signer's collection
            self.collection.deposit(token: <-nft)
            idx = idx + 1
        }

        // Destroy the ScopedFTProvider
        destroy self.scopedProvider
    }
}

/// Unwraps NFTs from a project's custom ERC721 wrapper contract to bridged NFTs on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
///
access(all) fun unwrapNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt256],
    nftType: Type,
    viewResolver: &{ViewResolver}
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            for id in nftIDs {
                // Unwrap NFT if it is wrapped
                if isNFTWrapped(coa,
                    nftID: id,
                    underlying: underlyingAddress,
                    wrapper: crossVMPointer.evmContractAddress
                ) {
                    let res = mustCall(coa, crossVMPointer.evmContractAddress,
                        functionSig: "withdrawTo(address,uint256[])",
                        args: [coa.address(), [id]]
                    )
                    let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                    assert(decodedRes.length == 1, message: "Invalid response length")
                    assert(decodedRes[0] as! Bool, message: "Failed to unwrap NFT")
                }
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is wrapped in the underlying ERC721 contract
///
access(all) fun isNFTWrapped(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftID: UInt256,
    underlying: EVM.EVMAddress,
    wrapper: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: underlying,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return false
    if res.status != EVM.Status.successful || res.data.length == 0{
        return false
    }

    // Decode and compare the addresses
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    let owner = decodedResult[0] as! EVM.EVMAddress
    return owner.toString() == wrapper.toString()
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", + "batchBridgeNFTToEvm": "// Flow Wallet - testnet Script  batchBridgeNFTToEvm - v2.78
// <platform_info>

import FungibleToken from 0x9a0766d93b6608b7

import FlowToken from 0x7e60df042a9c0868

import MetadataViews from 0x631e88ae7f1d7c20

import ViewResolver from 0x631e88ae7f1d7c20

import NonFungibleToken from 0x631e88ae7f1d7c20

import ScopedFTProviders from 0xdfc20aee650fcbdf

import EVM from 0x8c5303eaa26202d6

import FlowEVMBridgeUtils from 0xdfc20aee650fcbdf

import FlowEVMBridge from 0xdfc20aee650fcbdf

import FlowEVMBridgeConfig from 0xdfc20aee650fcbdf

import CrossVMMetadataViews from 0x631e88ae7f1d7c20


transaction(nftContractAddress: Address, nftContractName: String, ids: [UInt64]) {

    let nfts: @{UInt64 : {NonFungibleToken.NFT}}
    let coa: auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let nftType: Type
    let viewResolver: &{ViewResolver}

    prepare(signer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account) {

        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        self.nfts <- {}
        /* --- Retrieve the NFT --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        
        // Initialize nftType from the contract
        let nftIdentifier = "A.".concat(nftContractAddress.toString().slice(from: 2, upTo: nftContractAddress.toString().length)).concat(".").concat(nftContractName).concat(".NFT")
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
            
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: nil,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        let collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            ) ?? panic("Could not access signer's NFT Collection")

        // Withdraw the requested NFT & calculate the approximate bridge fee based on NFT storage usage
        let currentStorageUsage = signer.storage.used
        for id in ids {
            let nft <- collection.withdraw(withdrawID: id)
            self.nfts[id] <-! nft
        }
        // self.nft <- collection.withdraw(withdrawID: id)
        let withdrawnStorageUsage = signer.storage.used
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(
                bytes: currentStorageUsage - withdrawnStorageUsage
            ) * 1.10 * UFix64(ids.length)

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    execute {
        // Execute the bridge
        var idx = 0
        while idx < ids.length {
            let nftId = ids[idx]!
            let nft <- self.nfts.remove(key: nftId)! as @{NonFungibleToken.NFT}
            self.coa.depositNFT(
                nft: <- nft!,
                feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
            idx = idx + 1
        }

        // Destroy the ScopedFTProvider
        destroy self.scopedProvider
        destroy self.nfts

        // Wrap NFTs if applicable
        wrapAndTransferNFTsIfApplicable(self.coa,
            nftIDs: ids,
            nftType: self.nftType,
            viewResolver: self.viewResolver,
            recipientIfNotCoa: nil
        )
    }
}

/// Wraps and transfers bridged NFTs into a project's custom ERC721 wrapper contract on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
/// @param recipientIfNotCoa: The EVM address to transfer the wrapped NFTs to, nil if the NFTs should stay in signer's COA
///
access(all) fun wrapAndTransferNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt64],
    nftType: Type,
    viewResolver: &{ViewResolver},
    recipientIfNotCoa: EVM.EVMAddress?
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            // Wrap NFTs if underlying ERC721 address matches bridge's associated address for NFT type
            if underlyingAddress.equals(FlowEVMBridgeConfig.getEVMAddressAssociated(with: nftType)!) {
                // Approve contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, true]
                )

                // Wrap NFTs with provided IDs, and check if the call was successful
                let res = mustCall(coa, crossVMPointer.evmContractAddress,
                    functionSig: "depositFor(address,uint256[])",
                    args: [coa.address(), nftIDs]
                )
                let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                assert(decodedRes.length == 1, message: "Invalid response length")
                assert(decodedRes[0] as! Bool, message: "Failed to wrap NFTs")

                // Transfer NFTs to recipient if provided
                if let to = recipientIfNotCoa {
                    mustTransferNFTs(coa, crossVMPointer.evmContractAddress, nftIDs: nftIDs, to: to)
                }

                // Revoke approval for contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, false]
                )
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is owned by the provided EVM address
///
access(all) fun isOwner(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    _ nftID: UInt64,
    _ ownerToCheck: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: erc721Address,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )
    assert(res.status == EVM.Status.successful, message: "Call to ERC721.ownerOf(uint256) failed")
    let decodedRes = EVM.decodeABI(types: [Type<EVM.EVMAddress>()], data: res.data)
    if decodedRes.length == 1 {
        let actualOwner = decodedRes[0] as! EVM.EVMAddress
        return actualOwner.equals(ownerToCheck)
    }
    return false
}

/// Transfers NFTs from the provided COA to the provided EVM address
///
access(all) fun mustTransferNFTs(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    nftIDs: [UInt64],
    to: EVM.EVMAddress
) {
    for id in nftIDs {
        assert(isOwner(coa, erc721Address, id, coa.address()), message: "NFT not owned by signer's COA")
        mustCall(coa, erc721Address,
            functionSig: "safeTransferFrom(address,address,uint256)",
            args: [coa.address(), to, id]
        )
        assert(isOwner(coa, erc721Address, id, to), message: "NFT not transferred to recipient")
    }
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", + "batchBridgeNFTToEvmAddress": "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\u003d", + "batchBridgeNFTToEvmAddressWithPayer": "// Flow Wallet - testnet Script  batchBridgeNFTToEvmAddressWithPayer - v2.78
// <platform_info>

import MetadataViews from 0x631e88ae7f1d7c20

import ViewResolver from 0x631e88ae7f1d7c20

import NonFungibleToken from 0x631e88ae7f1d7c20

import FungibleToken from 0x9a0766d93b6608b7

import FlowToken from 0x7e60df042a9c0868

import FungibleTokenMetadataViews from 0x9a0766d93b6608b7

import ScopedFTProviders from 0xdfc20aee650fcbdf

import EVM from 0x8c5303eaa26202d6

import FlowEVMBridgeUtils from 0xdfc20aee650fcbdf

import FlowEVMBridge from 0xdfc20aee650fcbdf

import FlowEVMBridgeConfig from 0xdfc20aee650fcbdf

import CrossVMMetadataViews from 0x631e88ae7f1d7c20


/// Bridges an NFT from the signer's collection in Cadence to the signer's COA in FlowEVM
///
/// NOTE: This transaction also onboards the NFT to the bridge if necessary which may incur additional fees
///     than bridging an asset that has already been onboarded.
///
/// @param nftIdentifier: The Cadence type identifier of the NFT to bridge - e.g. nft.getType().identifier
/// @param id: The Cadence NFT.id of the NFT to bridge to EVM
///
transaction(nftIdentifier: String, ids: [UInt64], recipient: String) {
    let nft: @{NonFungibleToken.NFT}
    let requiresOnboarding: Bool
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let collection: auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}
    let nftType: Type
    let coa: auth(EVM.Call) &EVM.CadenceOwnedAccount
    let viewResolver: &{ViewResolver}

    prepare(signer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account, payer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account) {
        // Retrieve or create COA
        if let coa = signer.storage.borrow<auth(EVM.Call) &EVM.CadenceOwnedAccount>(from: /storage/evm) {
            self.coa = coa
        } else {
            signer.storage.save<@EVM.CadenceOwnedAccount>(<- EVM.createCadenceOwnedAccount(), to: /storage/evm)
            signer.capabilities.publish(
                signer.capabilities.storage.issue<&EVM.CadenceOwnedAccount>(/storage/evm),
                at: /public/evm
            )
            self.coa = signer.storage.borrow<auth(EVM.Call) &EVM.CadenceOwnedAccount>(from: /storage/evm)!
        }

        /* --- Construct the NFT type --- */
        //
        // Construct the NFT type from the provided identifier
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        // Parse the NFT identifier into its components
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: self.nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Retrieve the NFT --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: nil,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        self.collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            ) ?? panic("Could not access signer's NFT Collection")

        // Withdraw the requested NFT & calculate the approximate bridge fee based on NFT storage usage
        let currentStorageUsage = signer.storage.used
        self.nft <- self.collection.withdraw(withdrawID: ids[0])
        let withdrawnStorageUsage = signer.storage.used
        var approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000) + (FlowEVMBridgeConfig.baseFee * UFix64(ids.length))

        // Determine if the NFT requires onboarding - this impacts the fee required
        self.requiresOnboarding = FlowEVMBridge.typeRequiresOnboarding(self.nft.getType())
            ?? panic("Bridge does not support this asset type")
        if self.requiresOnboarding {
            approxFee = approxFee + FlowEVMBridgeConfig.onboardFee
        }

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if payer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = payer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            payer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = payer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    pre {
        self.nft.getType().identifier == nftIdentifier:
            "Attempting to send invalid nft type - requested: ".concat(nftIdentifier)
            .concat(", sending: ").concat(self.nft.getType().identifier)
    }

    execute {
        if self.requiresOnboarding {
            // Onboard the NFT to the bridge
            FlowEVMBridge.onboardByType(
                self.nft.getType(),
                feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
        }
        // Execute the bridge transaction
        self.coa.depositNFT(
            nft: <- self.nft,
            feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )

        var idx = 0
        for id in ids {
            if idx == 0 {
                idx = idx + 1
                continue
            }

            self.coa.depositNFT(
                nft: <- self.collection.withdraw(withdrawID: id),
                feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
        }

        // Destroy the ScopedFTProvider
        destroy self.scopedProvider

        // Wrap NFTs if applicable
        wrapAndTransferNFTsIfApplicable(self.coa,
            nftIDs: ids,
            nftType: self.nftType,
            viewResolver: self.viewResolver,
            recipientIfNotCoa: EVM.addressFromString(recipient)
        )
    }
}

/// Wraps and transfers bridged NFTs into a project's custom ERC721 wrapper contract on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
/// @param recipientIfNotCoa: The EVM address to transfer the wrapped NFTs to, nil if the NFTs should stay in signer's COA
///
access(all) fun wrapAndTransferNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt64],
    nftType: Type,
    viewResolver: &{ViewResolver},
    recipientIfNotCoa: EVM.EVMAddress?
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            // Wrap NFTs if underlying ERC721 address matches bridge's associated address for NFT type

            if underlyingAddress.equals(FlowEVMBridgeConfig.getEVMAddressAssociated(with: nftType)!) {
                // Approve contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, true]
                )

                // Wrap NFTs with provided IDs, and check if the call was successful
                let res = mustCall(coa, crossVMPointer.evmContractAddress,
                    functionSig: "depositFor(address,uint256[])",
                    args: [coa.address(), nftIDs]
                )
                let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                assert(decodedRes.length == 1, message: "Invalid response length")
                assert(decodedRes[0] as! Bool, message: "Failed to wrap NFTs")

                // Transfer NFTs to recipient if provided
                if let to = recipientIfNotCoa {
                    mustTransferNFTs(coa, crossVMPointer.evmContractAddress, nftIDs: nftIDs, to: to)
                }

                // Revoke approval for contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, false]
                )
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is owned by the provided EVM address
///
access(all) fun isOwner(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    _ nftID: UInt64,
    _ ownerToCheck: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: erc721Address,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )
    assert(res.status == EVM.Status.successful, message: "Call to ERC721.ownerOf(uint256) failed")
    let decodedRes = EVM.decodeABI(types: [Type<EVM.EVMAddress>()], data: res.data)
    if decodedRes.length == 1 {
        let actualOwner = decodedRes[0] as! EVM.EVMAddress
        return actualOwner.equals(ownerToCheck)
    }
    return false
}

/// Transfers NFTs from the provided COA to the provided EVM address
///
access(all) fun mustTransferNFTs(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    nftIDs: [UInt64],
    to: EVM.EVMAddress
) {
    for id in nftIDs {
        assert(isOwner(coa, erc721Address, id, coa.address()), message: "NFT not owned by signer's COA")
        mustCall(coa, erc721Address,
            functionSig: "safeTransferFrom(address,address,uint256)",
            args: [coa.address(), to, id]
        )
        assert(isOwner(coa, erc721Address, id, to), message: "NFT not transferred to recipient")
    }
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", + "batchBridgeNFTToEvmV2": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYmF0Y2hCcmlkZ2VORlRUb0V2bVYyIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgoKaW1wb3J0IENyb3NzVk1NZXRhZGF0YVZpZXdzIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgppbXBvcnQgTWV0YWRhdGFWaWV3cyBmcm9tIDB4NjMxZTg4YWU3ZjFkN2MyMAoKaW1wb3J0IFZpZXdSZXNvbHZlciBmcm9tIDB4NjMxZTg4YWU3ZjFkN2MyMAoKaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHg3ZTYwZGYwNDJhOWMwODY4CgppbXBvcnQgRnVuZ2libGVUb2tlbk1ldGFkYXRhVmlld3MgZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCmltcG9ydCBTY29wZWRGVFByb3ZpZGVycyBmcm9tIDB4ZGZjMjBhZWU2NTBmY2JkZgoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKaW1wb3J0IEZsb3dFVk1CcmlkZ2VVdGlscyBmcm9tIDB4ZGZjMjBhZWU2NTBmY2JkZgoKaW1wb3J0IEZsb3dFVk1CcmlkZ2UgZnJvbSAweGRmYzIwYWVlNjUwZmNiZGYKCmltcG9ydCBGbG93RVZNQnJpZGdlQ29uZmlnIGZyb20gMHhkZmMyMGFlZTY1MGZjYmRmCgoKLy8vIEJyaWRnZXMgYW4gTkZUIGZyb20gdGhlIHNpZ25lcidzIGNvbGxlY3Rpb24gaW4gQ2FkZW5jZSB0byB0aGUgc2lnbmVyJ3MgQ09BIGluIEZsb3dFVk0KLy8vCi8vLyBOT1RFOiBUaGlzIHRyYW5zYWN0aW9uIGFsc28gb25ib2FyZHMgdGhlIE5GVCB0byB0aGUgYnJpZGdlIGlmIG5lY2Vzc2FyeSB3aGljaCBtYXkgaW5jdXIgYWRkaXRpb25hbCBmZWVzCi8vLyAgICAgdGhhbiBicmlkZ2luZyBhbiBhc3NldCB0aGF0IGhhcyBhbHJlYWR5IGJlZW4gb25ib2FyZGVkLgovLy8KLy8vIEBwYXJhbSBuZnRJZGVudGlmaWVyOiBUaGUgQ2FkZW5jZSB0eXBlIGlkZW50aWZpZXIgb2YgdGhlIE5GVCB0byBicmlkZ2UgLSBlLmcuIG5mdC5nZXRUeXBlKCkuaWRlbnRpZmllcgovLy8gQHBhcmFtIGlkczogVGhlIENhZGVuY2UgaWRzIG9mIHRoZSBORlRzIHRvIGJyaWRnZSB0byBFVk0KLy8vCnRyYW5zYWN0aW9uKG5mdElkZW50aWZpZXI6IFN0cmluZywgaWRzOiBbVUludDY0XSkgewoKICAgIGxldCBjb2E6IGF1dGgoRVZNLkNhbGwsIEVWTS5CcmlkZ2UpICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudAogICAgbGV0IHJlcXVpcmVzT25ib2FyZGluZzogQm9vbAogICAgbGV0IG5mdFR5cGU6IFR5cGUKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChDb3B5VmFsdWUsIEJvcnJvd1ZhbHVlLCBJc3N1ZVN0b3JhZ2VDYXBhYmlsaXR5Q29udHJvbGxlciwgUHVibGlzaENhcGFiaWxpdHksIFNhdmVWYWx1ZSkgJkFjY291bnQpIHsKICAgICAgICAvKiAtLS0gUmVmZXJlbmNlIHRoZSBzaWduZXIncyBDYWRlbmNlT3duZWRBY2NvdW50IC0tLSAqLwogICAgICAgIC8vCiAgICAgICAgLy8gQm9ycm93IGEgcmVmZXJlbmNlIHRvIHRoZSBzaWduZXIncyBDT0EKICAgICAgICBzZWxmLmNvYSA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEVWTS5DYWxsLCBFVk0uQnJpZGdlKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KGZyb206IC9zdG9yYWdlL2V2bSkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgQ09BIGZyb20gcHJvdmlkZWQgZ2F0ZXdheSBhZGRyZXNzIikKCiAgICAgICAgLyogLS0tIENvbnN0cnVjdCB0aGUgTkZUIHR5cGUgLS0tICovCiAgICAgICAgLy8KICAgICAgICAvLyBDb25zdHJ1Y3QgdGhlIE5GVCB0eXBlIGZyb20gdGhlIHByb3ZpZGVkIGlkZW50aWZpZXIKICAgICAgICBzZWxmLm5mdFR5cGUgPSBDb21wb3NpdGVUeXBlKG5mdElkZW50aWZpZXIpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgY29uc3RydWN0IE5GVCB0eXBlIGZyb20gaWRlbnRpZmllcjogIi5jb25jYXQobmZ0SWRlbnRpZmllcikpCiAgICAgICAgLy8gUGFyc2UgdGhlIE5GVCBpZGVudGlmaWVyIGludG8gaXRzIGNvbXBvbmVudHMKICAgICAgICBsZXQgbmZ0Q29udHJhY3RBZGRyZXNzID0gRmxvd0VWTUJyaWRnZVV0aWxzLmdldENvbnRyYWN0QWRkcmVzcyhmcm9tVHlwZTogc2VsZi5uZnRUeXBlKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGdldCBjb250cmFjdCBhZGRyZXNzIGZyb20gaWRlbnRpZmllcjogIi5jb25jYXQobmZ0SWRlbnRpZmllcikpCiAgICAgICAgbGV0IG5mdENvbnRyYWN0TmFtZSA9IEZsb3dFVk1CcmlkZ2VVdGlscy5nZXRDb250cmFjdE5hbWUoZnJvbVR5cGU6IHNlbGYubmZ0VHlwZSkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBnZXQgY29udHJhY3QgbmFtZSBmcm9tIGlkZW50aWZpZXI6ICIuY29uY2F0KG5mdElkZW50aWZpZXIpKQoKICAgICAgICAvKiAtLS0gUmV0cmlldmUgdGhlIE5GVCAtLS0gKi8KICAgICAgICAvLwogICAgICAgIC8vIEJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgTkZUIGNvbGxlY3Rpb24sIGNvbmZpZ3VyaW5nIGlmIG5lY2Vzc2FyeQogICAgICAgIGxldCB2aWV3UmVzb2x2ZXIgPSBnZXRBY2NvdW50KG5mdENvbnRyYWN0QWRkcmVzcykuY29udHJhY3RzLmJvcnJvdzwme1ZpZXdSZXNvbHZlcn0+KG5hbWU6IG5mdENvbnRyYWN0TmFtZSkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgVmlld1Jlc29sdmVyIGZyb20gTkZUIGNvbnRyYWN0IikKICAgICAgICBsZXQgY29sbGVjdGlvbkRhdGEgPSB2aWV3UmVzb2x2ZXIucmVzb2x2ZUNvbnRyYWN0VmlldygKICAgICAgICAgICAgICAgIHJlc291cmNlVHlwZTogc2VsZi5uZnRUeXBlLAogICAgICAgICAgICAgICAgdmlld1R5cGU6IFR5cGU8TWV0YWRhdGFWaWV3cy5ORlRDb2xsZWN0aW9uRGF0YT4oKQogICAgICAgICAgICApIGFzISBNZXRhZGF0YVZpZXdzLk5GVENvbGxlY3Rpb25EYXRhPyA/PyBwYW5pYygiQ291bGQgbm90IHJlc29sdmUgTkZUQ29sbGVjdGlvbkRhdGEgdmlldyIpCiAgICAgICAgbGV0IGNvbGxlY3Rpb24gPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChOb25GdW5naWJsZVRva2VuLldpdGhkcmF3KSAme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0+KAogICAgICAgICAgICAgICAgZnJvbTogY29sbGVjdGlvbkRhdGEuc3RvcmFnZVBhdGgKICAgICAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGFjY2VzcyBzaWduZXIncyBORlQgQ29sbGVjdGlvbiIpCgogICAgICAgIC8vIFdpdGhkcmF3IHRoZSByZXF1ZXN0ZWQgTkZUICYgY2FsY3VsYXRlIHRoZSBhcHByb3hpbWF0ZSBicmlkZ2UgZmVlIGJhc2VkIG9uIE5GVCBzdG9yYWdlIHVzYWdlCiAgICAgICAgbGV0IGN1cnJlbnRTdG9yYWdlVXNhZ2UgPSBzaWduZXIuc3RvcmFnZS51c2VkCiAgICAgICAgbGV0IG5mdCA8LSBjb2xsZWN0aW9uLndpdGhkcmF3KHdpdGhkcmF3SUQ6IGlkc1swXSkKICAgICAgICBsZXQgd2l0aGRyYXduU3RvcmFnZVVzYWdlID0gc2lnbmVyLnN0b3JhZ2UudXNlZAogICAgICAgIHZhciBhcHByb3hGZWUgPSBGbG93RVZNQnJpZGdlVXRpbHMuY2FsY3VsYXRlQnJpZGdlRmVlKGJ5dGVzOiA0MDBfMDAwKSArIChGbG93RVZNQnJpZGdlQ29uZmlnLmJhc2VGZWUgKiBVRml4NjQoaWRzLmxlbmd0aCkpCiAgICAgICAgLy8gRGV0ZXJtaW5lIGlmIHRoZSBORlQgcmVxdWlyZXMgb25ib2FyZGluZyAtIHRoaXMgaW1wYWN0cyB0aGUgZmVlIHJlcXVpcmVkCiAgICAgICAgc2VsZi5yZXF1aXJlc09uYm9hcmRpbmcgPSBGbG93RVZNQnJpZGdlLnR5cGVSZXF1aXJlc09uYm9hcmRpbmcoc2VsZi5uZnRUeXBlKQogICAgICAgICAgICA/PyBwYW5pYygiQnJpZGdlIGRvZXMgbm90IHN1cHBvcnQgdGhpcyBhc3NldCB0eXBlIikKICAgICAgICBpZiBzZWxmLnJlcXVpcmVzT25ib2FyZGluZyB7CiAgICAgICAgICAgIGFwcHJveEZlZSA9IGFwcHJveEZlZSArIEZsb3dFVk1CcmlkZ2VDb25maWcub25ib2FyZEZlZQogICAgICAgIH0KCiAgICAgICAgLyogLS0tIENvbmZpZ3VyZSBhIFNjb3BlZEZUUHJvdmlkZXIgLS0tICovCiAgICAgICAgLy8KICAgICAgICAvLyBJc3N1ZSBhbmQgc3RvcmUgYnJpZGdlLWRlZGljYXRlZCBQcm92aWRlciBDYXBhYmlsaXR5IGluIHN0b3JhZ2UgaWYgbmVjZXNzYXJ5CiAgICAgICAgaWYgc2lnbmVyLnN0b3JhZ2UudHlwZShhdDogRmxvd0VWTUJyaWRnZUNvbmZpZy5wcm92aWRlckNhcGFiaWxpdHlTdG9yYWdlUGF0aCkgPT0gbmlsIHsKICAgICAgICAgICAgbGV0IHByb3ZpZGVyQ2FwID0gc2lnbmVyLmNhcGFiaWxpdGllcy5zdG9yYWdlLmlzc3VlPGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntGdW5naWJsZVRva2VuLlByb3ZpZGVyfT4oCiAgICAgICAgICAgICAgICAvc3RvcmFnZS9mbG93VG9rZW5WYXVsdAogICAgICAgICAgICApCiAgICAgICAgICAgIHNpZ25lci5zdG9yYWdlLnNhdmUocHJvdmlkZXJDYXAsIHRvOiBGbG93RVZNQnJpZGdlQ29uZmlnLnByb3ZpZGVyQ2FwYWJpbGl0eVN0b3JhZ2VQYXRoKQogICAgICAgIH0KICAgICAgICAvLyBDb3B5IHRoZSBzdG9yZWQgUHJvdmlkZXIgY2FwYWJpbGl0eSBhbmQgY3JlYXRlIGEgU2NvcGVkRlRQcm92aWRlcgogICAgICAgIGxldCBwcm92aWRlckNhcENvcHkgPSBzaWduZXIuc3RvcmFnZS5jb3B5PENhcGFiaWxpdHk8YXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAme0Z1bmdpYmxlVG9rZW4uUHJvdmlkZXJ9Pj4oCiAgICAgICAgICAgICAgICBmcm9tOiBGbG93RVZNQnJpZGdlQ29uZmlnLnByb3ZpZGVyQ2FwYWJpbGl0eVN0b3JhZ2VQYXRoCiAgICAgICAgICAgICkgPz8gcGFuaWMoIkludmFsaWQgUHJvdmlkZXIgQ2FwYWJpbGl0eSBmb3VuZCBpbiBzdG9yYWdlLiIpCiAgICAgICAgbGV0IHByb3ZpZGVyRmlsdGVyID0gU2NvcGVkRlRQcm92aWRlcnMuQWxsb3dhbmNlRmlsdGVyKGFwcHJveEZlZSkKICAgICAgICBsZXQgc2NvcGVkUHJvdmlkZXIgPC0gU2NvcGVkRlRQcm92aWRlcnMuY3JlYXRlU2NvcGVkRlRQcm92aWRlcigKICAgICAgICAgICAgICAgIHByb3ZpZGVyOiBwcm92aWRlckNhcENvcHksCiAgICAgICAgICAgICAgICBmaWx0ZXJzOiBbIHByb3ZpZGVyRmlsdGVyIF0sCiAgICAgICAgICAgICAgICBleHBpcmF0aW9uOiBnZXRDdXJyZW50QmxvY2soKS50aW1lc3RhbXAgKyAxLjAKICAgICAgICApCiAgICAgICAgc2VsZi5jb2EuZGVwb3NpdE5GVCgKICAgICAgICAgICAgbmZ0OiA8LSBuZnQsCiAgICAgICAgICAgIGZlZVByb3ZpZGVyOiAmc2NvcGVkUHJvdmlkZXIgYXMgYXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAme0Z1bmdpYmxlVG9rZW4uUHJvdmlkZXJ9CiAgICAgICAgKQoKICAgICAgICB2YXIgaWR4ID0gMAogICAgICAgIHdoaWxlIGlkeCA8IGlkcy5sZW5ndGggewogICAgICAgICAgICBpZiBpZHggPT0gMCB7CiAgICAgICAgICAgICAgICBpZHggPSBpZHggKyAxCiAgICAgICAgICAgICAgICBjb250aW51ZQogICAgICAgICAgICB9CiAgICAgICAgICAgIGxldCBuZnRJZCA9IGlkc1tpZHhdIQogICAgICAgICAgICBsZXQgbmZ0IDwtIGNvbGxlY3Rpb24ud2l0aGRyYXcod2l0aGRyYXdJRDogbmZ0SWQpISBhcyBAe05vbkZ1bmdpYmxlVG9rZW4uTkZUfQogICAgICAgICAgICBzZWxmLmNvYS5kZXBvc2l0TkZUKAogICAgICAgICAgICAgICAgbmZ0OiA8LSBuZnQsCiAgICAgICAgICAgICAgICBmZWVQcm92aWRlcjogJnNjb3BlZFByb3ZpZGVyIGFzIGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntGdW5naWJsZVRva2VuLlByb3ZpZGVyfQogICAgICAgICAgICApCiAgICAgICAgICAgIGlkeCA9IGlkeCArIDEKICAgICAgICB9CgogICAgICAgIC8vIERlc3Ryb3kgdGhlIFNjb3BlZEZUUHJvdmlkZXIKICAgICAgICBkZXN0cm95IHNjb3BlZFByb3ZpZGVyCgogICAgICAgIC8vIFdyYXAgTkZUcyBpZiBhcHBsaWNhYmxlCiAgICAgICAgd3JhcEFuZFRyYW5zZmVyTkZUc0lmQXBwbGljYWJsZShzZWxmLmNvYSwKICAgICAgICAgICAgbmZ0SURzOiBpZHMsCiAgICAgICAgICAgIG5mdFR5cGU6IHNlbGYubmZ0VHlwZSwKICAgICAgICAgICAgdmlld1Jlc29sdmVyOiB2aWV3UmVzb2x2ZXIsCiAgICAgICAgICAgIHJlY2lwaWVudElmTm90Q29hOiBuaWwKICAgICAgICApCiAgICB9Cn0KCi8vLyBXcmFwcyBhbmQgdHJhbnNmZXJzIGJyaWRnZWQgTkZUcyBpbnRvIGEgcHJvamVjdCdzIGN1c3RvbSBFUkM3MjEgd3JhcHBlciBjb250cmFjdCBvbiBFVk0sIGlmIGFwcGxpY2FibGUuCi8vLyBFbmFibGVzIHByb2plY3RzIHRvIHVzZSB0aGVpciBvd24gRVJDNzIxIGNvbnRyYWN0IHdoaWxlIGxldmVyYWdpbmcgdGhlIGJyaWRnZSdzIHVuZGVybHlpbmcgY29udHJhY3QsCi8vLyB1bnRpbCBkaXJlY3QgY3VzdG9tIGNvbnRyYWN0IHN1cHBvcnQgaXMgYWRkZWQgdG8gdGhlIGJyaWRnZS4KLy8vCi8vLyBAcGFyYW0gY29hOiBUaGUgQ09BIG9mIHRoZSBzaWduZXIKLy8vIEBwYXJhbSBuZnRJRHM6IFRoZSBJRHMgb2YgdGhlIE5GVHMgdG8gd3JhcAovLy8gQHBhcmFtIG5mdFR5cGU6IFRoZSB0eXBlIG9mIHRoZSBORlRzIHRvIHdyYXAKLy8vIEBwYXJhbSB2aWV3UmVzb2x2ZXI6IFRoZSBWaWV3UmVzb2x2ZXIgb2YgdGhlIE5GVCBjb250cmFjdAovLy8gQHBhcmFtIHJlY2lwaWVudElmTm90Q29hOiBUaGUgRVZNIGFkZHJlc3MgdG8gdHJhbnNmZXIgdGhlIHdyYXBwZWQgTkZUcyB0bywgbmlsIGlmIHRoZSBORlRzIHNob3VsZCBzdGF5IGluIHNpZ25lcidzIENPQQovLy8KYWNjZXNzKGFsbCkgZnVuIHdyYXBBbmRUcmFuc2Zlck5GVHNJZkFwcGxpY2FibGUoCiAgICBfIGNvYTogYXV0aChFVk0uQ2FsbCkgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50LAogICAgbmZ0SURzOiBbVUludDY0XSwKICAgIG5mdFR5cGU6IFR5cGUsCiAgICB2aWV3UmVzb2x2ZXI6ICZ7Vmlld1Jlc29sdmVyfSwKICAgIHJlY2lwaWVudElmTm90Q29hOiBFVk0uRVZNQWRkcmVzcz8KKSB7CiAgICAvLyBHZXQgdGhlIHByb2plY3QtZGVmaW5lZCBFUkM3MjEgYWRkcmVzcyBpZiBpdCBleGlzdHMKICAgIGlmIGxldCBjcm9zc1ZNUG9pbnRlciA9IHZpZXdSZXNvbHZlci5yZXNvbHZlQ29udHJhY3RWaWV3KAogICAgICAgICAgICByZXNvdXJjZVR5cGU6IG5mdFR5cGUsCiAgICAgICAgICAgIHZpZXdUeXBlOiBUeXBlPENyb3NzVk1NZXRhZGF0YVZpZXdzLkVWTVBvaW50ZXI+KCkKICAgICkgYXMhIENyb3NzVk1NZXRhZGF0YVZpZXdzLkVWTVBvaW50ZXI/IHsKICAgICAgICAvLyBHZXQgdGhlIHVuZGVybHlpbmcgRVJDNzIxIGFkZHJlc3MgaWYgaXQgZXhpc3RzCiAgICAgICAgaWYgbGV0IHVuZGVybHlpbmdBZGRyZXNzID0gZ2V0VW5kZXJseWluZ0VSQzcyMUFkZHJlc3MoY29hLCBjcm9zc1ZNUG9pbnRlci5ldm1Db250cmFjdEFkZHJlc3MpIHsKICAgICAgICAgICAgLy8gV3JhcCBORlRzIGlmIHVuZGVybHlpbmcgRVJDNzIxIGFkZHJlc3MgbWF0Y2hlcyBicmlkZ2UncyBhc3NvY2lhdGVkIGFkZHJlc3MgZm9yIE5GVCB0eXBlCiAgICAgICAgICAgIGlmIHVuZGVybHlpbmdBZGRyZXNzLmVxdWFscyhGbG93RVZNQnJpZGdlQ29uZmlnLmdldEVWTUFkZHJlc3NBc3NvY2lhdGVkKHdpdGg6IG5mdFR5cGUpISkgewogICAgICAgICAgICAgICAgLy8gQXBwcm92ZSBjb250cmFjdCB0byB3aXRoZHJhdyB1bmRlcmx5aW5nIE5GVHMgZnJvbSBzaWduZXIncyBjb2EKICAgICAgICAgICAgICAgIG11c3RDYWxsKGNvYSwgdW5kZXJseWluZ0FkZHJlc3MsCiAgICAgICAgICAgICAgICAgICAgZnVuY3Rpb25TaWc6ICJzZXRBcHByb3ZhbEZvckFsbChhZGRyZXNzLGJvb2wpIiwKICAgICAgICAgICAgICAgICAgICBhcmdzOiBbY3Jvc3NWTVBvaW50ZXIuZXZtQ29udHJhY3RBZGRyZXNzLCB0cnVlXQogICAgICAgICAgICAgICAgKQoKICAgICAgICAgICAgICAgIC8vIFdyYXAgTkZUcyB3aXRoIHByb3ZpZGVkIElEcywgYW5kIGNoZWNrIGlmIHRoZSBjYWxsIHdhcyBzdWNjZXNzZnVsCiAgICAgICAgICAgICAgICBsZXQgcmVzID0gbXVzdENhbGwoY29hLCBjcm9zc1ZNUG9pbnRlci5ldm1Db250cmFjdEFkZHJlc3MsCiAgICAgICAgICAgICAgICAgICAgZnVuY3Rpb25TaWc6ICJkZXBvc2l0Rm9yKGFkZHJlc3MsdWludDI1NltdKSIsCiAgICAgICAgICAgICAgICAgICAgYXJnczogW2NvYS5hZGRyZXNzKCksIG5mdElEc10KICAgICAgICAgICAgICAgICkKICAgICAgICAgICAgICAgIGxldCBkZWNvZGVkUmVzID0gRVZNLmRlY29kZUFCSSh0eXBlczogW1R5cGU8Qm9vbD4oKV0sIGRhdGE6IHJlcy5kYXRhKQogICAgICAgICAgICAgICAgYXNzZXJ0KGRlY29kZWRSZXMubGVuZ3RoID09IDEsIG1lc3NhZ2U6ICJJbnZhbGlkIHJlc3BvbnNlIGxlbmd0aCIpCiAgICAgICAgICAgICAgICBhc3NlcnQoZGVjb2RlZFJlc1swXSBhcyEgQm9vbCwgbWVzc2FnZTogIkZhaWxlZCB0byB3cmFwIE5GVHMiKQoKICAgICAgICAgICAgICAgIC8vIFRyYW5zZmVyIE5GVHMgdG8gcmVjaXBpZW50IGlmIHByb3ZpZGVkCiAgICAgICAgICAgICAgICBpZiBsZXQgdG8gPSByZWNpcGllbnRJZk5vdENvYSB7CiAgICAgICAgICAgICAgICAgICAgbXVzdFRyYW5zZmVyTkZUcyhjb2EsIGNyb3NzVk1Qb2ludGVyLmV2bUNvbnRyYWN0QWRkcmVzcywgbmZ0SURzOiBuZnRJRHMsIHRvOiB0bykKICAgICAgICAgICAgICAgIH0KCiAgICAgICAgICAgICAgICAvLyBSZXZva2UgYXBwcm92YWwgZm9yIGNvbnRyYWN0IHRvIHdpdGhkcmF3IHVuZGVybHlpbmcgTkZUcyBmcm9tIHNpZ25lcidzIGNvYQogICAgICAgICAgICAgICAgbXVzdENhbGwoY29hLCB1bmRlcmx5aW5nQWRkcmVzcywKICAgICAgICAgICAgICAgICAgICBmdW5jdGlvblNpZzogInNldEFwcHJvdmFsRm9yQWxsKGFkZHJlc3MsYm9vbCkiLAogICAgICAgICAgICAgICAgICAgIGFyZ3M6IFtjcm9zc1ZNUG9pbnRlci5ldm1Db250cmFjdEFkZHJlc3MsIGZhbHNlXQogICAgICAgICAgICAgICAgKQogICAgICAgICAgICB9CiAgICAgICAgfQogICAgfQp9CgovLy8gR2V0cyB0aGUgdW5kZXJseWluZyBFUkM3MjEgYWRkcmVzcyBpZiBpdCBleGlzdHMgKGkuZS4gaWYgdGhlIEVSQzcyMSBpcyBhIHdyYXBwZXIpCi8vLwphY2Nlc3MoYWxsKSBmdW4gZ2V0VW5kZXJseWluZ0VSQzcyMUFkZHJlc3MoCiAgICBfIGNvYTogYXV0aChFVk0uQ2FsbCkgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50LAogICAgXyB3cmFwcGVyQWRkcmVzczogRVZNLkVWTUFkZHJlc3MKKTogRVZNLkVWTUFkZHJlc3M/IHsKICAgIGxldCByZXMgPSBjb2EuY2FsbCgKICAgICAgICB0bzogd3JhcHBlckFkZHJlc3MsCiAgICAgICAgZGF0YTogRVZNLmVuY29kZUFCSVdpdGhTaWduYXR1cmUoInVuZGVybHlpbmcoKSIsIFtdKSwKICAgICAgICBnYXNMaW1pdDogMTAwXzAwMCwKICAgICAgICB2YWx1ZTogRVZNLkJhbGFuY2UoYXR0b2Zsb3c6IDApCiAgICApCgogICAgLy8gSWYgdGhlIGNhbGwgZmFpbHMsIHJldHVybiBuaWwKICAgIGlmIHJlcy5zdGF0dXMgIT0gRVZNLlN0YXR1cy5zdWNjZXNzZnVsIHx8IHJlcy5kYXRhLmxlbmd0aCA9PSAwIHsKICAgICAgICByZXR1cm4gbmlsCiAgICB9CgogICAgLy8gRGVjb2RlIGFuZCByZXR1cm4gdGhlIHVuZGVybHlpbmcgRVJDNzIxIGFkZHJlc3MKICAgIGxldCBkZWNvZGVkUmVzdWx0ID0gRVZNLmRlY29kZUFCSSgKICAgICAgICB0eXBlczogW1R5cGU8RVZNLkVWTUFkZHJlc3M+KCldLAogICAgICAgIGRhdGE6IHJlcy5kYXRhCiAgICApCiAgICBhc3NlcnQoZGVjb2RlZFJlc3VsdC5sZW5ndGggPT0gMSwgbWVzc2FnZTogIkludmFsaWQgcmVzcG9uc2UgbGVuZ3RoIikKICAgIHJldHVybiBkZWNvZGVkUmVzdWx0WzBdIGFzISBFVk0uRVZNQWRkcmVzcwp9CgovLy8gQ2hlY2tzIGlmIHRoZSBwcm92aWRlZCBORlQgaXMgb3duZWQgYnkgdGhlIHByb3ZpZGVkIEVWTSBhZGRyZXNzCi8vLwphY2Nlc3MoYWxsKSBmdW4gaXNPd25lcigKICAgIF8gY29hOiBhdXRoKEVWTS5DYWxsKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQsCiAgICBfIGVyYzcyMUFkZHJlc3M6IEVWTS5FVk1BZGRyZXNzLAogICAgXyBuZnRJRDogVUludDY0LAogICAgXyBvd25lclRvQ2hlY2s6IEVWTS5FVk1BZGRyZXNzCik6IEJvb2wgewogICAgbGV0IHJlcyA9IGNvYS5jYWxsKAogICAgICAgIHRvOiBlcmM3MjFBZGRyZXNzLAogICAgICAgIGRhdGE6IEVWTS5lbmNvZGVBQklXaXRoU2lnbmF0dXJlKCJvd25lck9mKHVpbnQyNTYpIiwgW25mdElEXSksCiAgICAgICAgZ2FzTGltaXQ6IDEwMF8wMDAsCiAgICAgICAgdmFsdWU6IEVWTS5CYWxhbmNlKGF0dG9mbG93OiAwKQogICAgKQogICAgYXNzZXJ0KHJlcy5zdGF0dXMgPT0gRVZNLlN0YXR1cy5zdWNjZXNzZnVsLCBtZXNzYWdlOiAiQ2FsbCB0byBFUkM3MjEub3duZXJPZih1aW50MjU2KSBmYWlsZWQiKQogICAgbGV0IGRlY29kZWRSZXMgPSBFVk0uZGVjb2RlQUJJKHR5cGVzOiBbVHlwZTxFVk0uRVZNQWRkcmVzcz4oKV0sIGRhdGE6IHJlcy5kYXRhKQogICAgaWYgZGVjb2RlZFJlcy5sZW5ndGggPT0gMSB7CiAgICAgICAgbGV0IGFjdHVhbE93bmVyID0gZGVjb2RlZFJlc1swXSBhcyEgRVZNLkVWTUFkZHJlc3MKICAgICAgICByZXR1cm4gYWN0dWFsT3duZXIuZXF1YWxzKG93bmVyVG9DaGVjaykKICAgIH0KICAgIHJldHVybiBmYWxzZQp9CgovLy8gVHJhbnNmZXJzIE5GVHMgZnJvbSB0aGUgcHJvdmlkZWQgQ09BIHRvIHRoZSBwcm92aWRlZCBFVk0gYWRkcmVzcwovLy8KYWNjZXNzKGFsbCkgZnVuIG11c3RUcmFuc2Zlck5GVHMoCiAgICBfIGNvYTogYXV0aChFVk0uQ2FsbCkgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50LAogICAgXyBlcmM3MjFBZGRyZXNzOiBFVk0uRVZNQWRkcmVzcywKICAgIG5mdElEczogW1VJbnQ2NF0sCiAgICB0bzogRVZNLkVWTUFkZHJlc3MKKSB7CiAgICBmb3IgaWQgaW4gbmZ0SURzIHsKICAgICAgICBhc3NlcnQoaXNPd25lcihjb2EsIGVyYzcyMUFkZHJlc3MsIGlkLCBjb2EuYWRkcmVzcygpKSwgbWVzc2FnZTogIk5GVCBub3Qgb3duZWQgYnkgc2lnbmVyJ3MgQ09BIikKICAgICAgICBtdXN0Q2FsbChjb2EsIGVyYzcyMUFkZHJlc3MsCiAgICAgICAgICAgIGZ1bmN0aW9uU2lnOiAic2FmZVRyYW5zZmVyRnJvbShhZGRyZXNzLGFkZHJlc3MsdWludDI1NikiLAogICAgICAgICAgICBhcmdzOiBbY29hLmFkZHJlc3MoKSwgdG8sIGlkXQogICAgICAgICkKICAgICAgICBhc3NlcnQoaXNPd25lcihjb2EsIGVyYzcyMUFkZHJlc3MsIGlkLCB0byksIG1lc3NhZ2U6ICJORlQgbm90IHRyYW5zZmVycmVkIHRvIHJlY2lwaWVudCIpCiAgICB9Cn0KCi8vLyBDYWxscyBhIGZ1bmN0aW9uIG9uIGFuIEVWTSBjb250cmFjdCBmcm9tIHByb3ZpZGVkIGNvYQovLy8KYWNjZXNzKGFsbCkgZnVuIG11c3RDYWxsKAogICAgXyBjb2E6IGF1dGgoRVZNLkNhbGwpICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudCwKICAgIF8gY29udHJhY3RBZGRyOiBFVk0uRVZNQWRkcmVzcywKICAgIGZ1bmN0aW9uU2lnOiBTdHJpbmcsCiAgICBhcmdzOiBbQW55U3RydWN0XQopOiBFVk0uUmVzdWx0IHsKICAgIGxldCByZXMgPSBjb2EuY2FsbCgKICAgICAgICB0bzogY29udHJhY3RBZGRyLAogICAgICAgIGRhdGE6IEVWTS5lbmNvZGVBQklXaXRoU2lnbmF0dXJlKGZ1bmN0aW9uU2lnLCBhcmdzKSwKICAgICAgICBnYXNMaW1pdDogNF8wMDBfMDAwLAogICAgICAgIHZhbHVlOiBFVk0uQmFsYW5jZShhdHRvZmxvdzogMCkKICAgICkKCiAgICBhc3NlcnQocmVzLnN0YXR1cyA9PSBFVk0uU3RhdHVzLnN1Y2Nlc3NmdWwsCiAgICAgICAgbWVzc2FnZTogIkZhaWxlZCB0byBjYWxsICciLmNvbmNhdChmdW5jdGlvblNpZykKICAgICAgICAgICAgLmNvbmNhdCgiXG5cdCBlcnJvciBjb2RlOiAiKS5jb25jYXQocmVzLmVycm9yQ29kZS50b1N0cmluZygpKQogICAgICAgICAgICAuY29uY2F0KCJcblx0IGVycm9yIG1lc3NhZ2U6ICIpLmNvbmNhdChyZXMuZXJyb3JNZXNzYWdlKQogICAgICAgICAgICAuY29uY2F0KCJcblx0IGdhcyB1c2VkOiAiKS5jb25jYXQocmVzLmdhc1VzZWQudG9TdHJpbmcoKSkKICAgICAgICAgICAgLmNvbmNhdCgiXG5cdCBjYWxsZXIgYWRkcmVzczogMHgiKS5jb25jYXQoY29hLmFkZHJlc3MoKS50b1N0cmluZygpKQogICAgICAgICAgICAuY29uY2F0KCJcblx0IGNvbnRyYWN0IGFkZHJlc3M6IDB4IikuY29uY2F0KGNvbnRyYWN0QWRkci50b1N0cmluZygpKQogICAgKQoKICAgIHJldHVybiByZXMKfQo\u003d", + "batchBridgeNFTToEvmWithPayer": "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\u003d\u003d", + "batchEvmAddressRequiresOnboarding": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYmF0Y2hFdm1BZGRyZXNzUmVxdWlyZXNPbmJvYXJkaW5nIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRVZNIGZyb20gMHg4YzUzMDNlYWEyNjIwMmQ2CgppbXBvcnQgRmxvd0VWTUJyaWRnZSBmcm9tIDB4ZGZjMjBhZWU2NTBmY2JkZgoKCi8vLyBSZXR1cm5zIHdoZXRoZXIgYSBFVk0gY29udHJhY3QgbmVlZHMgdG8gYmUgb25ib2FyZGVkIHRvIHRoZSBGbG93RVZNQnJpZGdlCi8vLwovLy8gQHBhcmFtIGV2bUFkZHJlc3NlczogQXJyYXkgb2YgaGV4LWVuY29kZWQgYWRkcmVzcyBvZiB0aGUgRVZNIGNvbnRyYWN0IGFzIGEgU3RyaW5nIHdpdGhvdXQgMHggcHJlZml4IHRvIGNoZWNrIGZvcgovLy8gICAgIG9uYm9hcmRpbmcgc3RhdHVzCi8vLwovLy8gQHJldHVybiBXaGV0aGVyIHRoZSBjb250cmFjdCByZXF1aXJlcyBvbmJvYXJkaW5nIHRvIHRoZSBGbG93RVZNQnJpZGdlIGlmIHRoZSB0eXBlIGlzIGJyaWRnZWFibGUsIG90aGVyd2lzZSBuaWwKLy8vICAgICBpbmRleGVkIG9uIHRoZSBoZXgtZW5jb2RlZCBhZGRyZXNzIG9mIHRoZSBFVk0gY29udHJhY3Qgd2l0aG91dCAweCBwcmVmaXgKLy8vCmFjY2VzcyhhbGwpIGZ1biBtYWluKGV2bUFkZHJlc3NlczogW1N0cmluZ10pOiB7U3RyaW5nOiBCb29sP30gewogICAgbGV0IHJlc3VsdHM6IHtTdHJpbmc6IEJvb2w/fSA9IHt9CiAgICBmb3IgYWRkcmVzc0hleCBpbiBldm1BZGRyZXNzZXMgewogICAgICAgIGlmIHJlc3VsdHNbYWRkcmVzc0hleF0gIT0gbmlsIHsKICAgICAgICAgICAgY29udGludWUKICAgICAgICB9CiAgICAgICAgbGV0IGFkZHJlc3MgPSBFVk0uYWRkcmVzc0Zyb21TdHJpbmcoYWRkcmVzc0hleCkKICAgICAgICBsZXQgcmVxdWlyZXNPbmJvYXJkaW5nID0gRmxvd0VWTUJyaWRnZS5ldm1BZGRyZXNzUmVxdWlyZXNPbmJvYXJkaW5nKGFkZHJlc3MpCiAgICAgICAgcmVzdWx0cy5pbnNlcnQoa2V5OiBhZGRyZXNzSGV4LCByZXF1aXJlc09uYm9hcmRpbmcpCiAgICB9CiAgICByZXR1cm4gcmVzdWx0cwp9Cg\u003d\u003d", + "batchIdentifierRequiresOnboarding": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYmF0Y2hJZGVudGlmaWVyUmVxdWlyZXNPbmJvYXJkaW5nIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd0VWTUJyaWRnZSBmcm9tIDB4ZGZjMjBhZWU2NTBmY2JkZgoKCi8vLyBSZXR1cm5zIHdoZXRoZXIgYSB0eXBlIG5lZWRzIHRvIGJlIG9uYm9hcmRlZCB0byB0aGUgRmxvd0VWTUJyaWRnZQovLy8KLy8vIEBwYXJhbSBUeXBlczogVGhlIGFycmF5IG9mIHR5cGVzIHRvIGNoZWNrIGZvciBvbmJvYXJkaW5nIHN0YXR1cwovLy8KLy8vIEByZXR1cm4gV2hldGhlciB0aGUgdHlwZSByZXF1aXJlcyBvbmJvYXJkaW5nIHRvIHRoZSBGbG93RVZNQnJpZGdlIGlmIHRoZSB0eXBlIGlzIGJyaWRnZWFibGUsIG90aGVyd2lzZSBuaWwgaW5kZXhlZAovLy8gICAgIG9uIHRoZSB0eXBlCi8vLwphY2Nlc3MoYWxsKSBmdW4gbWFpbihpZGVudGlmaWVyczogW1N0cmluZ10pOiB7U3RyaW5nOiBCb29sP30gewogICAgbGV0IHJlc3VsdHM6IHtTdHJpbmc6IEJvb2w/fSA9IHt9CgogICAgZm9yIGlkZW50aWZpZXIgaW4gaWRlbnRpZmllcnMgewogICAgICAgIGlmIHJlc3VsdHNbaWRlbnRpZmllcl0gIT0gbmlsIHsKICAgICAgICAgICAgY29udGludWUKICAgICAgICB9CiAgICAgICAgbGV0IHR5cGU6IFR5cGUgPSBDb21wb3NpdGVUeXBlKGlkZW50aWZpZXIpID8/IHBhbmljKCJJbnZhbGlkIHR5cGUgaWRlbnRpZmllciIpCiAgICAgICAgcmVzdWx0cy5pbnNlcnQoa2V5OiBpZGVudGlmaWVyLCBGbG93RVZNQnJpZGdlLnR5cGVSZXF1aXJlc09uYm9hcmRpbmcodHlwZSkpCiAgICB9CiAgICByZXR1cm4gcmVzdWx0cwp9Cg\u003d\u003d", + "batchOnboardByEvmAddress": "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", + "batchOnboardByIdentifier": "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\u003d", + "batchOnboardByType": "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\u003d\u003d", + "batchTypeRequiresOnboarding": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYmF0Y2hUeXBlUmVxdWlyZXNPbmJvYXJkaW5nIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd0VWTUJyaWRnZSBmcm9tIDB4ZGZjMjBhZWU2NTBmY2JkZgoKCi8vLyBSZXR1cm5zIHdoZXRoZXIgYSB0eXBlIG5lZWRzIHRvIGJlIG9uYm9hcmRlZCB0byB0aGUgRmxvd0VWTUJyaWRnZQovLy8KLy8vIEBwYXJhbSBUeXBlczogVGhlIGFycmF5IG9mIHR5cGVzIHRvIGNoZWNrIGZvciBvbmJvYXJkaW5nIHN0YXR1cwovLy8KLy8vIEByZXR1cm4gV2hldGhlciB0aGUgdHlwZSByZXF1aXJlcyBvbmJvYXJkaW5nIHRvIHRoZSBGbG93RVZNQnJpZGdlIGlmIHRoZSB0eXBlIGlzIGJyaWRnZWFibGUsIG90aGVyd2lzZSBuaWwgaW5kZXhlZAovLy8gICAgIG9uIHRoZSB0eXBlCi8vLwphY2Nlc3MoYWxsKSBmdW4gbWFpbih0eXBlczogW1R5cGVdKToge1R5cGU6IEJvb2w/fSB7CiAgICBsZXQgcmVzdWx0czoge1R5cGU6IEJvb2w/fSA9IHt9CiAgICBmb3IgdHlwZSBpbiB0eXBlcyB7CiAgICAgICAgaWYgcmVzdWx0c1t0eXBlXSAhPSBuaWwgewogICAgICAgICAgICBjb250aW51ZQogICAgICAgIH0KICAgICAgICByZXN1bHRzLmluc2VydChrZXk6IHR5cGUsIEZsb3dFVk1CcmlkZ2UudHlwZVJlcXVpcmVzT25ib2FyZGluZyh0eXBlKSkKICAgIH0KICAgIHJldHVybiByZXN1bHRzCn0K", + "bridgeNFTFromEvm": "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\u003d", + "bridgeNFTFromEvmToFlow": "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\u003d", + "bridgeNFTFromEvmToFlowV2": "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\u003d\u003d", + "bridgeNFTFromEvmToFlowV3": "// Flow Wallet - testnet Script  bridgeNFTFromEvmToFlowV3 - v2.78
// <platform_info>

import MetadataViews from 0x631e88ae7f1d7c20

import ViewResolver from 0x631e88ae7f1d7c20

import NonFungibleToken from 0x631e88ae7f1d7c20

import FungibleToken from 0x9a0766d93b6608b7

import FlowToken from 0x7e60df042a9c0868

import FungibleTokenMetadataViews from 0x9a0766d93b6608b7

import ScopedFTProviders from 0xdfc20aee650fcbdf

import EVM from 0x8c5303eaa26202d6

import FlowEVMBridgeUtils from 0xdfc20aee650fcbdf

import FlowEVMBridge from 0xdfc20aee650fcbdf

import FlowEVMBridgeConfig from 0xdfc20aee650fcbdf

import StorageRent from 0xd50084a1a43b1507

import CrossVMMetadataViews from 0x631e88ae7f1d7c20


/// This transaction bridges an NFT from EVM to Cadence assuming it has already been onboarded to the FlowEVMBridge.
/// Also know that the recipient Flow account must have a Receiver capable of receiving the this bridged NFT accessible
/// via published Capability at the token's standard path.
/// NOTE: The ERC721 must have first been onboarded to the bridge. This can be checked via the method
///     FlowEVMBridge.evmAddressRequiresOnboarding(address: self.evmContractAddress)
///
/// @param nftIdentifier: The Cadence type identifier of the NFT to bridge - e.g. nft.getType().identifier
/// @param id: The ERC721 id of the NFT to bridge to Cadence from EVM
/// @param recipient: The Flow account address to receive the bridged NFT
///
transaction(nftIdentifier: String, id: UInt256, recipient: Address) {
    let nftType: Type
    let receiver: &{NonFungibleToken.Receiver}
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let coa: auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount
    let viewResolver: &{ViewResolver}

    prepare(signer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        /* --- Construct the NFT type --- */
        //
        // Construct the NFT type from the provided identifier
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        // Parse the NFT identifier into its components
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: self.nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Reference the recipient's NFT Receiver --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: self.nftType,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        // Configure the signer's account for this NFT
        if signer.storage.borrow<&{NonFungibleToken.Collection}>(from: collectionData.storagePath) == nil {
            signer.storage.save(<-collectionData.createEmptyCollection(), to: collectionData.storagePath)
            signer.capabilities.unpublish(collectionData.publicPath)
            let collectionCap = signer.capabilities.storage.issue<&{NonFungibleToken.Collection}>(collectionData.storagePath)
            signer.capabilities.publish(collectionCap, at: collectionData.publicPath)
        }
        self.receiver = getAccount(recipient).capabilities.borrow<&{NonFungibleToken.Receiver}>(collectionData.publicPath)
            ?? panic("Could not borrow Receiver from recipient's public capability path")

        /* --- Configure a ScopedFTProvider --- */
        //
        // Calculate the bridge fee - bridging from EVM consumes no storage, so flat fee
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000)
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    execute {
        // Unwrap NFTs from project-defined ERC721 wrapper contract if applicable
        unwrapNFTsIfApplicable(self.coa, nftIDs: [id], nftType: self.nftType, viewResolver: self.viewResolver)

        // Execute the bridge
        let nft: @{NonFungibleToken.NFT} <- self.coa.withdrawNFT(
            type: self.nftType,
            id: id,
            feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        // Ensure the bridged nft is the correct type
        assert(
            nft.getType() == self.nftType,
            message: "Bridged nft type mismatch - requested: ".concat(self.nftType.identifier)
                .concat(", received: ").concat(nft.getType().identifier)
        )
        // Deposit the bridged NFT into the signer's collection
        self.receiver.deposit(token: <-nft)
        // Destroy the ScopedFTProvider
        destroy self.scopedProvider
        StorageRent.tryRefill(recipient)

    }
}

/// Unwraps NFTs from a project's custom ERC721 wrapper contract to bridged NFTs on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
///
access(all) fun unwrapNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt256],
    nftType: Type,
    viewResolver: &{ViewResolver}
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            for id in nftIDs {
                // Unwrap NFT if it is wrapped
                if isNFTWrapped(coa,
                    nftID: id,
                    underlying: underlyingAddress,
                    wrapper: crossVMPointer.evmContractAddress
                ) {
                    let res = mustCall(coa, crossVMPointer.evmContractAddress,
                        functionSig: "withdrawTo(address,uint256[])",
                        args: [coa.address(), [id]]
                    )
                    let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                    assert(decodedRes.length == 1, message: "Invalid response length")
                    assert(decodedRes[0] as! Bool, message: "Failed to unwrap NFT")
                }
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is wrapped in the underlying ERC721 contract
///
access(all) fun isNFTWrapped(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftID: UInt256,
    underlying: EVM.EVMAddress,
    wrapper: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: underlying,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return false
    if res.status != EVM.Status.successful || res.data.length == 0{
        return false
    }

    // Decode and compare the addresses
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")

    let owner = decodedResult[0] as! EVM.EVMAddress
    return owner.toString() == wrapper.toString()
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", + "bridgeNFTFromEvmToFlowWithPayer": "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\u003d\u003d", + "bridgeNFTFromEvmV2": "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\u003d", + "bridgeNFTFromEvmWithPayer": "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\u003d\u003d", + "bridgeNFTToEvm": "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\u003d", + "bridgeNFTToEvmAddress": "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\u003d", + "bridgeNFTToEvmAddressV2": "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\u003d", + "bridgeNFTToEvmAddressWithPayer": "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\u003d\u003d", + "bridgeNFTToEvmV2": "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\u003d\u003d", + "bridgeNFTToEvmWithPayer": "// Flow Wallet - testnet Script  bridgeNFTToEvmWithPayer - v2.78
// <platform_info>

import MetadataViews from 0x631e88ae7f1d7c20

import ViewResolver from 0x631e88ae7f1d7c20

import NonFungibleToken from 0x631e88ae7f1d7c20

import FungibleToken from 0x9a0766d93b6608b7

import FlowToken from 0x7e60df042a9c0868

import FungibleTokenMetadataViews from 0x9a0766d93b6608b7

import ScopedFTProviders from 0xdfc20aee650fcbdf

import EVM from 0x8c5303eaa26202d6

import FlowEVMBridgeUtils from 0xdfc20aee650fcbdf

import FlowEVMBridge from 0xdfc20aee650fcbdf

import FlowEVMBridgeConfig from 0xdfc20aee650fcbdf

import CrossVMMetadataViews from 0x631e88ae7f1d7c20


/// Bridges an NFT from the signer's collection in Cadence to the signer's COA in FlowEVM
///
/// NOTE: This transaction also onboards the NFT to the bridge if necessary which may incur additional fees
///     than bridging an asset that has already been onboarded.
///
/// @param nftIdentifier: The Cadence type identifier of the NFT to bridge - e.g. nft.getType().identifier
/// @param id: The Cadence NFT.id of the NFT to bridge to EVM
///
transaction(nftIdentifier: String, id: UInt64) {

    let nft: @{NonFungibleToken.NFT}
    let coa: auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount
    let requiresOnboarding: Bool
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let nftType: Type
    let viewResolver: &{ViewResolver}

    prepare(signer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account, payer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        /* --- Construct the NFT type --- */
        //
        // Construct the NFT type from the provided identifier
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        // Parse the NFT identifier into its components
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: self.nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Retrieve the NFT --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: self.nftType,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        let collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            ) ?? panic("Could not access signer's NFT Collection")

        // Withdraw the requested NFT & calculate the approximate bridge fee based on NFT storage usage
        let currentStorageUsage = signer.storage.used
        self.nft <- collection.withdraw(withdrawID: id)
        let withdrawnStorageUsage = signer.storage.used
        var approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000) + FlowEVMBridgeConfig.baseFee
        // Determine if the NFT requires onboarding - this impacts the fee required
        self.requiresOnboarding = FlowEVMBridge.typeRequiresOnboarding(self.nft.getType())
            ?? panic("Bridge does not support this asset type")
        if self.requiresOnboarding {
            approxFee = approxFee + FlowEVMBridgeConfig.onboardFee
        }

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if payer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = payer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            payer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = payer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    pre {
        self.nft.getType().identifier == nftIdentifier:
            "Attempting to send invalid nft type - requested: ".concat(nftIdentifier)
            .concat(", sending: ").concat(self.nft.getType().identifier)
    }

    execute {
        if self.requiresOnboarding {
            // Onboard the NFT to the bridge
            FlowEVMBridge.onboardByType(
                self.nft.getType(),
                feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
        }

        // Execute the bridge
        self.coa.depositNFT(
            nft: <-self.nft,
            feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        // Destroy the ScopedFTProvider
        destroy self.scopedProvider

        // Wrap NFTs if applicable
        wrapAndTransferNFTsIfApplicable(self.coa,
            nftIDs: [id],
            nftType: self.nftType,
            viewResolver: self.viewResolver,
            recipientIfNotCoa: nil
        )
    }
}

/// Wraps and transfers bridged NFTs into a project's custom ERC721 wrapper contract on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
/// @param recipientIfNotCoa: The EVM address to transfer the wrapped NFTs to, nil if the NFTs should stay in signer's COA
///
access(all) fun wrapAndTransferNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt64],
    nftType: Type,
    viewResolver: &{ViewResolver},
    recipientIfNotCoa: EVM.EVMAddress?
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            // Wrap NFTs if underlying ERC721 address matches bridge's associated address for NFT type
            if underlyingAddress.equals(FlowEVMBridgeConfig.getEVMAddressAssociated(with: nftType)!) {
                // Approve contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, true]
                )

                // Wrap NFTs with provided IDs, and check if the call was successful
                let res = mustCall(coa, crossVMPointer.evmContractAddress,
                    functionSig: "depositFor(address,uint256[])",
                    args: [coa.address(), nftIDs]
                )
                let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                assert(decodedRes.length == 1, message: "Invalid response length")
                assert(decodedRes[0] as! Bool, message: "Failed to wrap NFTs")

                // Transfer NFTs to recipient if provided
                if let to = recipientIfNotCoa {
                    mustTransferNFTs(coa, crossVMPointer.evmContractAddress, nftIDs: nftIDs, to: to)
                }

                // Revoke approval for contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, false]
                )
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is owned by the provided EVM address
///
access(all) fun isOwner(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    _ nftID: UInt64,
    _ ownerToCheck: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: erc721Address,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )
    assert(res.status == EVM.Status.successful, message: "Call to ERC721.ownerOf(uint256) failed")
    let decodedRes = EVM.decodeABI(types: [Type<EVM.EVMAddress>()], data: res.data)
    if decodedRes.length == 1 {
        let actualOwner = decodedRes[0] as! EVM.EVMAddress
        return actualOwner.equals(ownerToCheck)
    }
    return false
}

/// Transfers NFTs from the provided COA to the provided EVM address
///
access(all) fun mustTransferNFTs(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    nftIDs: [UInt64],
    to: EVM.EVMAddress
) {
    for id in nftIDs {
        assert(isOwner(coa, erc721Address, id, coa.address()), message: "NFT not owned by signer's COA")
        mustCall(coa, erc721Address,
            functionSig: "safeTransferFrom(address,address,uint256)",
            args: [coa.address(), to, id]
        )
        assert(isOwner(coa, erc721Address, id, to), message: "NFT not transferred to recipient")
    }
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", + "bridgeTokensFromEoaToFlowV3": "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\u003d\u003d", + "bridgeTokensFromEvm": "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\u003d\u003d", + "bridgeTokensFromEvmToFlow": "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\u003d", + "bridgeTokensFromEvmToFlowV2": "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\u003d\u003d", + "bridgeTokensFromEvmToFlowV3": "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\u003d\u003d", + "bridgeTokensFromEvmV2": "// Flow Wallet - testnet Script  bridgeTokensFromEvmV2 - v2.78
// <platform_info>

import MetadataViews from 0x631e88ae7f1d7c20

import ViewResolver from 0x631e88ae7f1d7c20

import NonFungibleToken from 0x631e88ae7f1d7c20


import FungibleToken from 0x9a0766d93b6608b7

import FlowToken from 0x7e60df042a9c0868

import FungibleTokenMetadataViews from 0x9a0766d93b6608b7


import ScopedFTProviders from 0xdfc20aee650fcbdf


import EVM from 0x8c5303eaa26202d6


import FlowEVMBridgeUtils from 0xdfc20aee650fcbdf

import FlowEVMBridge from 0xdfc20aee650fcbdf

import FlowEVMBridgeConfig from 0xdfc20aee650fcbdf


/// This transaction bridges fungible tokens from EVM to Cadence assuming it has already been onboarded to the
/// FlowEVMBridge.
///
/// NOTE: The ERC20 must have first been onboarded to the bridge. This can be checked via the method
///     FlowEVMBridge.evmAddressRequiresOnboarding(address: self.evmContractAddress)
///
/// @param vaultIdentifier: The Cadence type identifier of the FungibleToken Vault to bridge
///     - e.g. vault.getType().identifier
/// @param amount: The amount of tokens to bridge from EVM
///
transaction(vaultIdentifier: String, amount: UInt256) {
    let vaultType: Type
    let receiver: &{FungibleToken.Vault}
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let coa: auth(EVM.Bridge) &EVM.CadenceOwnedAccount

    prepare(signer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        /* --- Construct the Vault type --- */
        //
        // Construct the Vault type from the provided identifier
        self.vaultType = CompositeType(vaultIdentifier)
            ?? panic("Could not construct Vault type from identifier: ".concat(vaultIdentifier))
        // Parse the Vault identifier into its components
        let tokenContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.vaultType)
            ?? panic("Could not get contract address from identifier: ".concat(vaultIdentifier))
        let tokenContractName = FlowEVMBridgeUtils.getContractName(fromType: self.vaultType)
            ?? panic("Could not get contract name from identifier: ".concat(vaultIdentifier))

        /* --- Reference the signer's Vault --- */
        //
        // Borrow a reference to the FungibleToken Vault, configuring if necessary
        let viewResolver = getAccount(tokenContractAddress).contracts.borrow<&{ViewResolver}>(name: tokenContractName)
            ?? panic("Could not borrow ViewResolver from FungibleToken contract")
        let vaultData = viewResolver.resolveContractView(
                resourceType: self.vaultType,
                viewType: Type<FungibleTokenMetadataViews.FTVaultData>()
            ) as! FungibleTokenMetadataViews.FTVaultData? ?? panic("Could not resolve FTVaultData view")
        // If the vault does not exist, create it and publish according to the contract's defined configuration
        if signer.storage.borrow<&{FungibleToken.Vault}>(from: vaultData.storagePath) == nil {
            signer.storage.save(<-vaultData.createEmptyVault(), to: vaultData.storagePath)

            signer.capabilities.unpublish(vaultData.receiverPath)
            signer.capabilities.unpublish(vaultData.metadataPath)

            let receiverCap = signer.capabilities.storage.issue<&{FungibleToken.Vault}>(vaultData.storagePath)
            let metadataCap = signer.capabilities.storage.issue<&{FungibleToken.Vault}>(vaultData.storagePath)

            signer.capabilities.publish(receiverCap, at: vaultData.receiverPath)
            signer.capabilities.publish(metadataCap, at: vaultData.metadataPath)
        }
        self.receiver = signer.storage.borrow<&{FungibleToken.Vault}>(from: vaultData.storagePath)
            ?? panic("Could not borrow Vault from storage path")

        /* --- Configure a ScopedFTProvider --- */
        //
        // Calculate the bridge fee - bridging from EVM consumes no storage, so flat fee
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000)
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    execute {
        // Execute the bridge request
        let vault: @{FungibleToken.Vault} <- self.coa.withdrawTokens(
            type: self.vaultType,
            amount: amount,
            feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        // Ensure the bridged vault is the correct type
        assert(vault.getType() == self.vaultType, message: "Bridged vault type mismatch")
        // Deposit the bridged token into the signer's vault
        self.receiver.deposit(from: <-vault)
        // Destroy the ScopedFTProvider
        destroy self.scopedProvider
    }
}", + "bridgeTokensToEvm": "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", + "bridgeTokensToEvmAddress": "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", + "bridgeTokensToEvmAddressV2": "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\u003d\u003d", + "bridgeTokensToEvmV2": "// Flow Wallet - testnet Script  bridgeTokensToEvmV2 - v2.78
// <platform_info>

import MetadataViews from 0x631e88ae7f1d7c20

import ViewResolver from 0x631e88ae7f1d7c20

import NonFungibleToken from 0x631e88ae7f1d7c20


import FungibleToken from 0x9a0766d93b6608b7

import FlowToken from 0x7e60df042a9c0868

import FungibleTokenMetadataViews from 0x9a0766d93b6608b7


import ScopedFTProviders from 0xdfc20aee650fcbdf


import EVM from 0x8c5303eaa26202d6


import FlowEVMBridgeUtils from 0xdfc20aee650fcbdf

import FlowEVMBridge from 0xdfc20aee650fcbdf

import FlowEVMBridgeConfig from 0xdfc20aee650fcbdf

/// Bridges a Vault from the signer's storage to the signer's COA in EVM.Account.
///
/// NOTE: This transaction also onboards the Vault to the bridge if necessary which may incur additional fees
///     than bridging an asset that has already been onboarded.
///
/// @param vaultIdentifier: The Cadence type identifier of the FungibleToken Vault to bridge
///     - e.g. vault.getType().identifier
/// @param amount: The amount of tokens to bridge from EVM
///
transaction(vaultIdentifier: String, amount: UFix64) {
    let sentVault: @{FungibleToken.Vault}
    let coa: auth(EVM.Bridge) &EVM.CadenceOwnedAccount
    let requiresOnboarding: Bool
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider

    prepare(signer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        /* --- Construct the Vault type --- */
        //
        // Construct the Vault type from the provided identifier
        let vaultType = CompositeType(vaultIdentifier)
            ?? panic("Could not construct Vault type from identifier: ".concat(vaultIdentifier))
        // Parse the Vault identifier into its components
        let tokenContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: vaultType)
            ?? panic("Could not get contract address from identifier: ".concat(vaultIdentifier))
        let tokenContractName = FlowEVMBridgeUtils.getContractName(fromType: vaultType)
            ?? panic("Could not get contract name from identifier: ".concat(vaultIdentifier))

        /* --- Retrieve the funds --- */
        //
        // Borrow a reference to the FungibleToken Vault
        let viewResolver = getAccount(tokenContractAddress).contracts.borrow<&{ViewResolver}>(name: tokenContractName)
            ?? panic("Could not borrow ViewResolver from FungibleToken contract")
        let vaultData = viewResolver.resolveContractView(
                resourceType: vaultType,
                viewType: Type<FungibleTokenMetadataViews.FTVaultData>()
            ) as! FungibleTokenMetadataViews.FTVaultData? ?? panic("Could not resolve FTVaultData view")
        let vault = signer.storage.borrow<auth(FungibleToken.Withdraw) &{FungibleToken.Vault}>(
                from: vaultData.storagePath
            ) ?? panic("Could not access signer's FungibleToken Vault")

        // Withdraw the requested balance & calculate the approximate bridge fee based on storage usage
        let currentStorageUsage = signer.storage.used
        self.sentVault <- vault.withdraw(amount: amount)
        let withdrawnStorageUsage = signer.storage.used
        // Approximate the bridge fee based on the difference in storage usage with some buffer
        var approxFee = FlowEVMBridgeUtils.calculateBridgeFee(
                bytes: currentStorageUsage - withdrawnStorageUsage
            ) * 1.10
        // Determine if the Vault requires onboarding - this impacts the fee required
        self.requiresOnboarding = FlowEVMBridge.typeRequiresOnboarding(self.sentVault.getType())
            ?? panic("Bridge does not support this asset type")
        if self.requiresOnboarding {
            approxFee = approxFee + FlowEVMBridgeConfig.onboardFee
        }

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    pre {
        self.sentVault.getType().identifier == vaultIdentifier:
            "Attempting to send invalid vault type - requested: ".concat(vaultIdentifier)
            .concat(", sending: ").concat(self.sentVault.getType().identifier)
    }

    execute {
        if self.requiresOnboarding {
            // Onboard the Vault to the bridge
            FlowEVMBridge.onboardByType(
                self.sentVault.getType(),
                feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
        }
        // Execute the bridge
        self.coa.depositTokens(
            vault: <-self.sentVault,
            feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        // Destroy the ScopedFTProvider
        destroy self.scopedProvider
    }
}", + "calculateBridgeFee": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY2FsY3VsYXRlQnJpZGdlRmVlIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd0VWTUJyaWRnZVV0aWxzIGZyb20gMHhkZmMyMGFlZTY1MGZjYmRmCgoKLy8vIFJldHVybnMgdGhlIGNhbGN1bGF0ZWQgZmVlIGJhc2VkIG9uIHRoZSBudW1iZXIgb2YgYnl0ZXMgdXNlZCB0byBlc2Nyb3cgYW4gYXNzZXQgcGx1cyB0aGUgYmFzZSBmZWUuCi8vLwovLy8gQHBhcmFtIGJ5dGVzOiBUaGUgbnVtYmVyIG9mIGJ5dGVzIHVzZWQgdG8gZXNjcm93IGFuIGFzc2V0LgovLy8KLy8vIEByZXR1cm4gVGhlIGNhbGN1bGF0ZWQgZmVlIHRvIGJlIHBhaWQgaW4gRmxvd1Rva2VuCi8vLwphY2Nlc3MoYWxsKQpmdW4gbWFpbihieXRlcyB1c2VkOiBVSW50NjQpOiBVRml4NjQgewogICAgcmV0dXJuIEZsb3dFVk1CcmlkZ2VVdGlscy5jYWxjdWxhdGVCcmlkZ2VGZWUoYnl0ZXM6IHVzZWQpCn0K", + "evmAddressRequiresOnboarding": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZXZtQWRkcmVzc1JlcXVpcmVzT25ib2FyZGluZyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKaW1wb3J0IEZsb3dFVk1CcmlkZ2UgZnJvbSAweGRmYzIwYWVlNjUwZmNiZGYKCgovLy8gUmV0dXJucyB3aGV0aGVyIGEgRVZNIGNvbnRyYWN0IG5lZWRzIHRvIGJlIG9uYm9hcmRlZCB0byB0aGUgRmxvd0VWTUJyaWRnZQovLy8KLy8vIEBwYXJhbSBldm1BZGRyZXNzSGV4OiBUaGUgaGV4LWVuY29kZWQgYWRkcmVzcyBvZiB0aGUgRVZNIGNvbnRyYWN0IGFzIGEgU3RyaW5nIHdpdGhvdXQgMHggcHJlZml4Ci8vLwovLy8gQHJldHVybiBXaGV0aGVyIHRoZSBjb250cmFjdCByZXF1aXJlcyBvbmJvYXJkaW5nIHRvIHRoZSBGbG93RVZNQnJpZGdlIGlmIHRoZSB0eXBlIGlzIGJyaWRnZWFibGUsIG90aGVyd2lzZSBuaWwKLy8vCmFjY2VzcyhhbGwpIGZ1biBtYWluKGV2bUFkZHJlc3NIZXg6IFN0cmluZyk6IEJvb2w/IHsKICAgIGxldCBhZGRyZXNzID0gRVZNLmFkZHJlc3NGcm9tU3RyaW5nKGV2bUFkZHJlc3NIZXgpCiAgICByZXR1cm4gRmxvd0VWTUJyaWRnZS5ldm1BZGRyZXNzUmVxdWlyZXNPbmJvYXJkaW5nKGFkZHJlc3MpCn0K", + "getAssociatedEvmAddress": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QXNzb2NpYXRlZEV2bUFkZHJlc3MgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBFVk0gZnJvbSAweDhjNTMwM2VhYTI2MjAyZDYKCgppbXBvcnQgRmxvd0VWTUJyaWRnZUNvbmZpZyBmcm9tIDB4ZGZjMjBhZWU2NTBmY2JkZgoKCi8vLyBSZXR1cm5zIHRoZSBFVk0gYWRkcmVzcyBhc3NvY2lhdGVkIHdpdGggdGhlIGdpdmVuIENhZGVuY2UgdHlwZSAoYXMgaXRzIGlkZW50aWZpZXIgU3RyaW5nKQovLy8KLy8vIEBwYXJhbSB0eXBlSWRlbnRpZmllciBUaGUgQ2FkZW5jZSB0eXBlIGlkZW50aWZpZXIgU3RyaW5nCi8vLwovLy8gQHJldHVybiBUaGUgRVZNIGFkZHJlc3MgYXMgYSBoZXggc3RyaW5nIGlmIHRoZSB0eXBlIGhhcyBhbiBhc3NvY2lhdGVkIEVWTUFkZHJlc3MsIG90aGVyd2lzZSBuaWwKLy8vCmFjY2VzcyhhbGwpCmZ1biBtYWluKGlkZW50aWZpZXI6IFN0cmluZyk6IFN0cmluZz8gewogICAgaWYgbGV0IHR5cGUgPSBDb21wb3NpdGVUeXBlKGlkZW50aWZpZXIpIHsKICAgICAgICBpZiBsZXQgYWRkcmVzcyA9IEZsb3dFVk1CcmlkZ2VDb25maWcuZ2V0RVZNQWRkcmVzc0Fzc29jaWF0ZWQod2l0aDogdHlwZSkgewogICAgICAgICAgICByZXR1cm4gU3RyaW5nLmVuY29kZUhleChhZGRyZXNzLmJ5dGVzKQogICAgICAgIH0KICAgIH0KICAgIHJldHVybiBuaWwKfQ\u003d\u003d", + "getAssociatedFlowIdentifier": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QXNzb2NpYXRlZEZsb3dJZGVudGlmaWVyIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRVZNIGZyb20gMHg4YzUzMDNlYWEyNjIwMmQ2CgppbXBvcnQgRmxvd0VWTUJyaWRnZUNvbmZpZyBmcm9tIDB4ZGZjMjBhZWU2NTBmY2JkZgoKCmFjY2VzcyhhbGwpCmZ1biBtYWluKGFkZHJlc3M6IFN0cmluZyk6IFN0cmluZz8gewogICAgaWYgbGV0IHR5cGVJbmZvID0gRmxvd0VWTUJyaWRnZUNvbmZpZy5nZXRUeXBlQXNzb2NpYXRlZCh3aXRoOiBFVk0uYWRkcmVzc0Zyb21TdHJpbmcoYWRkcmVzcykpIHsKICAgICAgICByZXR1cm4gdHlwZUluZm8uaWRlbnRpZmllcgogICAgfQogICAgcmV0dXJuIG5pbAp9", + "getBridgeCoaAddress": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QnJpZGdlQ29hQWRkcmVzcyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKCmltcG9ydCBGbG93RVZNQnJpZGdlIGZyb20gMHhkZmMyMGFlZTY1MGZjYmRmCgoKLy8vIFJldHVybnMgdGhlIEVWTSBhZGRyZXNzIGFzc29jaWF0ZWQgd2l0aCB0aGUgRmxvd0VWTUJyaWRnZQovLy8KLy8vIEByZXR1cm4gVGhlIEVWTSBhZGRyZXNzIGFzc29jaWF0ZWQgd2l0aCB0aGUgRmxvd0VWTUJyaWRnZSdzIGNvb3JkaW5hdGluZyBDYWRlbmNlT3duZWRBY2NvdW50Ci8vLwphY2Nlc3MoYWxsKSBmdW4gbWFpbigpOiBTdHJpbmcgewogICAgbGV0IGFkZHJlc3M6IEVWTS5FVk1BZGRyZXNzID0gRmxvd0VWTUJyaWRnZS5nZXRCcmlkZ2VDT0FFVk1BZGRyZXNzKCkKICAgIHJldHVybiBTdHJpbmcuZW5jb2RlSGV4KGFkZHJlc3MuYnl0ZXMpCn0\u003d", + "onboardByEvmAddress": "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\u003d\u003d", + "onboardByType": "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\u003d\u003d", + "onboardByTypeIdentifier": "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\u003d\u003d", + "typeRequiresOnboarding": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdHlwZVJlcXVpcmVzT25ib2FyZGluZyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dFVk1CcmlkZ2UgZnJvbSAweGRmYzIwYWVlNjUwZmNiZGYKCgovLy8gUmV0dXJucyB3aGV0aGVyIGEgdHlwZSBuZWVkcyB0byBiZSBvbmJvYXJkZWQgdG8gdGhlIEZsb3dFVk1CcmlkZ2UKLy8vCi8vLyBAcGFyYW0gdHlwZTogVGhlIENhZGVuY2UgVHlwZSBpbiBxdWVzdGlvbgovLy8KLy8vIEByZXR1cm4gV2hldGhlciB0aGUgdHlwZSByZXF1aXJlcyBvbmJvYXJkaW5nIHRvIHRoZSBGbG93RVZNQnJpZGdlIGlmIHRoZSB0eXBlIGlzIGJyaWRnZWFibGUsIG90aGVyd2lzZSBuaWwKLy8vCmFjY2VzcyhhbGwpIGZ1biBtYWluKHR5cGU6IFR5cGUpOiBCb29sPyB7CiAgICByZXR1cm4gRmxvd0VWTUJyaWRnZS50eXBlUmVxdWlyZXNPbmJvYXJkaW5nKHR5cGUpCn0K", + "typeRequiresOnboardingByIdentifier": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdHlwZVJlcXVpcmVzT25ib2FyZGluZ0J5SWRlbnRpZmllciAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dFVk1CcmlkZ2UgZnJvbSAweGRmYzIwYWVlNjUwZmNiZGYKCgovLy8gUmV0dXJucyB3aGV0aGVyIGEgdHlwZSBuZWVkcyB0byBiZSBvbmJvYXJkZWQgdG8gdGhlIEZsb3dFVk1CcmlkZ2UKLy8vCi8vLyBAcGFyYW0gaWRlbnRpZmllcjogVGhlIGlkZW50aWZpZXIgb2YgdGhlIENhZGVuY2UgVHlwZSBpbiBxdWVzdGlvbgovLy8KLy8vIEByZXR1cm4gV2hldGhlciB0aGUgdHlwZSByZXF1aXJlcyBvbmJvYXJkaW5nIHRvIHRoZSBGbG93RVZNQnJpZGdlIGlmIHRoZSB0eXBlIGlzIGJyaWRnZWFibGUsIG90aGVyd2lzZSBuaWwKLy8vCmFjY2VzcyhhbGwpIGZ1biBtYWluKGlkZW50aWZpZXI6IFN0cmluZyk6IEJvb2w/IHsKICAgIGlmIGxldCB0eXBlID0gQ29tcG9zaXRlVHlwZShpZGVudGlmaWVyKSB7CiAgICAgICAgcmV0dXJuIEZsb3dFVk1CcmlkZ2UudHlwZVJlcXVpcmVzT25ib2FyZGluZyh0eXBlKQogICAgfQogICAgcmV0dXJuIG5pbAp9Cg\u003d\u003d" }, "collection": { - "checkNFTCollection": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY2hlY2tORlRDb2xsZWN0aW9uIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgogICAgaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCiAgICBpbXBvcnQgPE5GVD4gZnJvbSA8TkZUQWRkcmVzcz4KCiAgICAvLyBUaGlzIHRyYW5zYWN0aW9uIGlzIGZvciB0cmFuc2ZlcnJpbmcgYW5kIE5GVCBmcm9tCiAgICAvLyBvbmUgYWNjb3VudCB0byBhbm90aGVyCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrPFRva2VuPlZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAgbGV0IHZhdWx0UmVmID0gYWNjb3VudC5jYXBhYmlsaXRpZXMuZXhpc3QoPFRva2VuQ29sbGVjdGlvblB1YmxpY1BhdGg+KQogICAgICAgIHJldHVybiB2YXVsdFJlZgogICAgfQoKICAgIGFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgICAgcmV0dXJuIGNoZWNrPFRva2VuPlZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICB9", - "enableNFTStorage": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZW5hYmxlTkZUU3RvcmFnZSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgppbXBvcnQgPE5GVD4gZnJvbSA8TkZUQWRkcmVzcz4KCnRyYW5zYWN0aW9uIHsKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChDYXBhYmlsaXRpZXMsIFNhdmVWYWx1ZSkgJkFjY291bnQpIHsKICAgICAgICBpZiBzaWduZXIuY2FwYWJpbGl0aWVzLmJvcnJvdzwmPE5GVD4uQ29sbGVjdGlvbj4oPENvbGxlY3Rpb25QdWJsaWNQYXRoPikgPT0gbmlsIHsKICAgICAgICAgICAgbGV0IGNvbGxlY3Rpb24gPC0gPE5GVD4uY3JlYXRlRW1wdHlDb2xsZWN0aW9uKG5mdFR5cGU6IFR5cGU8QDxORlQ+Lk5GVD4oKSkKICAgICAgICAgICAgc2lnbmVyLnN0b3JhZ2Uuc2F2ZSg8LWNvbGxlY3Rpb24sIHRvOiA8Q29sbGVjdGlvblN0b3JhZ2VQYXRoPikKICAgICAgICB9CiAgICAgICAgaWYgKHNpZ25lci5jYXBhYmlsaXRpZXMuYm9ycm93PCY8TkZUPi5Db2xsZWN0aW9uPig8Q29sbGVjdGlvblB1YmxpY1BhdGg+KSA9PSBuaWwpIHsKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy51bnB1Ymxpc2goPENvbGxlY3Rpb25QdWJsaWNQYXRoPikKICAgICAgICAgICAgbGV0IGNhcCA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTwmPE5GVD4uQ29sbGVjdGlvbj4oPENvbGxlY3Rpb25TdG9yYWdlUGF0aD4pICAgICAgICAgICAgCiAgICAgICAgICAgIHNpZ25lci5jYXBhYmlsaXRpZXMucHVibGlzaChjYXAsIGF0OiA8Q29sbGVjdGlvblB1YmxpY1BhdGg+KQoKICAgICAgICB9CiAgICB9Cn0\u003d", - "enableNFTStorageV2": "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", - "getCatalogTypeData": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0Q2F0YWxvZ1R5cGVEYXRhIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTkZUQ2F0YWxvZyBmcm9tIDB4TkZUQ2F0YWxvZwoKYWNjZXNzKGFsbCkgZnVuIG1haW4oKToge1N0cmluZyA6IHtTdHJpbmcgOiBCb29sfX0gewogIGxldCBjYXRhbG9nID0gTkZUQ2F0YWxvZy5nZXRDYXRhbG9nVHlwZURhdGEoKQogIHJldHVybiBjYXRhbG9nCn0\u003d", - "getNFT": "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", - "getNFTBalanceStorage": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0TkZUQmFsYW5jZVN0b3JhZ2UgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBOb25GdW5naWJsZVRva2VuIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgoKLy8vIEhlbHBlciBmdW5jdGlvbiB0aGF0IHJldHJpZXZlcyBkYXRhIGFib3V0IGFsbCBwdWJsaWNseSBhY2Nlc3NpYmxlIE5GVHMgY291bnQgIGFuIGFjY291bnQKLy8vCmFjY2VzcyhhbGwpIGZ1biBtYWluKF8gYWRkcmVzczogQWRkcmVzcyk6IHtTdHJpbmc6IEludH0gewogICAgbGV0IGFjY291bnQgPSBnZXRBdXRoQWNjb3VudDxhdXRoKEJvcnJvd1ZhbHVlKSAmQWNjb3VudD4oYWRkcmVzcykKICAgIGxldCBkYXRhOiB7U3RyaW5nOiBJbnR9ID0ge30KICAgIGxldCBjb2xsZWN0aW9uVHlwZTogVHlwZSA9IFR5cGU8QHtOb25GdW5naWJsZVRva2VuLkNvbGxlY3Rpb259PigpCgogICAgLy8gSXRlcmF0ZSBvdmVyIGVhY2ggcHVibGljIHBhdGgKICAgIGFjY291bnQuc3RvcmFnZS5mb3JFYWNoU3RvcmVkKGZ1biAocGF0aDogU3RvcmFnZVBhdGgsIHR5cGU6IFR5cGUpOiBCb29sIHsKICAgICAgICAvLyBSZXR1cm4gZWFybHkgaWYgdGhlIGNvbGxlY3Rpb24gaXMgYnJva2VuIG9yIGlzIG5vdCB0aGUgdHlwZSB3ZSdyZSBsb29raW5nIGZvcgogICAgICAgIGlmIHR5cGUuaXNSZWNvdmVyZWQgfHwgKCF0eXBlLmlzSW5zdGFuY2UoY29sbGVjdGlvblR5cGUpICYmICF0eXBlLmlzU3VidHlwZShvZjogY29sbGVjdGlvblR5cGUpKSB7CiAgICAgICAgICAgIHJldHVybiB0cnVlCiAgICAgICAgfQogICAgICAgIGlmIGxldCBjb2xsZWN0aW9uUmVmID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzwme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0+KGZyb206IHBhdGgpIHsKICAgICAgICAgICAgLy8gUmV0dXJuIGVhcmx5IGlmIG5vIFJlc29sdmVyIGZvdW5kIGluIHRoZSBDb2xsZWN0aW9uCiAgICAgICAgICAgIGxldCBpZHM6IFtVSW50NjRdPSBjb2xsZWN0aW9uUmVmLmdldElEcygpCiAgICAgICAgICAgIGRhdGEuaW5zZXJ0KGtleTogdHlwZS5pZGVudGlmaWVyLCBpZHMubGVuZ3RoKQogICAgICAgIH0KICAgICAgICByZXR1cm4gdHJ1ZQogICAgfSkKICAgIHJldHVybiBkYXRhCn0\u003d", - "getNFTCollection": "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\u003d\u003d", - "getNFTDisplays": "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", - "getNFTMetadataViews": "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\u003d\u003d", - "getUserCollections": "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\u003d", - "getUserCollectionsPage": "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", - "sendNbaNFT": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgc2VuZE5iYU5GVCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCgppbXBvcnQgPE5GVD4gZnJvbSA8TkZUQWRkcmVzcz4KCnRyYW5zYWN0aW9uKHJlY2lwaWVudEFkZHI6IEFkZHJlc3MsIHdpdGhkcmF3SUQ6IFVJbnQ2NCkgewogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSwgQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgLy8gZ2V0IHRoZSByZWNpcGllbnRzIHB1YmxpYyBhY2NvdW50IG9iamVjdAogICAgICAgIGxldCByZWNpcGllbnQgPSBnZXRBY2NvdW50KHJlY2lwaWVudEFkZHIpCiAgICAgICAgLy8gYm9ycm93IGEgcmVmZXJlbmNlIHRvIHRoZSBzaWduZXInJ3MgTkZUIGNvbGxlY3Rpb24KICAgICAgICBsZXQgY29sbGVjdGlvblJlZiA9IHNpZ25lci5zdG9yYWdlCiAgICAgICAgLmJvcnJvdzxhdXRoKE5vbkZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7Tm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9ufT4oZnJvbTogL3N0b3JhZ2UvTW9tZW50Q29sbGVjdGlvbikKICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgb3duZXInJ3MgY29sbGVjdGlvbiIpCiAgICAgICAgbGV0IHNlbmRlclJlZiA9IHNpZ25lcgogICAgICAgIC5jYXBhYmlsaXRpZXMKICAgICAgICAuYm9ycm93PCZ7Tm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9uUHVibGljfT4oL3B1YmxpYy9Nb21lbnRDb2xsZWN0aW9uKQogICAgICAgIC8vIGJvcnJvdyBhIHB1YmxpYyByZWZlcmVuY2UgdG8gdGhlIHJlY2VpdmVycyBjb2xsZWN0aW9uCiAgICAgICAgbGV0IHJlY2lwaWVudFJlZiA9IHJlY2lwaWVudAogICAgICAgIC5jYXBhYmlsaXRpZXMKICAgICAgICAuYm9ycm93PCZ7VG9wU2hvdC5Nb21lbnRDb2xsZWN0aW9uUHVibGljfT4oL3B1YmxpYy9Nb21lbnRDb2xsZWN0aW9uKSA/PyBwYW5pYygiVW5hYmxlIHRvIGJvcnJvdyByZWNlaXZlciByZWZlcmVuY2UiKQogICAgICAgIAogICAgICAgIC8vIHdpdGhkcmF3IHRoZSBORlQgZnJvbSB0aGUgb3duZXInJ3MgY29sbGVjdGlvbgogICAgICAgIGxldCBuZnQgPC0gY29sbGVjdGlvblJlZi53aXRoZHJhdyh3aXRoZHJhd0lEOiB3aXRoZHJhd0lEKQogICAgICAgIC8vIERlcG9zaXQgdGhlIE5GVCBpbiB0aGUgcmVjaXBpZW50JydzIGNvbGxlY3Rpb24KICAgICAgICByZWNpcGllbnRSZWYhLmRlcG9zaXQodG9rZW46IDwtbmZ0KQogICAgfQp9", - "sendNbaNFTV3": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgc2VuZE5iYU5GVFYzIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4NjMxZTg4YWU3ZjFkN2MyMAoKaW1wb3J0IFN0b3JhZ2VSZW50IGZyb20gMHhkNTAwODRhMWE0M2IxNTA3CgoKaW1wb3J0IDxORlQ+IGZyb20gPE5GVEFkZHJlc3M+Cgp0cmFuc2FjdGlvbihyZWNpcGllbnRBZGRyOiBBZGRyZXNzLCB3aXRoZHJhd0lEOiBVSW50NjQpIHsKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgIC8vIGdldCB0aGUgcmVjaXBpZW50cyBwdWJsaWMgYWNjb3VudCBvYmplY3QKICAgICAgICBsZXQgcmVjaXBpZW50ID0gZ2V0QWNjb3VudChyZWNpcGllbnRBZGRyKQogICAgICAgIC8vIGJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgc2lnbmVyJydzIE5GVCBjb2xsZWN0aW9uCiAgICAgICAgbGV0IGNvbGxlY3Rpb25SZWYgPSBzaWduZXIuc3RvcmFnZQogICAgICAgIC5ib3Jyb3c8YXV0aChOb25GdW5naWJsZVRva2VuLldpdGhkcmF3KSAme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0+KGZyb206IC9zdG9yYWdlL01vbWVudENvbGxlY3Rpb24pCiAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgYSByZWZlcmVuY2UgdG8gdGhlIG93bmVyJydzIGNvbGxlY3Rpb24iKQogICAgICAgIGxldCBzZW5kZXJSZWYgPSBzaWduZXIKICAgICAgICAuY2FwYWJpbGl0aWVzCiAgICAgICAgLmJvcnJvdzwme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvblB1YmxpY30+KC9wdWJsaWMvTW9tZW50Q29sbGVjdGlvbikKICAgICAgICAvLyBib3Jyb3cgYSBwdWJsaWMgcmVmZXJlbmNlIHRvIHRoZSByZWNlaXZlcnMgY29sbGVjdGlvbgogICAgICAgIGxldCByZWNpcGllbnRSZWYgPSByZWNpcGllbnQKICAgICAgICAuY2FwYWJpbGl0aWVzCiAgICAgICAgLmJvcnJvdzwme1RvcFNob3QuTW9tZW50Q29sbGVjdGlvblB1YmxpY30+KC9wdWJsaWMvTW9tZW50Q29sbGVjdGlvbikgPz8gcGFuaWMoIlVuYWJsZSB0byBib3Jyb3cgcmVjZWl2ZXIgcmVmZXJlbmNlIikKICAgICAgICAKICAgICAgICAvLyB3aXRoZHJhdyB0aGUgTkZUIGZyb20gdGhlIG93bmVyJydzIGNvbGxlY3Rpb24KICAgICAgICBsZXQgbmZ0IDwtIGNvbGxlY3Rpb25SZWYud2l0aGRyYXcod2l0aGRyYXdJRDogd2l0aGRyYXdJRCkKICAgICAgICAvLyBEZXBvc2l0IHRoZSBORlQgaW4gdGhlIHJlY2lwaWVudCcncyBjb2xsZWN0aW9uCiAgICAgICAgcmVjaXBpZW50UmVmIS5kZXBvc2l0KHRva2VuOiA8LW5mdCkKICAgICAgICBTdG9yYWdlUmVudC50cnlSZWZpbGwocmVjaXBpZW50QWRkcikKICAgIH0KfQ\u003d\u003d", - "sendNFT": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgc2VuZE5GVCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCmltcG9ydCA8TkZUPiBmcm9tIDxORlRBZGRyZXNzPgoKLy8gVGhpcyB0cmFuc2FjdGlvbiBpcyBmb3IgdHJhbnNmZXJyaW5nIGFuZCBORlQgZnJvbQovLyBvbmUgYWNjb3VudCB0byBhbm90aGVyCgp0cmFuc2FjdGlvbihyZWNpcGllbnRBZGRyOiBBZGRyZXNzLCB3aXRoZHJhd0lEOiBVSW50NjQpIHsKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChTdG9yYWdlLCBCb3Jyb3dWYWx1ZSkgJkFjY291bnQpIHsKICAgICAgICAvLyBnZXQgdGhlIHJlY2lwaWVudHMgcHVibGljIGFjY291bnQgb2JqZWN0CiAgICAgICAgbGV0IHJlY2lwaWVudCA9IGdldEFjY291bnQocmVjaXBpZW50QWRkcikKCiAgICAgICAgLy8gYm9ycm93IGEgcmVmZXJlbmNlIHRvIHRoZSBzaWduZXIncyBORlQgY29sbGVjdGlvbgogICAgICAgIGxldCBjb2xsZWN0aW9uUmVmID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoTm9uRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntOb25GdW5naWJsZVRva2VuLlByb3ZpZGVyfT4oZnJvbTogPENvbGxlY3Rpb25TdG9yYWdlUGF0aD4pCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IGEgcmVmZXJlbmNlIHRvIHRoZSBvd25lcidzIGNvbGxlY3Rpb24iKQoKICAgICAgICAvLyBib3Jyb3cgYSBwdWJsaWMgcmVmZXJlbmNlIHRvIHRoZSByZWNlaXZlcnMgY29sbGVjdGlvbgogICAgICAgIGxldCBkZXBvc2l0UmVmID0gcmVjaXBpZW50CiAgICAgICAgICAgIC5jYXBhYmlsaXRpZXMKICAgICAgICAgICAgLmJvcnJvdzwme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0+KDxDb2xsZWN0aW9uUHVibGljUGF0aD4pCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IGEgcmVmZXJlbmNlIHRvIHRoZSByZWNlaXZlcidzIGNvbGxlY3Rpb24iKQoKICAgICAgICAvLyB3aXRoZHJhdyB0aGUgTkZUIGZyb20gdGhlIG93bmVyJ3MgY29sbGVjdGlvbgogICAgICAgIGxldCBuZnQgPC0gY29sbGVjdGlvblJlZi53aXRoZHJhdyh3aXRoZHJhd0lEOiB3aXRoZHJhd0lEKQoKICAgICAgICAvLyBEZXBvc2l0IHRoZSBORlQgaW4gdGhlIHJlY2lwaWVudCdzIGNvbGxlY3Rpb24KICAgICAgICBkZXBvc2l0UmVmLmRlcG9zaXQodG9rZW46IDwtbmZ0KQoKICAgIH0KfQ\u003d\u003d", - "sendNFTV3": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgc2VuZE5GVFYzIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4NjMxZTg4YWU3ZjFkN2MyMAoKaW1wb3J0IFN0b3JhZ2VSZW50IGZyb20gMHhkNTAwODRhMWE0M2IxNTA3CgppbXBvcnQgPE5GVD4gZnJvbSA8TkZUQWRkcmVzcz4KCi8vIFRoaXMgdHJhbnNhY3Rpb24gaXMgZm9yIHRyYW5zZmVycmluZyBhbmQgTkZUIGZyb20KLy8gb25lIGFjY291bnQgdG8gYW5vdGhlcgoKdHJhbnNhY3Rpb24ocmVjaXBpZW50QWRkcjogQWRkcmVzcywgd2l0aGRyYXdJRDogVUludDY0KSB7CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSwgQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgLy8gZ2V0IHRoZSByZWNpcGllbnRzIHB1YmxpYyBhY2NvdW50IG9iamVjdAogICAgICAgIGxldCByZWNpcGllbnQgPSBnZXRBY2NvdW50KHJlY2lwaWVudEFkZHIpCgogICAgICAgIC8vIGJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgc2lnbmVyJ3MgTkZUIGNvbGxlY3Rpb24KICAgICAgICBsZXQgY29sbGVjdGlvblJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKE5vbkZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7Tm9uRnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+KGZyb206IDxDb2xsZWN0aW9uU3RvcmFnZVBhdGg+KQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgb3duZXIncyBjb2xsZWN0aW9uIikKCiAgICAgICAgLy8gYm9ycm93IGEgcHVibGljIHJlZmVyZW5jZSB0byB0aGUgcmVjZWl2ZXJzIGNvbGxlY3Rpb24KICAgICAgICBsZXQgZGVwb3NpdFJlZiA9IHJlY2lwaWVudAogICAgICAgICAgICAuY2FwYWJpbGl0aWVzCiAgICAgICAgICAgIC5ib3Jyb3c8JntOb25GdW5naWJsZVRva2VuLkNvbGxlY3Rpb259Pig8Q29sbGVjdGlvblB1YmxpY1BhdGg+KQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgcmVjZWl2ZXIncyBjb2xsZWN0aW9uIikKCiAgICAgICAgLy8gd2l0aGRyYXcgdGhlIE5GVCBmcm9tIHRoZSBvd25lcidzIGNvbGxlY3Rpb24KICAgICAgICBsZXQgbmZ0IDwtIGNvbGxlY3Rpb25SZWYud2l0aGRyYXcod2l0aGRyYXdJRDogd2l0aGRyYXdJRCkKCiAgICAgICAgLy8gRGVwb3NpdCB0aGUgTkZUIGluIHRoZSByZWNpcGllbnQncyBjb2xsZWN0aW9uCiAgICAgICAgZGVwb3NpdFJlZi5kZXBvc2l0KHRva2VuOiA8LW5mdCkKICAgICAgICBTdG9yYWdlUmVudC50cnlSZWZpbGwocmVjaXBpZW50QWRkcikKCiAgICB9Cn0\u003d" + "batchSendNFTV3": "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\u003d\u003d", + "checkNFTCollection": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY2hlY2tORlRDb2xsZWN0aW9uIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgogICAgaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCiAgICBpbXBvcnQgPE5GVD4gZnJvbSA8TkZUQWRkcmVzcz4KCiAgICAvLyBUaGlzIHRyYW5zYWN0aW9uIGlzIGZvciB0cmFuc2ZlcnJpbmcgYW5kIE5GVCBmcm9tCiAgICAvLyBvbmUgYWNjb3VudCB0byBhbm90aGVyCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrPFRva2VuPlZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAgbGV0IHZhdWx0UmVmID0gYWNjb3VudC5jYXBhYmlsaXRpZXMuZXhpc3QoPFRva2VuQ29sbGVjdGlvblB1YmxpY1BhdGg+KQogICAgICAgIHJldHVybiB2YXVsdFJlZgogICAgfQoKICAgIGFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgICAgcmV0dXJuIGNoZWNrPFRva2VuPlZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICB9", + "enableNFTStorage": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZW5hYmxlTkZUU3RvcmFnZSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgppbXBvcnQgPE5GVD4gZnJvbSA8TkZUQWRkcmVzcz4KCnRyYW5zYWN0aW9uIHsKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChDYXBhYmlsaXRpZXMsIFNhdmVWYWx1ZSkgJkFjY291bnQpIHsKICAgICAgICBpZiBzaWduZXIuY2FwYWJpbGl0aWVzLmJvcnJvdzwmPE5GVD4uQ29sbGVjdGlvbj4oPENvbGxlY3Rpb25QdWJsaWNQYXRoPikgPT0gbmlsIHsKICAgICAgICAgICAgbGV0IGNvbGxlY3Rpb24gPC0gPE5GVD4uY3JlYXRlRW1wdHlDb2xsZWN0aW9uKG5mdFR5cGU6IFR5cGU8QDxORlQ+Lk5GVD4oKSkKICAgICAgICAgICAgc2lnbmVyLnN0b3JhZ2Uuc2F2ZSg8LWNvbGxlY3Rpb24sIHRvOiA8Q29sbGVjdGlvblN0b3JhZ2VQYXRoPikKICAgICAgICB9CiAgICAgICAgaWYgKHNpZ25lci5jYXBhYmlsaXRpZXMuYm9ycm93PCY8TkZUPi5Db2xsZWN0aW9uPig8Q29sbGVjdGlvblB1YmxpY1BhdGg+KSA9PSBuaWwpIHsKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy51bnB1Ymxpc2goPENvbGxlY3Rpb25QdWJsaWNQYXRoPikKICAgICAgICAgICAgbGV0IGNhcCA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTwmPE5GVD4uQ29sbGVjdGlvbj4oPENvbGxlY3Rpb25TdG9yYWdlUGF0aD4pICAgICAgICAgICAgCiAgICAgICAgICAgIHNpZ25lci5jYXBhYmlsaXRpZXMucHVibGlzaChjYXAsIGF0OiA8Q29sbGVjdGlvblB1YmxpY1BhdGg+KQoKICAgICAgICB9CiAgICB9Cn0\u003d", + "enableNFTStorageV2": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZW5hYmxlTkZUU3RvcmFnZVYyIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4NjMxZTg4YWU3ZjFkN2MyMAoKaW1wb3J0IE1ldGFkYXRhVmlld3MgZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCmltcG9ydCBWaWV3UmVzb2x2ZXIgZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCgp0cmFuc2FjdGlvbihuZnRJZGVudGlmaWVyOiBTdHJpbmcpIHsKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChDYXBhYmlsaXRpZXMsIFNhdmVWYWx1ZSkgJkFjY291bnQpIHsKCiAgICAgICAgbGV0IHR5cGUgPSBDb21wb3NpdGVUeXBlKG5mdElkZW50aWZpZXIpCiAgICAgICAgbGV0IGlkZW50aWZpZXJTcGxpdCA9IG5mdElkZW50aWZpZXIuc3BsaXQoc2VwYXJhdG9yOiAiLiIpCiAgICAgICAgbGV0IGFkZHJlc3MgPSBBZGRyZXNzLmZyb21TdHJpbmcoIjB4Ii5jb25jYXQoaWRlbnRpZmllclNwbGl0WzFdKSkhCiAgICAgICAgbGV0IG5hbWUgPSBpZGVudGlmaWVyU3BsaXRbMl0hCgogICAgICAgIGxldCB2aWV3UmVzb2x2ZXIgPSBnZXRBY2NvdW50KGFkZHJlc3MpLmNvbnRyYWN0cy5ib3Jyb3c8JntWaWV3UmVzb2x2ZXJ9PihuYW1lOiBuYW1lKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBWaWV3UmVzb2x2ZXIgZnJvbSBORlQgY29udHJhY3QiKQogICAgICAgIGxldCBjb2xsZWN0aW9uRGF0YSA9IHZpZXdSZXNvbHZlci5yZXNvbHZlQ29udHJhY3RWaWV3KAogICAgICAgICAgICAgICAgcmVzb3VyY2VUeXBlOiB0eXBlLAogICAgICAgICAgICAgICAgdmlld1R5cGU6IFR5cGU8TWV0YWRhdGFWaWV3cy5ORlRDb2xsZWN0aW9uRGF0YT4oKQogICAgICAgICAgICApIGFzISBNZXRhZGF0YVZpZXdzLk5GVENvbGxlY3Rpb25EYXRhPyA/PyBwYW5pYygiQ291bGQgbm90IHJlc29sdmUgTkZUQ29sbGVjdGlvbkRhdGEgdmlldyIpCgogICAgICAgIGlmIHNpZ25lci5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7Tm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9ufT4oY29sbGVjdGlvbkRhdGEucHVibGljUGF0aCkgPT0gbmlsIHsKICAgICAgICAgICAgbGV0IGNvbGxlY3Rpb24gPC0gY29sbGVjdGlvbkRhdGEuY3JlYXRlRW1wdHlDb2xsZWN0aW9uKCkKICAgICAgICAgICAgc2lnbmVyLnN0b3JhZ2Uuc2F2ZSg8LWNvbGxlY3Rpb24sIHRvOiBjb2xsZWN0aW9uRGF0YS5zdG9yYWdlUGF0aCkKICAgICAgICB9CiAgICAgICAgaWYgKHNpZ25lci5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7Tm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9ufT4oY29sbGVjdGlvbkRhdGEucHVibGljUGF0aCkgPT0gbmlsKSB7CiAgICAgICAgICAgIHNpZ25lci5jYXBhYmlsaXRpZXMudW5wdWJsaXNoKGNvbGxlY3Rpb25EYXRhLnB1YmxpY1BhdGgpCiAgICAgICAgICAgIGxldCBjYXAgPSBzaWduZXIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8JntOb25GdW5naWJsZVRva2VuLkNvbGxlY3Rpb259Pihjb2xsZWN0aW9uRGF0YS5zdG9yYWdlUGF0aCkgICAgICAgICAgICAKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5wdWJsaXNoKGNhcCwgYXQ6IGNvbGxlY3Rpb25EYXRhLnB1YmxpY1BhdGgpCiAgICAgICAgfQogICAgfQp9", + "getCatalogTypeData": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0Q2F0YWxvZ1R5cGVEYXRhIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTkZUQ2F0YWxvZyBmcm9tIDB4TkZUQ2F0YWxvZwoKYWNjZXNzKGFsbCkgZnVuIG1haW4oKToge1N0cmluZyA6IHtTdHJpbmcgOiBCb29sfX0gewogIGxldCBjYXRhbG9nID0gTkZUQ2F0YWxvZy5nZXRDYXRhbG9nVHlwZURhdGEoKQogIHJldHVybiBjYXRhbG9nCn0\u003d", + "getNFT": "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", + "getNFTBalanceStorage": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0TkZUQmFsYW5jZVN0b3JhZ2UgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBOb25GdW5naWJsZVRva2VuIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgoKLy8vIEhlbHBlciBmdW5jdGlvbiB0aGF0IHJldHJpZXZlcyBkYXRhIGFib3V0IGFsbCBwdWJsaWNseSBhY2Nlc3NpYmxlIE5GVHMgY291bnQgIGFuIGFjY291bnQKLy8vCmFjY2VzcyhhbGwpIGZ1biBtYWluKF8gYWRkcmVzczogQWRkcmVzcyk6IHtTdHJpbmc6IEludH0gewogICAgbGV0IGFjY291bnQgPSBnZXRBdXRoQWNjb3VudDxhdXRoKEJvcnJvd1ZhbHVlKSAmQWNjb3VudD4oYWRkcmVzcykKICAgIGxldCBkYXRhOiB7U3RyaW5nOiBJbnR9ID0ge30KICAgIGxldCBjb2xsZWN0aW9uVHlwZTogVHlwZSA9IFR5cGU8QHtOb25GdW5naWJsZVRva2VuLkNvbGxlY3Rpb259PigpCgogICAgLy8gSXRlcmF0ZSBvdmVyIGVhY2ggcHVibGljIHBhdGgKICAgIGFjY291bnQuc3RvcmFnZS5mb3JFYWNoU3RvcmVkKGZ1biAocGF0aDogU3RvcmFnZVBhdGgsIHR5cGU6IFR5cGUpOiBCb29sIHsKICAgICAgICAvLyBSZXR1cm4gZWFybHkgaWYgdGhlIGNvbGxlY3Rpb24gaXMgYnJva2VuIG9yIGlzIG5vdCB0aGUgdHlwZSB3ZSdyZSBsb29raW5nIGZvcgogICAgICAgIGlmIHR5cGUuaXNSZWNvdmVyZWQgfHwgKCF0eXBlLmlzSW5zdGFuY2UoY29sbGVjdGlvblR5cGUpICYmICF0eXBlLmlzU3VidHlwZShvZjogY29sbGVjdGlvblR5cGUpKSB7CiAgICAgICAgICAgIHJldHVybiB0cnVlCiAgICAgICAgfQogICAgICAgIGlmIGxldCBjb2xsZWN0aW9uUmVmID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzwme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0+KGZyb206IHBhdGgpIHsKICAgICAgICAgICAgLy8gUmV0dXJuIGVhcmx5IGlmIG5vIFJlc29sdmVyIGZvdW5kIGluIHRoZSBDb2xsZWN0aW9uCiAgICAgICAgICAgIGxldCBpZHM6IFtVSW50NjRdPSBjb2xsZWN0aW9uUmVmLmdldElEcygpCiAgICAgICAgICAgIGRhdGEuaW5zZXJ0KGtleTogdHlwZS5pZGVudGlmaWVyLCBpZHMubGVuZ3RoKQogICAgICAgIH0KICAgICAgICByZXR1cm4gdHJ1ZQogICAgfSkKICAgIHJldHVybiBkYXRhCn0\u003d", + "getNFTCollection": "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\u003d\u003d", + "getNFTDisplays": "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", + "getNFTMetadataViews": "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\u003d\u003d", + "getUserCollections": "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\u003d", + "getUserCollectionsPage": "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", + "sendNbaNFT": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgc2VuZE5iYU5GVCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCgppbXBvcnQgPE5GVD4gZnJvbSA8TkZUQWRkcmVzcz4KCnRyYW5zYWN0aW9uKHJlY2lwaWVudEFkZHI6IEFkZHJlc3MsIHdpdGhkcmF3SUQ6IFVJbnQ2NCkgewogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSwgQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgLy8gZ2V0IHRoZSByZWNpcGllbnRzIHB1YmxpYyBhY2NvdW50IG9iamVjdAogICAgICAgIGxldCByZWNpcGllbnQgPSBnZXRBY2NvdW50KHJlY2lwaWVudEFkZHIpCiAgICAgICAgLy8gYm9ycm93IGEgcmVmZXJlbmNlIHRvIHRoZSBzaWduZXInJ3MgTkZUIGNvbGxlY3Rpb24KICAgICAgICBsZXQgY29sbGVjdGlvblJlZiA9IHNpZ25lci5zdG9yYWdlCiAgICAgICAgLmJvcnJvdzxhdXRoKE5vbkZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7Tm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9ufT4oZnJvbTogL3N0b3JhZ2UvTW9tZW50Q29sbGVjdGlvbikKICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgb3duZXInJ3MgY29sbGVjdGlvbiIpCiAgICAgICAgbGV0IHNlbmRlclJlZiA9IHNpZ25lcgogICAgICAgIC5jYXBhYmlsaXRpZXMKICAgICAgICAuYm9ycm93PCZ7Tm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9uUHVibGljfT4oL3B1YmxpYy9Nb21lbnRDb2xsZWN0aW9uKQogICAgICAgIC8vIGJvcnJvdyBhIHB1YmxpYyByZWZlcmVuY2UgdG8gdGhlIHJlY2VpdmVycyBjb2xsZWN0aW9uCiAgICAgICAgbGV0IHJlY2lwaWVudFJlZiA9IHJlY2lwaWVudAogICAgICAgIC5jYXBhYmlsaXRpZXMKICAgICAgICAuYm9ycm93PCZ7VG9wU2hvdC5Nb21lbnRDb2xsZWN0aW9uUHVibGljfT4oL3B1YmxpYy9Nb21lbnRDb2xsZWN0aW9uKSA/PyBwYW5pYygiVW5hYmxlIHRvIGJvcnJvdyByZWNlaXZlciByZWZlcmVuY2UiKQogICAgICAgIAogICAgICAgIC8vIHdpdGhkcmF3IHRoZSBORlQgZnJvbSB0aGUgb3duZXInJ3MgY29sbGVjdGlvbgogICAgICAgIGxldCBuZnQgPC0gY29sbGVjdGlvblJlZi53aXRoZHJhdyh3aXRoZHJhd0lEOiB3aXRoZHJhd0lEKQogICAgICAgIC8vIERlcG9zaXQgdGhlIE5GVCBpbiB0aGUgcmVjaXBpZW50JydzIGNvbGxlY3Rpb24KICAgICAgICByZWNpcGllbnRSZWYhLmRlcG9zaXQodG9rZW46IDwtbmZ0KQogICAgfQp9", + "sendNbaNFTV3": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgc2VuZE5iYU5GVFYzIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4NjMxZTg4YWU3ZjFkN2MyMAoKaW1wb3J0IFN0b3JhZ2VSZW50IGZyb20gMHhkNTAwODRhMWE0M2IxNTA3CgoKaW1wb3J0IDxORlQ+IGZyb20gPE5GVEFkZHJlc3M+Cgp0cmFuc2FjdGlvbihyZWNpcGllbnRBZGRyOiBBZGRyZXNzLCB3aXRoZHJhd0lEOiBVSW50NjQpIHsKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgIC8vIGdldCB0aGUgcmVjaXBpZW50cyBwdWJsaWMgYWNjb3VudCBvYmplY3QKICAgICAgICBsZXQgcmVjaXBpZW50ID0gZ2V0QWNjb3VudChyZWNpcGllbnRBZGRyKQogICAgICAgIC8vIGJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgc2lnbmVyJydzIE5GVCBjb2xsZWN0aW9uCiAgICAgICAgbGV0IGNvbGxlY3Rpb25SZWYgPSBzaWduZXIuc3RvcmFnZQogICAgICAgIC5ib3Jyb3c8YXV0aChOb25GdW5naWJsZVRva2VuLldpdGhkcmF3KSAme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0+KGZyb206IC9zdG9yYWdlL01vbWVudENvbGxlY3Rpb24pCiAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgYSByZWZlcmVuY2UgdG8gdGhlIG93bmVyJydzIGNvbGxlY3Rpb24iKQogICAgICAgIGxldCBzZW5kZXJSZWYgPSBzaWduZXIKICAgICAgICAuY2FwYWJpbGl0aWVzCiAgICAgICAgLmJvcnJvdzwme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvblB1YmxpY30+KC9wdWJsaWMvTW9tZW50Q29sbGVjdGlvbikKICAgICAgICAvLyBib3Jyb3cgYSBwdWJsaWMgcmVmZXJlbmNlIHRvIHRoZSByZWNlaXZlcnMgY29sbGVjdGlvbgogICAgICAgIGxldCByZWNpcGllbnRSZWYgPSByZWNpcGllbnQKICAgICAgICAuY2FwYWJpbGl0aWVzCiAgICAgICAgLmJvcnJvdzwme1RvcFNob3QuTW9tZW50Q29sbGVjdGlvblB1YmxpY30+KC9wdWJsaWMvTW9tZW50Q29sbGVjdGlvbikgPz8gcGFuaWMoIlVuYWJsZSB0byBib3Jyb3cgcmVjZWl2ZXIgcmVmZXJlbmNlIikKICAgICAgICAKICAgICAgICAvLyB3aXRoZHJhdyB0aGUgTkZUIGZyb20gdGhlIG93bmVyJydzIGNvbGxlY3Rpb24KICAgICAgICBsZXQgbmZ0IDwtIGNvbGxlY3Rpb25SZWYud2l0aGRyYXcod2l0aGRyYXdJRDogd2l0aGRyYXdJRCkKICAgICAgICAvLyBEZXBvc2l0IHRoZSBORlQgaW4gdGhlIHJlY2lwaWVudCcncyBjb2xsZWN0aW9uCiAgICAgICAgcmVjaXBpZW50UmVmIS5kZXBvc2l0KHRva2VuOiA8LW5mdCkKICAgICAgICBTdG9yYWdlUmVudC50cnlSZWZpbGwocmVjaXBpZW50QWRkcikKICAgIH0KfQ\u003d\u003d", + "sendNFT": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgc2VuZE5GVCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCmltcG9ydCA8TkZUPiBmcm9tIDxORlRBZGRyZXNzPgoKLy8gdG9kbwovLyBUaGlzIHRyYW5zYWN0aW9uIGlzIGZvciB0cmFuc2ZlcnJpbmcgYW5kIE5GVCBmcm9tCi8vIG9uZSBhY2NvdW50IHRvIGFub3RoZXIKCnRyYW5zYWN0aW9uKHJlY2lwaWVudEFkZHI6IEFkZHJlc3MsIHdpdGhkcmF3SUQ6IFVJbnQ2NCkgewoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgIC8vIGdldCB0aGUgcmVjaXBpZW50cyBwdWJsaWMgYWNjb3VudCBvYmplY3QKICAgICAgICBsZXQgcmVjaXBpZW50ID0gZ2V0QWNjb3VudChyZWNpcGllbnRBZGRyKQoKICAgICAgICAvLyBib3Jyb3cgYSByZWZlcmVuY2UgdG8gdGhlIHNpZ25lcidzIE5GVCBjb2xsZWN0aW9uCiAgICAgICAgbGV0IGNvbGxlY3Rpb25SZWYgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChOb25GdW5naWJsZVRva2VuLldpdGhkcmF3KSAme05vbkZ1bmdpYmxlVG9rZW4uUHJvdmlkZXJ9Pihmcm9tOiA8Q29sbGVjdGlvblN0b3JhZ2VQYXRoPikKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgYSByZWZlcmVuY2UgdG8gdGhlIG93bmVyJ3MgY29sbGVjdGlvbiIpCgogICAgICAgIC8vIGJvcnJvdyBhIHB1YmxpYyByZWZlcmVuY2UgdG8gdGhlIHJlY2VpdmVycyBjb2xsZWN0aW9uCiAgICAgICAgbGV0IGRlcG9zaXRSZWYgPSByZWNpcGllbnQKICAgICAgICAgICAgLmNhcGFiaWxpdGllcwogICAgICAgICAgICAuYm9ycm93PCZ7Tm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9ufT4oPENvbGxlY3Rpb25QdWJsaWNQYXRoPikKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgYSByZWZlcmVuY2UgdG8gdGhlIHJlY2VpdmVyJ3MgY29sbGVjdGlvbiIpCgogICAgICAgIC8vIHdpdGhkcmF3IHRoZSBORlQgZnJvbSB0aGUgb3duZXIncyBjb2xsZWN0aW9uCiAgICAgICAgbGV0IG5mdCA8LSBjb2xsZWN0aW9uUmVmLndpdGhkcmF3KHdpdGhkcmF3SUQ6IHdpdGhkcmF3SUQpCgogICAgICAgIC8vIERlcG9zaXQgdGhlIE5GVCBpbiB0aGUgcmVjaXBpZW50J3MgY29sbGVjdGlvbgogICAgICAgIGRlcG9zaXRSZWYuZGVwb3NpdCh0b2tlbjogPC1uZnQpCgogICAgfQp9", + "sendNFTV3": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgc2VuZE5GVFYzIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4NjMxZTg4YWU3ZjFkN2MyMAoKaW1wb3J0IFN0b3JhZ2VSZW50IGZyb20gMHhkNTAwODRhMWE0M2IxNTA3CgppbXBvcnQgPE5GVD4gZnJvbSA8TkZUQWRkcmVzcz4KCi8vIFRoaXMgdHJhbnNhY3Rpb24gaXMgZm9yIHRyYW5zZmVycmluZyBhbmQgTkZUIGZyb20KLy8gb25lIGFjY291bnQgdG8gYW5vdGhlcgoKdHJhbnNhY3Rpb24ocmVjaXBpZW50QWRkcjogQWRkcmVzcywgd2l0aGRyYXdJRDogVUludDY0KSB7CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSwgQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgLy8gZ2V0IHRoZSByZWNpcGllbnRzIHB1YmxpYyBhY2NvdW50IG9iamVjdAogICAgICAgIGxldCByZWNpcGllbnQgPSBnZXRBY2NvdW50KHJlY2lwaWVudEFkZHIpCgogICAgICAgIC8vIGJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgc2lnbmVyJ3MgTkZUIGNvbGxlY3Rpb24KICAgICAgICBsZXQgY29sbGVjdGlvblJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKE5vbkZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7Tm9uRnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+KGZyb206IDxDb2xsZWN0aW9uU3RvcmFnZVBhdGg+KQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgb3duZXIncyBjb2xsZWN0aW9uIikKCiAgICAgICAgLy8gYm9ycm93IGEgcHVibGljIHJlZmVyZW5jZSB0byB0aGUgcmVjZWl2ZXJzIGNvbGxlY3Rpb24KICAgICAgICBsZXQgZGVwb3NpdFJlZiA9IHJlY2lwaWVudAogICAgICAgICAgICAuY2FwYWJpbGl0aWVzCiAgICAgICAgICAgIC5ib3Jyb3c8JntOb25GdW5naWJsZVRva2VuLkNvbGxlY3Rpb259Pig8Q29sbGVjdGlvblB1YmxpY1BhdGg+KQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgcmVjZWl2ZXIncyBjb2xsZWN0aW9uIikKCiAgICAgICAgLy8gd2l0aGRyYXcgdGhlIE5GVCBmcm9tIHRoZSBvd25lcidzIGNvbGxlY3Rpb24KICAgICAgICBsZXQgbmZ0IDwtIGNvbGxlY3Rpb25SZWYud2l0aGRyYXcod2l0aGRyYXdJRDogd2l0aGRyYXdJRCkKCiAgICAgICAgLy8gRGVwb3NpdCB0aGUgTkZUIGluIHRoZSByZWNpcGllbnQncyBjb2xsZWN0aW9uCiAgICAgICAgZGVwb3NpdFJlZi5kZXBvc2l0KHRva2VuOiA8LW5mdCkKICAgICAgICBTdG9yYWdlUmVudC50cnlSZWZpbGwocmVjaXBpZW50QWRkcikKCiAgICB9Cn0\u003d" }, "contract": { - "getContractByName": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0Q29udHJhY3RCeU5hbWUgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MsIGNvbnRyYWN0TmFtZTogU3RyaW5nKTogU3RyaW5nPyB7CiAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgbGV0IGRlcGxveWVkQ29udHJhY3QgPSBhY2NvdW50LmNvbnRyYWN0cy5nZXQobmFtZTogY29udHJhY3ROYW1lKQoKICByZXR1cm4gU3RyaW5nLmZyb21VVEY4KGRlcGxveWVkQ29udHJhY3Q/LmNvZGUhKQp9", - "getContractNames": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0Q29udHJhY3ROYW1lcyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6ICZbU3RyaW5nXSB7CiAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgcmV0dXJuIGFjY291bnQuY29udHJhY3RzLm5hbWVzCn0\u003d" + "getContractByName": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0Q29udHJhY3RCeU5hbWUgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MsIGNvbnRyYWN0TmFtZTogU3RyaW5nKTogU3RyaW5nPyB7CiAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgbGV0IGRlcGxveWVkQ29udHJhY3QgPSBhY2NvdW50LmNvbnRyYWN0cy5nZXQobmFtZTogY29udHJhY3ROYW1lKQoKICByZXR1cm4gU3RyaW5nLmZyb21VVEY4KGRlcGxveWVkQ29udHJhY3Q/LmNvZGUhKQp9", + "getContractNames": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0Q29udHJhY3ROYW1lcyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6ICZbU3RyaW5nXSB7CiAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgcmV0dXJuIGFjY291bnQuY29udHJhY3RzLm5hbWVzCn0\u003d" }, "evm": { - "call": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY2FsbCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKCmFjY2VzcyhhbGwpCmZ1biBtYWluKGhleEVuY29kZWREYXRhOiBTdHJpbmcsIGhleEVuY29kZWRBZGRyZXNzOiBTdHJpbmcpOiBTdHJpbmcgewogICAgbGV0IGFjY291bnQgPSBnZXRBdXRoQWNjb3VudDxhdXRoKFN0b3JhZ2UpICZBY2NvdW50PihBZGRyZXNzKDB4Q09BKSkKCiAgICBsZXQgY29hID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzxhdXRoKEVWTS5DYWxsKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KAogICAgICAgIGZyb206IC9zdG9yYWdlL2V2bQogICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQogICAgbGV0IGFkZHJlc3NCeXRlcyA9IGhleEVuY29kZWRBZGRyZXNzLmRlY29kZUhleCgpLnRvQ29uc3RhbnRTaXplZDxbVUludDg7IDIwXT4oKSEKCiAgICBsZXQgdHhSZXN1bHQgPSBjb2EuY2FsbCgKICAgICAgICB0bzogRVZNLkVWTUFkZHJlc3MoYnl0ZXM6IGFkZHJlc3NCeXRlcyksCiAgICAgICAgZGF0YTogaGV4RW5jb2RlZERhdGEuZGVjb2RlSGV4KCksCiAgICAgICAgZ2FzTGltaXQ6IDE1MDAwMDAwLCAvLyB0b2RvIG1ha2UgaXQgY29uZmlndXJhYmxlLCBtYXggZm9yIG5vdwogICAgICAgIHZhbHVlOiBFVk0uQmFsYW5jZShhdHRvZmxvdzogMCkKICAgICkKCiAgICBhc3NlcnQoCiAgICAgICAgdHhSZXN1bHQuc3RhdHVzID09IEVWTS5TdGF0dXMuZmFpbGVkIHx8IHR4UmVzdWx0LnN0YXR1cyA9PSBFVk0uU3RhdHVzLnN1Y2Nlc3NmdWwsCiAgICAgICAgbWVzc2FnZTogImV2bV9lcnJvcj0iLmNvbmNhdCh0eFJlc3VsdC5lcnJvck1lc3NhZ2UpLmNvbmNhdCgiXG4iKQogICAgKQoKICAgIHJldHVybiBTdHJpbmcuZW5jb2RlSGV4KGNhbGxSZXN1bHQuZGF0YSkKfQo\u003d", - "callContract": "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\u003d\u003d", - "callContractV2": "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", - "checkCoaLink": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY2hlY2tDb2FMaW5rIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRVZNIGZyb20gMHg4YzUzMDNlYWEyNjIwMmQ2CgoKLy8vIFJldHVybnMgd2hldGhlciBhIENPQSBpcyBzdG9yZWQgYW5kIGl0cyBwdWJsaWMgY2FwYWJpbGl0eSBpcyBwdWJsaXNoZWQKLy8vCi8vLyBAcGFyYW0gZmxvd0FkZHJlc3M6IFRoZSBGbG93IGFkZHJlc3MgdG8gY2hlY2sgZm9yIGEgQ09BCi8vLwovLy8gQHJldHVybiBCb29sOiBXaGV0aGVyIGEgQ09BIGlzIHN0b3JlZCBhbmQgaXRzIHB1YmxpYyBjYXBhYmlsaXR5IGlzIHB1Ymxpc2hlZCwgbmlsIGlmIG5vIENPQSBpcyBzdG9yZWQKLy8vCmFjY2VzcyhhbGwpIGZ1biBtYWluKGZsb3dBZGRyZXNzOiBBZGRyZXNzKTogQm9vbD8gewogICAgLy8gQm9ycm93IHRoZSBDT0EgdG8gY2hlY2sgaWYgb25lIGlzIHN0b3JlZAogICAgaWYgbGV0IGFkZHJlc3M6IEVWTS5FVk1BZGRyZXNzID0gZ2V0QXV0aEFjY291bnQ8YXV0aChCb3Jyb3dWYWx1ZSkgJkFjY291bnQ+KGZsb3dBZGRyZXNzKQogICAgICAgIC5zdG9yYWdlLmJvcnJvdzwmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KGZyb206IC9zdG9yYWdlL2V2bSk/LmFkZHJlc3MoKSB7CiAgICAgICAgLy8gQ09BIGZvdW5kIC0gY2hlY2sgaWYgdGhlIHB1YmxpYyBjYXBhYmlsaXR5IGlzIHB1Ymxpc2hlZAogICAgICAgIHJldHVybiBnZXRBY2NvdW50KGZsb3dBZGRyZXNzKS5jYXBhYmlsaXRpZXMuYm9ycm93PCZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oL3B1YmxpYy9ldm0pICE9IG5pbAogICAgfQogICAgLy8gTm8gQ09BIGZvdW5kIC0gcmV0dXJuIG5pbAogICAgcmV0dXJuIG5pbAp9", - "coaLink": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY29hTGluayAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IENyeXB0bwppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKaW1wb3J0IEZsb3dUb2tlbiBmcm9tIDB4N2U2MGRmMDQyYTljMDg2OAoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKCi8vLyBUaGlzIHRyYW5zYWN0aW9uIHB1Ymxpc2hlcyBhIHB1YmxpYyAqKnVuZW50aXRsZWQqKiBjYXBhYmlsaXR5IGZvciB0aGUgQ09BIHN0b3JlZCBpbiB0aGUgc2lnbmluZyBhY2NvdW50J3Mgc3RvcmFnZQovLy8gd2hlcmUgYSBDT0EgaGFzIGFscmVhZHkgYmVlbiBzdG9yZWQuCi8vLwp0cmFuc2FjdGlvbiB7CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoQm9ycm93VmFsdWUsIFN0b3JhZ2VDYXBhYmlsaXRpZXMsIFB1Ymxpc2hDYXBhYmlsaXR5LCBVbnB1Ymxpc2hDYXBhYmlsaXR5KSAmQWNjb3VudCkgewogICAgICAgIC8vIEVuc3VyZSBhIENPQSBpcyBzdG9yZWQKICAgICAgICBsZXQgY29hUGF0aCA9IC9zdG9yYWdlL2V2bQogICAgICAgIGxldCBjb2EgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChFVk0uQ2FsbCkgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50Pihmcm9tOiAvc3RvcmFnZS9ldm0pCiAgICAgICAgICAgID8/IHBhbmljKAogICAgICAgICAgICAgICAgIkNvdWxkIG5vdCBmaW5kIENPQSBpbiBzdG9yYWdlIGF0IHBhdGggIi5jb25jYXQoY29hUGF0aC50b1N0cmluZygpKQogICAgICAgICAgICAgICAgLmNvbmNhdCgiLiBNYWtlIHN1cmUgdGhlIHNpZ25pbmcgYWNjb3VudCBoYXMgaW5pdGlhbGl6ZWQgYSBDT0EgYXQgdGhlIGV4cGVjdGVkIHBhdGguIikKICAgICAgICAgICAgKQoKICAgICAgICAvLyBQdWJsaXNoIGEgcHVibGljICoqdW5lbnRpdGxlZCoqIGNhcGFiaWxpdHkKICAgICAgICBsZXQgY29hUHVibGljUGF0aCA9IC9wdWJsaWMvZXZtCiAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy51bnB1Ymxpc2goY29hUHVibGljUGF0aCkKICAgICAgICBsZXQgY29hQ2FwYWJpbGl0eSA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTwmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KGNvYVBhdGgpCiAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5wdWJsaXNoKGNvYUNhcGFiaWxpdHksIGF0OiBjb2FQdWJsaWNQYXRoKQogICAgfQp9", - "createCoa": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY3JlYXRlQ29hIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKaW1wb3J0IEZsb3dUb2tlbiBmcm9tIDB4N2U2MGRmMDQyYTljMDg2OAoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKCgovLy8gQ3JlYXRlcyBhIENPQSBhbmQgc2F2ZXMgaXQgaW4gdGhlIHNpZ25lcidzIEZsb3cgYWNjb3VudCAmIHBhc3NpbmcgdGhlIGdpdmVuIHZhbHVlIG9mIEZsb3cgaW50byBGbG93RVZNCnRyYW5zYWN0aW9uKGFtb3VudDogVUZpeDY0KSB7CiAgICBsZXQgc2VudFZhdWx0OiBARmxvd1Rva2VuLlZhdWx0CiAgICBsZXQgYXV0aDogYXV0aChJc3N1ZVN0b3JhZ2VDYXBhYmlsaXR5Q29udHJvbGxlciwgSXNzdWVTdG9yYWdlQ2FwYWJpbGl0eUNvbnRyb2xsZXIsIFB1Ymxpc2hDYXBhYmlsaXR5LCBTYXZlVmFsdWUsIFVucHVibGlzaENhcGFiaWxpdHkpICZBY2NvdW50CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoQm9ycm93VmFsdWUsIElzc3VlU3RvcmFnZUNhcGFiaWxpdHlDb250cm9sbGVyLCBQdWJsaXNoQ2FwYWJpbGl0eSwgU2F2ZVZhbHVlLCBVbnB1Ymxpc2hDYXBhYmlsaXR5KSAmQWNjb3VudCkgewogICAgICAgIGxldCB2YXVsdFJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZGbG93VG9rZW4uVmF1bHQ+KAogICAgICAgICAgICAgICAgZnJvbTogL3N0b3JhZ2UvZmxvd1Rva2VuVmF1bHQKICAgICAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIG93bmVyJ3MgVmF1bHQhIikKCiAgICAgICAgc2VsZi5zZW50VmF1bHQgPC0gdmF1bHRSZWYud2l0aGRyYXcoYW1vdW50OiBhbW91bnQpIGFzISBARmxvd1Rva2VuLlZhdWx0CiAgICAgICAgc2VsZi5hdXRoID0gc2lnbmVyCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgbGV0IGNvYSA8LSBFVk0uY3JlYXRlQ2FkZW5jZU93bmVkQWNjb3VudCgpCiAgICAgICAgY29hLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKCiAgICAgICAgbG9nKGNvYS5iYWxhbmNlKCkuaW5GTE9XKCkpCiAgICAgICAgbGV0IHN0b3JhZ2VQYXRoID0gU3RvcmFnZVBhdGgoaWRlbnRpZmllcjogImV2bSIpIQogICAgICAgIGxldCBwdWJsaWNQYXRoID0gUHVibGljUGF0aChpZGVudGlmaWVyOiAiZXZtIikhCiAgICAgICAgc2VsZi5hdXRoLnN0b3JhZ2Uuc2F2ZTxARVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KDwtY29hLCB0bzogc3RvcmFnZVBhdGgpCiAgICAgICAgbGV0IGFkZHJlc3NhYmxlQ2FwID0gc2VsZi5hdXRoLmNhcGFiaWxpdGllcy5zdG9yYWdlLmlzc3VlPCZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oc3RvcmFnZVBhdGgpCiAgICAgICAgc2VsZi5hdXRoLmNhcGFiaWxpdGllcy51bnB1Ymxpc2gocHVibGljUGF0aCkKICAgICAgICBzZWxmLmF1dGguY2FwYWJpbGl0aWVzLnB1Ymxpc2goYWRkcmVzc2FibGVDYXAsIGF0OiBwdWJsaWNQYXRoKQogICAgfQp9", - "createCoaEmpty": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY3JlYXRlQ29hRW1wdHkgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHg3ZTYwZGYwNDJhOWMwODY4CgppbXBvcnQgRVZNIGZyb20gMHg4YzUzMDNlYWEyNjIwMmQ2CgoKCi8vLyBDcmVhdGVzIGEgQ09BIGFuZCBzYXZlcyBpdCBpbiB0aGUgc2lnbmVyJ3MgRmxvdyBhY2NvdW50ICYgcGFzc2luZyB0aGUgZ2l2ZW4gdmFsdWUgb2YgRmxvdyBpbnRvIEZsb3dFVk0KdHJhbnNhY3Rpb24oKSB7CiAgICBsZXQgYXV0aDogYXV0aChJc3N1ZVN0b3JhZ2VDYXBhYmlsaXR5Q29udHJvbGxlciwgSXNzdWVTdG9yYWdlQ2FwYWJpbGl0eUNvbnRyb2xsZXIsIFB1Ymxpc2hDYXBhYmlsaXR5LCBTYXZlVmFsdWUsIFVucHVibGlzaENhcGFiaWxpdHkpICZBY2NvdW50CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoQm9ycm93VmFsdWUsIElzc3VlU3RvcmFnZUNhcGFiaWxpdHlDb250cm9sbGVyLCBQdWJsaXNoQ2FwYWJpbGl0eSwgU2F2ZVZhbHVlLCBVbnB1Ymxpc2hDYXBhYmlsaXR5KSAmQWNjb3VudCkgewogICAgICAgIGxldCB2YXVsdFJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZGbG93VG9rZW4uVmF1bHQ+KAogICAgICAgICAgICAgICAgZnJvbTogL3N0b3JhZ2UvZmxvd1Rva2VuVmF1bHQKICAgICAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIG93bmVyJ3MgVmF1bHQhIikKICAgICAgICBzZWxmLmF1dGggPSBzaWduZXIKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBsZXQgY29hIDwtIEVWTS5jcmVhdGVDYWRlbmNlT3duZWRBY2NvdW50KCkKICAgICAgICBsZXQgc3RvcmFnZVBhdGggPSBTdG9yYWdlUGF0aChpZGVudGlmaWVyOiAiZXZtIikhCiAgICAgICAgbGV0IHB1YmxpY1BhdGggPSBQdWJsaWNQYXRoKGlkZW50aWZpZXI6ICJldm0iKSEKICAgICAgICBzZWxmLmF1dGguc3RvcmFnZS5zYXZlPEBFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oPC1jb2EsIHRvOiBzdG9yYWdlUGF0aCkKICAgICAgICBsZXQgYWRkcmVzc2FibGVDYXAgPSBzZWxmLmF1dGguY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8JkVWTS5DYWRlbmNlT3duZWRBY2NvdW50PihzdG9yYWdlUGF0aCkKICAgICAgICBzZWxmLmF1dGguY2FwYWJpbGl0aWVzLnVucHVibGlzaChwdWJsaWNQYXRoKQogICAgICAgIHNlbGYuYXV0aC5jYXBhYmlsaXRpZXMucHVibGlzaChhZGRyZXNzYWJsZUNhcCwgYXQ6IHB1YmxpY1BhdGgpCiAgICB9Cn0\u003d", - "deployContract": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZGVwbG95Q29udHJhY3QgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBFVk0gZnJvbSAweDhjNTMwM2VhYTI2MjAyZDYKCgoKdHJhbnNhY3Rpb24oY29kZTogU3RyaW5nKSB7CiAgICBsZXQgY29hOiBhdXRoKEVWTS5EZXBsb3kpICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudAoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgc2VsZi5jb2EgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChFVk0uRGVwbG95KSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KAogICAgICAgIGZyb206IC9zdG9yYWdlL2V2bSkgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgcmVmZXJlbmNlIHRvIHRoZSBDT0EhIikKCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgIHNlbGYuY29hLmRlcGxveShjb2RlOiBjb2RlLmRlY29kZUhleCgpLCAgZ2FzTGltaXQ6IDE1MDAwMDAwLCB2YWx1ZTogRVZNLkJhbGFuY2UoYXR0b2Zsb3c6IDApKQogICAgfQp9Cg\u003d\u003d", - "estimateGas": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZXN0aW1hdGVHYXMgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBFVk0gZnJvbSAweDhjNTMwM2VhYTI2MjAyZDYKCgphY2Nlc3MoYWxsKQpmdW4gbWFpbihoZXhFbmNvZGVkVHg6IFN0cmluZywgYWRkcmVzczogQWRkcmVzcyk6IFtVSW50NjQ7IDJdIHsKICAgIGxldCBhY2NvdW50ID0gZ2V0QXV0aEFjY291bnQ8YXV0aChTdG9yYWdlKSAmQWNjb3VudD4oYWRkcmVzcykKCiAgICBsZXQgY29hID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzwmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KAogICAgICAgIGZyb206IC9zdG9yYWdlL2V2bQogICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQogICAgbGV0IHR4UmVzdWx0ID0gRVZNLnJ1bih0eDogaGV4RW5jb2RlZFR4LmRlY29kZUhleCgpLCBjb2luYmFzZTogY29hLmFkZHJlc3MoKSkKCiAgICBhc3NlcnQoCiAgICAgICAgdHhSZXN1bHQuc3RhdHVzID09IEVWTS5TdGF0dXMuZmFpbGVkIHx8IHR4UmVzdWx0LnN0YXR1cyA9PSBFVk0uU3RhdHVzLnN1Y2Nlc3NmdWwsCiAgICAgICAgbWVzc2FnZTogImV2bV9lcnJvcj0iLmNvbmNhdCh0eFJlc3VsdC5lcnJvck1lc3NhZ2UpLmNvbmNhdCgiXG4iKQogICAgKQoKICAgIHJldHVybiBbdHhSZXN1bHQuZXJyb3JDb2RlLCB0eFJlc3VsdC5nYXNVc2VkXQp9Cg\u003d\u003d", - "fundCoa": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZnVuZENvYSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDdlNjBkZjA0MmE5YzA4NjgKCmltcG9ydCBFVk0gZnJvbSAweDhjNTMwM2VhYTI2MjAyZDYKCgp0cmFuc2FjdGlvbihhbW91bnQ6IFVGaXg2NCkgewogICAgbGV0IHNlbnRWYXVsdDogQEZsb3dUb2tlbi5WYXVsdAogICAgbGV0IGF1dGg6IGF1dGgoU3RvcmFnZSkgJkFjY291bnQKICAgIGxldCBjb2E6ICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudAoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IHZhdWx0UmVmID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJkZsb3dUb2tlbi5WYXVsdD4oCiAgICAgICAgICAgIGZyb206IC9zdG9yYWdlL2Zsb3dUb2tlblZhdWx0CiAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIG93bmVyJ3MgVmF1bHQhIikKCgogICAgICAgIGxldCBjb2EgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8JkVWTS5DYWRlbmNlT3duZWRBY2NvdW50PigKICAgICAgICAgICAgZnJvbTogL3N0b3JhZ2UvZXZtCiAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQoKICAgICAgICBzZWxmLnNlbnRWYXVsdCA8LSB2YXVsdFJlZi53aXRoZHJhdyhhbW91bnQ6IGFtb3VudCkgYXMhIEBGbG93VG9rZW4uVmF1bHQKICAgICAgICBzZWxmLmF1dGggPSBzaWduZXIKICAgICAgICBzZWxmLmNvYSA9IGNvYQogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIHNlbGYuY29hLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKICAgIH0KfQo\u003d", - "fundEvmAddr": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZnVuZEV2bUFkZHIgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHg3ZTYwZGYwNDJhOWMwODY4CgppbXBvcnQgRVZNIGZyb20gMHg4YzUzMDNlYWEyNjIwMmQ2CgoKdHJhbnNhY3Rpb24oZXZtQWRkcjogU3RyaW5nLCBhbW91bnQ6IFVGaXg2NCkgewoKICAgIC8vIFRoZSBWYXVsdCByZXNvdXJjZSB0aGF0IGhvbGRzIHRoZSB0b2tlbnMgdGhhdCBhcmUgYmVpbmcgdHJhbnNmZXJlZAogICAgbGV0IHNlbnRWYXVsdDogQHtGdW5naWJsZVRva2VuLlZhdWx0fQoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgICAvLyBHZXQgYSByZWZlcmVuY2UgdG8gdGhlIHNpZ25lcidzIHN0b3JlZCB2YXVsdAogICAgICAgIGxldCB2YXVsdFJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICY8VG9rZW4+LlZhdWx0Pihmcm9tOiA8VG9rZW5TdG9yYWdlUGF0aD4pCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IHJlZmVyZW5jZSB0byB0aGUgb3duZXIncyBWYXVsdCEiKQoKICAgICAgICAvLyBXaXRoZHJhdyB0b2tlbnMgZnJvbSB0aGUgc2lnbmVyJ3Mgc3RvcmVkIHZhdWx0CiAgICAgICAgc2VsZi5zZW50VmF1bHQgPC0gdmF1bHRSZWYud2l0aGRyYXcoYW1vdW50OiBhbW91bnQpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgLy8gR2V0IHRoZSByZWNpcGllbnQncyBwdWJsaWMgYWNjb3VudCBvYmplY3QKICAgICAgICBsZXQgcmVjaXBpZW50QWNjb3VudCA9IGdldEFjY291bnQocmVjaXBpZW50KQoKICAgICAgICAvLyBHZXQgYSByZWZlcmVuY2UgdG8gdGhlIHJlY2lwaWVudCdzIFJlY2VpdmVyCiAgICAgICAgbGV0IHJlY2VpdmVyUmVmID0gcmVjaXBpZW50QWNjb3VudC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5SZWNlaXZlcn0+KDxUb2tlblJlY2VpdmVyUGF0aD4pIQogICAgICAgICAgICAKICAgICAgICAvLyBEZXBvc2l0IHRoZSB3aXRoZHJhd24gdG9rZW5zIGluIHRoZSByZWNpcGllbnQncyByZWNlaXZlcgogICAgICAgIHJlY2VpdmVyUmVmLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKICAgIH0KfQ\u003d\u003d", - "getAddr": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QWRkciAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGZsb3dBZGRyZXNzOiBBZGRyZXNzKTogU3RyaW5nPyB7CiAgICBpZiBsZXQgYWRkcmVzczogRVZNLkVWTUFkZHJlc3MgPSBnZXRBdXRoQWNjb3VudDxhdXRoKEJvcnJvd1ZhbHVlKSAmQWNjb3VudD4oZmxvd0FkZHJlc3MpCiAgICAgICAgLnN0b3JhZ2UuYm9ycm93PCZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oZnJvbTogL3N0b3JhZ2UvZXZtKT8uYWRkcmVzcygpIHsKICAgICAgICBsZXQgYnl0ZXM6IFtVSW50OF0gPSBbXQogICAgICAgIGZvciBieXRlIGluIGFkZHJlc3MuYnl0ZXMgewogICAgICAgICAgICBieXRlcy5hcHBlbmQoYnl0ZSkKICAgICAgICB9CiAgICAgICAgcmV0dXJuIFN0cmluZy5lbmNvZGVIZXgoYnl0ZXMpCiAgICB9CiAgICByZXR1cm4gbmlsCn0\u003d", - "getBalance": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QmFsYW5jZSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKCmFjY2VzcyhhbGwpCmZ1biBtYWluKGhleEVuY29kZWRBZGRyZXNzOiBTdHJpbmcpOiBVSW50IHsKICAgIGxldCBhZGRyZXNzQnl0ZXMgPSBoZXhFbmNvZGVkQWRkcmVzcy5kZWNvZGVIZXgoKS50b0NvbnN0YW50U2l6ZWQ8W1VJbnQ4OyAyMF0+KCkhCiAgICBsZXQgYWRkcmVzcyA9IEVWTS5FVk1BZGRyZXNzKGJ5dGVzOiBhZGRyZXNzQnl0ZXMpCgogICAgcmV0dXJuIGFkZHJlc3MuYmFsYW5jZSgpLmluQXR0b0ZMT1coKQp9Cg\u003d\u003d", - "getCoaAddr": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0Q29hQWRkciAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKCmFjY2VzcyhhbGwpCmZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBTdHJpbmcgewogICAgbGV0IGFjY291bnQgPSBnZXRBdXRoQWNjb3VudDxhdXRoKFN0b3JhZ2UpICZBY2NvdW50PihhZGRyZXNzKQoKICAgIGxldCBjb2EgPSBhY2NvdW50LnN0b3JhZ2UuYm9ycm93PCZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oCiAgICAgICAgZnJvbTogL3N0b3JhZ2UvZXZtCiAgICApCgogICAgaWYgY29hID09IG5pbCB7IAogICAgICAgIHJldHVybiAiIgogICAgfSBlbHNlIHsKICAgICAgICBsZXQgY29hQWRkciA9IGNvYT8uYWRkcmVzcygpIAoKICAgICAgICBsZXQgYWRkckJ5dGU6IFtVSW50OF0gPSBbXQoKICAgICAgICBmb3IgYnl0ZSBpbiBjb2FBZGRyPy5ieXRlcyEgewogICAgICAgICAgICBhZGRyQnl0ZS5hcHBlbmQoYnl0ZSkKICAgICAgICB9CgogICAgICAgIHJldHVybiBTdHJpbmcuZW5jb2RlSGV4KGFkZHJCeXRlKQogICAgfQp9Cg\u003d\u003d", - "getCoaBalance": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0Q29hQmFsYW5jZSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKCmFjY2VzcyhhbGwpCmZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBVRml4NjQgewogICAgIGxldCBhY2NvdW50ID0gZ2V0QXV0aEFjY291bnQ8YXV0aChTdG9yYWdlKSAmQWNjb3VudD4oYWRkcmVzcykKCiAgICBsZXQgY29hID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzwmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KAogICAgICAgIGZyb206IC9zdG9yYWdlL2V2bQogICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQogICAgCiAgICByZXR1cm4gY29hLmJhbGFuY2UoKS5pbkZMT1coKQp9Cg\u003d\u003d", - "getCode": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0Q29kZSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKCmFjY2VzcyhhbGwpCmZ1biBtYWluKGhleEVuY29kZWRBZGRyZXNzOiBTdHJpbmcpOiBTdHJpbmcgewogICAgbGV0IGFkZHJlc3NCeXRlcyA9IGhleEVuY29kZWRBZGRyZXNzLmRlY29kZUhleCgpLnRvQ29uc3RhbnRTaXplZDxbVUludDg7IDIwXT4oKSEKICAgIGxldCBhZGRyZXNzID0gRVZNLkVWTUFkZHJlc3MoYnl0ZXM6IGFkZHJlc3NCeXRlcykKCiAgICByZXR1cm4gU3RyaW5nLmVuY29kZUhleChhZGRyZXNzLmNvZGUoKSkKfQo\u003d", - "getNonce": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0Tm9uY2UgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBFVk0gZnJvbSAweDhjNTMwM2VhYTI2MjAyZDYKCgphY2Nlc3MoYWxsKQpmdW4gbWFpbihoZXhFbmNvZGVkQWRkcmVzczogU3RyaW5nKTogVUludDY0IHsKICAgIGxldCBhZGRyZXNzQnl0ZXMgPSBoZXhFbmNvZGVkQWRkcmVzcy5kZWNvZGVIZXgoKS50b0NvbnN0YW50U2l6ZWQ8W1VJbnQ4OyAyMF0+KCkhCiAgICBsZXQgYWRkcmVzcyA9IEVWTS5FVk1BZGRyZXNzKGJ5dGVzOiBhZGRyZXNzQnl0ZXMpCgogICAgcmV0dXJuIGFkZHJlc3Mubm9uY2UoKQp9Cg\u003d\u003d", - "newAccountAndCoa": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgbmV3QWNjb3VudEFuZENvYSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IENyeXB0bwppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKaW1wb3J0IEZsb3dUb2tlbiBmcm9tIDB4N2U2MGRmMDQyYTljMDg2OAoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKCnRyYW5zYWN0aW9uKHB1YmxpY0tleTogU3RyaW5nLCBzaWduYXR1cmVBbGdvcml0aG06IFVJbnQ4LCBoYXNoQWxnb3JpdGhtOiBVSW50OCwgd2VpZ2h0OiBVRml4NjQpIHsKICAgIGxldCBzZW50VmF1bHQ6IEBGbG93VG9rZW4uVmF1bHQKICAgIGxldCBhdXRoOiBhdXRoKFN0b3JhZ2UpICZBY2NvdW50CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSkgJkFjY291bnQpIHsKCiAgICAgICAgbGV0IGFjY291bnQgPSBBY2NvdW50KHBheWVyOiBzaWduZXIpCgogICAgICAgIGxldCBrZXkgPSBQdWJsaWNLZXkoCiAgICAgICAgICAgIHB1YmxpY0tleTogcHVibGljS2V5LmRlY29kZUhleCgpLAogICAgICAgICAgICBzaWduYXR1cmVBbGdvcml0aG06IFNpZ25hdHVyZUFsZ29yaXRobShyYXdWYWx1ZTogc2lnbmF0dXJlQWxnb3JpdGhtKSEKICAgICAgICApCgogICAgICAgIGFjY291bnQua2V5cy5hZGQocHVibGljS2V5OiBrZXksIGhhc2hBbGdvcml0aG06IEhhc2hBbGdvcml0aG0ocmF3VmFsdWU6IGhhc2hBbGdvcml0aG0pISwgd2VpZ2h0OiB3ZWlnaHQpCgkJCiAgICAgICAgbGV0IHZhdWx0UmVmID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZGbG93VG9rZW4uVmF1bHQ+KAogICAgICAgICAgICBmcm9tOiAvc3RvcmFnZS9mbG93VG9rZW5WYXVsdAogICAgICAgICkgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgcmVmZXJlbmNlIHRvIHRoZSBvd25lcidzIFZhdWx0ISIpCgogICAgICAgIHNlbGYuc2VudFZhdWx0IDwtIHZhdWx0UmVmLndpdGhkcmF3KGFtb3VudDogMC4wKSBhcyEgQEZsb3dUb2tlbi5WYXVsdAogICAgICAgIHNlbGYuYXV0aCA9IGFjY291bnQKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBsZXQgYWNjb3VudCA8LSBFVk0uY3JlYXRlQ2FkZW5jZU93bmVkQWNjb3VudCgpCiAgICAgICAgbG9nKGFjY291bnQuYWRkcmVzcygpKQogICAgICAgIGFjY291bnQuZGVwb3NpdChmcm9tOiA8LXNlbGYuc2VudFZhdWx0KQoKICAgICAgICBsb2coYWNjb3VudC5iYWxhbmNlKCkpCiAgICAgICAgc2VsZi5hdXRoLnN0b3JhZ2Uuc2F2ZTxARVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KDwtYWNjb3VudCwgdG86IFN0b3JhZ2VQYXRoKGlkZW50aWZpZXI6ICJldm0iKSEpCiAgICB9Cn0K", - "removeCoa": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcmVtb3ZlQ29hIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRVZNIGZyb20gMHg4YzUzMDNlYWEyNjIwMmQ2CgoKdHJhbnNhY3Rpb24oKSB7CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSwgVW5wdWJsaXNoQ2FwYWJpbGl0eSkgJkFjY291bnQpIHsKICAgICAgICBsZXQgY29hUmVmID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PCZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oCiAgICAgICAgICAgIGZyb206IC9zdG9yYWdlL2V2bQogICAgICAgICkgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgcmVmZXJlbmNlIHRvIHRoZSBDT0EhIikKICAgICAgICBpZiBjb2FSZWYgIT0gbmlsIHsKICAgICAgICAgICAgbGV0IGNvYSA8LSBzaWduZXIuc3RvcmFnZS5sb2FkPEBFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oZnJvbTogL3N0b3JhZ2UvZXZtKSAKICAgICAgICAgICAgbGV0IHB1YmxpY1BhdGggPSBQdWJsaWNQYXRoKGlkZW50aWZpZXI6ICJldm0iKSEKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy51bnB1Ymxpc2gocHVibGljUGF0aCkKICAgICAgICAgICAgZGVzdHJveSBjb2EKICAgICAgICB9CiAgICB9Cn0K", - "run": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcnVuIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRVZNIGZyb20gMHg4YzUzMDNlYWEyNjIwMmQ2CgoKdHJhbnNhY3Rpb24oaGV4RW5jb2RlZFR4OiBTdHJpbmcpIHsKICAgIGxldCBjb2E6ICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudAoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgc2VsZi5jb2EgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8JkVWTS5DYWRlbmNlT3duZWRBY2NvdW50PigKICAgICAgICAgICAgZnJvbTogL3N0b3JhZ2UvZXZtCiAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIGxldCB0eFJlc3VsdCA9IEVWTS5ydW4odHg6IGhleEVuY29kZWRUeC5kZWNvZGVIZXgoKSwgY29pbmJhc2U6IHNlbGYuY29hLmFkZHJlc3MoKSkKICAgICAgICAvLyB0b2RvIG9ubHkgdGVtcG9yYXJ5IHVudGlsIHdlIGNvcnJlY3RseSBoYW5kbGUgZmFpbHVyZSBldmVudHMKICAgICAgICBhc3NlcnQoCiAgICAgICAgICAgIHR4UmVzdWx0LnN0YXR1cyA9PSBFVk0uU3RhdHVzLmZhaWxlZCB8fCB0eFJlc3VsdC5zdGF0dXMgPT0gRVZNLlN0YXR1cy5zdWNjZXNzZnVsLAogICAgICAgICAgICBtZXNzYWdlOiAiZXZtX2Vycm9yPSIuY29uY2F0KHR4UmVzdWx0LmVycm9yTWVzc2FnZSkuY29uY2F0KCJcbiIpCiAgICAgICAgKQogICAgfQp9Cg\u003d\u003d", - "transferCoa": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdHJhbnNmZXJDb2EgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHg3ZTYwZGYwNDJhOWMwODY4CgppbXBvcnQgRVZNIGZyb20gMHg4YzUzMDNlYWEyNjIwMmQ2CgoKdHJhbnNhY3Rpb24oYW1vdW50OiBVRml4NjQsIGFkZHJlc3M6IEFkZHJlc3MpIHsKICAgIGxldCBzZW50VmF1bHQ6IEBGbG93VG9rZW4uVmF1bHQKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChTdG9yYWdlLCBFVk0uV2l0aGRyYXcpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IGNvYSA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEVWTS5XaXRoZHJhdykgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50PigKICAgICAgICAgICAgZnJvbTogL3N0b3JhZ2UvZXZtCiAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQoKICAgICAgICBzZWxmLnNlbnRWYXVsdCA8LSBjb2Eud2l0aGRyYXcoYmFsYW5jZTogRVZNLkJhbGFuY2UoYXR0b2Zsb3c6IFVJbnQoYW1vdW50KSAqIDEwMDAwMDAwMDAwMDAwMDAwMCkpIGFzISBARmxvd1Rva2VuLlZhdWx0CiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAgbGV0IHJlY2VpdmVyID0gYWNjb3VudC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5SZWNlaXZlcn0+KC9wdWJsaWMvZmxvd1Rva2VuUmVjZWl2ZXIpIQogICAgICAgIHJlY2VpdmVyLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKICAgIH0KfQo\u003d", - "transferFlowFromCoaToFlow": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdHJhbnNmZXJGbG93RnJvbUNvYVRvRmxvdyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDdlNjBkZjA0MmE5YzA4NjgKCmltcG9ydCBFVk0gZnJvbSAweDhjNTMwM2VhYTI2MjAyZDYKCgp0cmFuc2FjdGlvbihhbW91bnQ6IFVGaXg2NCwgYWRkcmVzczogQWRkcmVzcykgewogICAgbGV0IHNlbnRWYXVsdDogQEZsb3dUb2tlbi5WYXVsdAoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIEVWTS5XaXRoZHJhdykgJkFjY291bnQpIHsKICAgICAgICBsZXQgY29hID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoRVZNLldpdGhkcmF3KSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KAogICAgICAgICAgICBmcm9tOiAvc3RvcmFnZS9ldm0KICAgICAgICApID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IHJlZmVyZW5jZSB0byB0aGUgQ09BISIpCiAgICAgICAgbGV0IHdpdGhkcmF3QmFsYW5jZSA9IEVWTS5CYWxhbmNlKGF0dG9mbG93OiAwKQogICAgICAgIHdpdGhkcmF3QmFsYW5jZS5zZXRGTE9XKGZsb3c6IGFtb3VudCkKICAgICAgICBzZWxmLnNlbnRWYXVsdCA8LSBjb2Eud2l0aGRyYXcoYmFsYW5jZTogd2l0aGRyYXdCYWxhbmNlKSBhcyEgQEZsb3dUb2tlbi5WYXVsdAogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgIGxldCByZWNlaXZlciA9IGFjY291bnQuY2FwYWJpbGl0aWVzLmJvcnJvdzwme0Z1bmdpYmxlVG9rZW4uUmVjZWl2ZXJ9PigvcHVibGljL2Zsb3dUb2tlblJlY2VpdmVyKSEKICAgICAgICByZWNlaXZlci5kZXBvc2l0KGZyb206IDwtc2VsZi5zZW50VmF1bHQpCiAgICB9Cn0K", - "transferFlowToEvmAddress": "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", - "withdrawCoa": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgd2l0aGRyYXdDb2EgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHg3ZTYwZGYwNDJhOWMwODY4CgppbXBvcnQgRVZNIGZyb20gMHg4YzUzMDNlYWEyNjIwMmQ2CgoKdHJhbnNhY3Rpb24oYW1vdW50OiBVRml4NjQsIGFkZHJlc3M6IEFkZHJlc3MpIHsKICAgIGxldCBzZW50VmF1bHQ6IEBGbG93VG9rZW4uVmF1bHQKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChTdG9yYWdlLCBFVk0uV2l0aGRyYXcpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IGNvYSA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEVWTS5XaXRoZHJhdykgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50PigKICAgICAgICAgICAgZnJvbTogL3N0b3JhZ2UvZXZtCiAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQogICAgICAgIGxldCB3aXRoZHJhd0JhbGFuY2UgPSBFVk0uQmFsYW5jZShhdHRvZmxvdzogMCkKICAgICAgICB3aXRoZHJhd0JhbGFuY2Uuc2V0RkxPVyhmbG93OiBhbW91bnQpCiAgICAgICAgc2VsZi5zZW50VmF1bHQgPC0gY29hLndpdGhkcmF3KGJhbGFuY2U6IHdpdGhkcmF3QmFsYW5jZSkgYXMhIEBGbG93VG9rZW4uVmF1bHQKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBsZXQgYWNjb3VudCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgICBsZXQgcmVjZWl2ZXIgPSBhY2NvdW50LmNhcGFiaWxpdGllcy5ib3Jyb3c8JntGdW5naWJsZVRva2VuLlJlY2VpdmVyfT4oL3B1YmxpYy9mbG93VG9rZW5SZWNlaXZlcikhCiAgICAgICAgcmVjZWl2ZXIuZGVwb3NpdChmcm9tOiA8LXNlbGYuc2VudFZhdWx0KQogICAgfQp9Cg\u003d\u003d" + "batchEoaCallContract": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYmF0Y2hFb2FDYWxsQ29udHJhY3QgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHg3ZTYwZGYwNDJhOWMwODY4CgppbXBvcnQgRVZNIGZyb20gMHg4YzUzMDNlYWEyNjIwMmQ2CgoKdHJhbnNhY3Rpb24ocmxwRW5jb2RlZFRyYW5zYWN0aW9uczogW1tVSW50OF1dLCAgY29pbmJhc2VBZGRyOiBTdHJpbmcpIHsKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChTdG9yYWdlLCBFVk0uV2l0aGRyYXcpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IGNvaW5iYXNlID0gRVZNLmFkZHJlc3NGcm9tU3RyaW5nKGNvaW5iYXNlQWRkcikKCiAgICAgICAgZm9yIGluZGV4LCBybHBFbmNvZGVkVHJhbnNhY3Rpb24gaW4gcmxwRW5jb2RlZFRyYW5zYWN0aW9ucyB7CiAgICAgICAgICAgIGxldCBydW5SZXN1bHQgPSBFVk0ucnVuKHR4OiBybHBFbmNvZGVkVHJhbnNhY3Rpb24sIGNvaW5iYXNlOiBjb2luYmFzZSkKICAgICAgICAgICAgYXNzZXJ0KAogICAgICAgICAgICAgICAgcnVuUmVzdWx0LnN0YXR1cyA9PSBFVk0uU3RhdHVzLnN1Y2Nlc3NmdWwsCiAgICAgICAgICAgICAgICBtZXNzYWdlOiAiZXZtIHR4IHdhcyBub3QgZXhlY3V0ZWQgc3VjY2Vzc2Z1bGx5LiIKICAgICAgICAgICAgKQogICAgICAgIH0KICAgIH0KICAgIAogICAgZXhlY3V0ZSB7CiAgICB9Cn0K", + "call": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY2FsbCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKCmFjY2VzcyhhbGwpCmZ1biBtYWluKGhleEVuY29kZWREYXRhOiBTdHJpbmcsIGhleEVuY29kZWRBZGRyZXNzOiBTdHJpbmcpOiBTdHJpbmcgewogICAgbGV0IGFjY291bnQgPSBnZXRBdXRoQWNjb3VudDxhdXRoKFN0b3JhZ2UpICZBY2NvdW50PihBZGRyZXNzKDB4Q09BKSkKCiAgICBsZXQgY29hID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzxhdXRoKEVWTS5DYWxsKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KAogICAgICAgIGZyb206IC9zdG9yYWdlL2V2bQogICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQogICAgbGV0IGFkZHJlc3NCeXRlcyA9IGhleEVuY29kZWRBZGRyZXNzLmRlY29kZUhleCgpLnRvQ29uc3RhbnRTaXplZDxbVUludDg7IDIwXT4oKSEKCiAgICBsZXQgdHhSZXN1bHQgPSBjb2EuY2FsbCgKICAgICAgICB0bzogRVZNLkVWTUFkZHJlc3MoYnl0ZXM6IGFkZHJlc3NCeXRlcyksCiAgICAgICAgZGF0YTogaGV4RW5jb2RlZERhdGEuZGVjb2RlSGV4KCksCiAgICAgICAgZ2FzTGltaXQ6IDE1MDAwMDAwLCAvLyB0b2RvIG1ha2UgaXQgY29uZmlndXJhYmxlLCBtYXggZm9yIG5vdwogICAgICAgIHZhbHVlOiBFVk0uQmFsYW5jZShhdHRvZmxvdzogMCkKICAgICkKCiAgICBhc3NlcnQoCiAgICAgICAgdHhSZXN1bHQuc3RhdHVzID09IEVWTS5TdGF0dXMuZmFpbGVkIHx8IHR4UmVzdWx0LnN0YXR1cyA9PSBFVk0uU3RhdHVzLnN1Y2Nlc3NmdWwsCiAgICAgICAgbWVzc2FnZTogImV2bV9lcnJvcj0iLmNvbmNhdCh0eFJlc3VsdC5lcnJvck1lc3NhZ2UpLmNvbmNhdCgiXG4iKQogICAgKQoKICAgIHJldHVybiBTdHJpbmcuZW5jb2RlSGV4KGNhbGxSZXN1bHQuZGF0YSkKfQo\u003d", + "callContract": "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\u003d\u003d", + "callContractV2": "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", + "checkCoaLink": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY2hlY2tDb2FMaW5rIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRVZNIGZyb20gMHg4YzUzMDNlYWEyNjIwMmQ2CgoKLy8vIFJldHVybnMgd2hldGhlciBhIENPQSBpcyBzdG9yZWQgYW5kIGl0cyBwdWJsaWMgY2FwYWJpbGl0eSBpcyBwdWJsaXNoZWQKLy8vCi8vLyBAcGFyYW0gZmxvd0FkZHJlc3M6IFRoZSBGbG93IGFkZHJlc3MgdG8gY2hlY2sgZm9yIGEgQ09BCi8vLwovLy8gQHJldHVybiBCb29sOiBXaGV0aGVyIGEgQ09BIGlzIHN0b3JlZCBhbmQgaXRzIHB1YmxpYyBjYXBhYmlsaXR5IGlzIHB1Ymxpc2hlZCwgbmlsIGlmIG5vIENPQSBpcyBzdG9yZWQKLy8vCmFjY2VzcyhhbGwpIGZ1biBtYWluKGZsb3dBZGRyZXNzOiBBZGRyZXNzKTogQm9vbD8gewogICAgLy8gQm9ycm93IHRoZSBDT0EgdG8gY2hlY2sgaWYgb25lIGlzIHN0b3JlZAogICAgaWYgbGV0IGFkZHJlc3M6IEVWTS5FVk1BZGRyZXNzID0gZ2V0QXV0aEFjY291bnQ8YXV0aChCb3Jyb3dWYWx1ZSkgJkFjY291bnQ+KGZsb3dBZGRyZXNzKQogICAgICAgIC5zdG9yYWdlLmJvcnJvdzwmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KGZyb206IC9zdG9yYWdlL2V2bSk/LmFkZHJlc3MoKSB7CiAgICAgICAgLy8gQ09BIGZvdW5kIC0gY2hlY2sgaWYgdGhlIHB1YmxpYyBjYXBhYmlsaXR5IGlzIHB1Ymxpc2hlZAogICAgICAgIHJldHVybiBnZXRBY2NvdW50KGZsb3dBZGRyZXNzKS5jYXBhYmlsaXRpZXMuYm9ycm93PCZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oL3B1YmxpYy9ldm0pICE9IG5pbAogICAgfQogICAgLy8gTm8gQ09BIGZvdW5kIC0gcmV0dXJuIG5pbAogICAgcmV0dXJuIG5pbAp9", + "coaLink": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY29hTGluayAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IENyeXB0bwppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKaW1wb3J0IEZsb3dUb2tlbiBmcm9tIDB4N2U2MGRmMDQyYTljMDg2OAoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKCi8vLyBUaGlzIHRyYW5zYWN0aW9uIHB1Ymxpc2hlcyBhIHB1YmxpYyAqKnVuZW50aXRsZWQqKiBjYXBhYmlsaXR5IGZvciB0aGUgQ09BIHN0b3JlZCBpbiB0aGUgc2lnbmluZyBhY2NvdW50J3Mgc3RvcmFnZQovLy8gd2hlcmUgYSBDT0EgaGFzIGFscmVhZHkgYmVlbiBzdG9yZWQuCi8vLwp0cmFuc2FjdGlvbiB7CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoQm9ycm93VmFsdWUsIFN0b3JhZ2VDYXBhYmlsaXRpZXMsIFB1Ymxpc2hDYXBhYmlsaXR5LCBVbnB1Ymxpc2hDYXBhYmlsaXR5KSAmQWNjb3VudCkgewogICAgICAgIC8vIEVuc3VyZSBhIENPQSBpcyBzdG9yZWQKICAgICAgICBsZXQgY29hUGF0aCA9IC9zdG9yYWdlL2V2bQogICAgICAgIGxldCBjb2EgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChFVk0uQ2FsbCkgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50Pihmcm9tOiAvc3RvcmFnZS9ldm0pCiAgICAgICAgICAgID8/IHBhbmljKAogICAgICAgICAgICAgICAgIkNvdWxkIG5vdCBmaW5kIENPQSBpbiBzdG9yYWdlIGF0IHBhdGggIi5jb25jYXQoY29hUGF0aC50b1N0cmluZygpKQogICAgICAgICAgICAgICAgLmNvbmNhdCgiLiBNYWtlIHN1cmUgdGhlIHNpZ25pbmcgYWNjb3VudCBoYXMgaW5pdGlhbGl6ZWQgYSBDT0EgYXQgdGhlIGV4cGVjdGVkIHBhdGguIikKICAgICAgICAgICAgKQoKICAgICAgICAvLyBQdWJsaXNoIGEgcHVibGljICoqdW5lbnRpdGxlZCoqIGNhcGFiaWxpdHkKICAgICAgICBsZXQgY29hUHVibGljUGF0aCA9IC9wdWJsaWMvZXZtCiAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy51bnB1Ymxpc2goY29hUHVibGljUGF0aCkKICAgICAgICBsZXQgY29hQ2FwYWJpbGl0eSA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTwmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KGNvYVBhdGgpCiAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5wdWJsaXNoKGNvYUNhcGFiaWxpdHksIGF0OiBjb2FQdWJsaWNQYXRoKQogICAgfQp9", + "createCoa": "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", + "createCoaEmpty": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY3JlYXRlQ29hRW1wdHkgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHg3ZTYwZGYwNDJhOWMwODY4CgppbXBvcnQgRVZNIGZyb20gMHg4YzUzMDNlYWEyNjIwMmQ2CgoKCi8vLyBDcmVhdGVzIGEgQ09BIGFuZCBzYXZlcyBpdCBpbiB0aGUgc2lnbmVyJ3MgRmxvdyBhY2NvdW50ICYgcGFzc2luZyB0aGUgZ2l2ZW4gdmFsdWUgb2YgRmxvdyBpbnRvIEZsb3dFVk0KdHJhbnNhY3Rpb24oKSB7CiAgICBsZXQgYXV0aDogYXV0aChJc3N1ZVN0b3JhZ2VDYXBhYmlsaXR5Q29udHJvbGxlciwgSXNzdWVTdG9yYWdlQ2FwYWJpbGl0eUNvbnRyb2xsZXIsIFB1Ymxpc2hDYXBhYmlsaXR5LCBTYXZlVmFsdWUsIFVucHVibGlzaENhcGFiaWxpdHkpICZBY2NvdW50CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoQm9ycm93VmFsdWUsIElzc3VlU3RvcmFnZUNhcGFiaWxpdHlDb250cm9sbGVyLCBQdWJsaXNoQ2FwYWJpbGl0eSwgU2F2ZVZhbHVlLCBVbnB1Ymxpc2hDYXBhYmlsaXR5KSAmQWNjb3VudCkgewogICAgICAgIGxldCB2YXVsdFJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZGbG93VG9rZW4uVmF1bHQ+KAogICAgICAgICAgICAgICAgZnJvbTogL3N0b3JhZ2UvZmxvd1Rva2VuVmF1bHQKICAgICAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIG93bmVyJ3MgVmF1bHQhIikKICAgICAgICBzZWxmLmF1dGggPSBzaWduZXIKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBsZXQgY29hIDwtIEVWTS5jcmVhdGVDYWRlbmNlT3duZWRBY2NvdW50KCkKICAgICAgICBsZXQgc3RvcmFnZVBhdGggPSBTdG9yYWdlUGF0aChpZGVudGlmaWVyOiAiZXZtIikhCiAgICAgICAgbGV0IHB1YmxpY1BhdGggPSBQdWJsaWNQYXRoKGlkZW50aWZpZXI6ICJldm0iKSEKICAgICAgICBzZWxmLmF1dGguc3RvcmFnZS5zYXZlPEBFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oPC1jb2EsIHRvOiBzdG9yYWdlUGF0aCkKICAgICAgICBsZXQgYWRkcmVzc2FibGVDYXAgPSBzZWxmLmF1dGguY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8JkVWTS5DYWRlbmNlT3duZWRBY2NvdW50PihzdG9yYWdlUGF0aCkKICAgICAgICBzZWxmLmF1dGguY2FwYWJpbGl0aWVzLnVucHVibGlzaChwdWJsaWNQYXRoKQogICAgICAgIHNlbGYuYXV0aC5jYXBhYmlsaXRpZXMucHVibGlzaChhZGRyZXNzYWJsZUNhcCwgYXQ6IHB1YmxpY1BhdGgpCiAgICB9Cn0\u003d", + "deployContract": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZGVwbG95Q29udHJhY3QgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBFVk0gZnJvbSAweDhjNTMwM2VhYTI2MjAyZDYKCgoKdHJhbnNhY3Rpb24oY29kZTogU3RyaW5nKSB7CiAgICBsZXQgY29hOiBhdXRoKEVWTS5EZXBsb3kpICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudAoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgc2VsZi5jb2EgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChFVk0uRGVwbG95KSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KAogICAgICAgIGZyb206IC9zdG9yYWdlL2V2bSkgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgcmVmZXJlbmNlIHRvIHRoZSBDT0EhIikKCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgIHNlbGYuY29hLmRlcGxveShjb2RlOiBjb2RlLmRlY29kZUhleCgpLCAgZ2FzTGltaXQ6IDE1MDAwMDAwLCB2YWx1ZTogRVZNLkJhbGFuY2UoYXR0b2Zsb3c6IDApKQogICAgfQp9Cg\u003d\u003d", + "estimateGas": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZXN0aW1hdGVHYXMgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBFVk0gZnJvbSAweDhjNTMwM2VhYTI2MjAyZDYKCgphY2Nlc3MoYWxsKQpmdW4gbWFpbihoZXhFbmNvZGVkVHg6IFN0cmluZywgYWRkcmVzczogQWRkcmVzcyk6IFtVSW50NjQ7IDJdIHsKICAgIGxldCBhY2NvdW50ID0gZ2V0QXV0aEFjY291bnQ8YXV0aChTdG9yYWdlKSAmQWNjb3VudD4oYWRkcmVzcykKCiAgICBsZXQgY29hID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzwmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KAogICAgICAgIGZyb206IC9zdG9yYWdlL2V2bQogICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQogICAgbGV0IHR4UmVzdWx0ID0gRVZNLnJ1bih0eDogaGV4RW5jb2RlZFR4LmRlY29kZUhleCgpLCBjb2luYmFzZTogY29hLmFkZHJlc3MoKSkKCiAgICBhc3NlcnQoCiAgICAgICAgdHhSZXN1bHQuc3RhdHVzID09IEVWTS5TdGF0dXMuZmFpbGVkIHx8IHR4UmVzdWx0LnN0YXR1cyA9PSBFVk0uU3RhdHVzLnN1Y2Nlc3NmdWwsCiAgICAgICAgbWVzc2FnZTogImV2bV9lcnJvcj0iLmNvbmNhdCh0eFJlc3VsdC5lcnJvck1lc3NhZ2UpLmNvbmNhdCgiXG4iKQogICAgKQoKICAgIHJldHVybiBbdHhSZXN1bHQuZXJyb3JDb2RlLCB0eFJlc3VsdC5nYXNVc2VkXQp9Cg\u003d\u003d", + "fundCoa": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZnVuZENvYSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDdlNjBkZjA0MmE5YzA4NjgKCmltcG9ydCBFVk0gZnJvbSAweDhjNTMwM2VhYTI2MjAyZDYKCgp0cmFuc2FjdGlvbihhbW91bnQ6IFVGaXg2NCkgewogICAgbGV0IHNlbnRWYXVsdDogQEZsb3dUb2tlbi5WYXVsdAogICAgbGV0IGF1dGg6IGF1dGgoU3RvcmFnZSkgJkFjY291bnQKICAgIGxldCBjb2E6ICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudAoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IHZhdWx0UmVmID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJkZsb3dUb2tlbi5WYXVsdD4oCiAgICAgICAgICAgIGZyb206IC9zdG9yYWdlL2Zsb3dUb2tlblZhdWx0CiAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIG93bmVyJ3MgVmF1bHQhIikKCgogICAgICAgIGxldCBjb2EgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8JkVWTS5DYWRlbmNlT3duZWRBY2NvdW50PigKICAgICAgICAgICAgZnJvbTogL3N0b3JhZ2UvZXZtCiAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQoKICAgICAgICBzZWxmLnNlbnRWYXVsdCA8LSB2YXVsdFJlZi53aXRoZHJhdyhhbW91bnQ6IGFtb3VudCkgYXMhIEBGbG93VG9rZW4uVmF1bHQKICAgICAgICBzZWxmLmF1dGggPSBzaWduZXIKICAgICAgICBzZWxmLmNvYSA9IGNvYQogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIHNlbGYuY29hLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKICAgIH0KfQo\u003d", + "fundEvmAddr": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZnVuZEV2bUFkZHIgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHg3ZTYwZGYwNDJhOWMwODY4CgppbXBvcnQgRVZNIGZyb20gMHg4YzUzMDNlYWEyNjIwMmQ2CgoKdHJhbnNhY3Rpb24oZXZtQWRkcjogU3RyaW5nLCBhbW91bnQ6IFVGaXg2NCkgewoKICAgIC8vIFRoZSBWYXVsdCByZXNvdXJjZSB0aGF0IGhvbGRzIHRoZSB0b2tlbnMgdGhhdCBhcmUgYmVpbmcgdHJhbnNmZXJlZAogICAgbGV0IHNlbnRWYXVsdDogQHtGdW5naWJsZVRva2VuLlZhdWx0fQoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgICAvLyBHZXQgYSByZWZlcmVuY2UgdG8gdGhlIHNpZ25lcidzIHN0b3JlZCB2YXVsdAogICAgICAgIGxldCB2YXVsdFJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICY8VG9rZW4+LlZhdWx0Pihmcm9tOiA8VG9rZW5TdG9yYWdlUGF0aD4pCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IHJlZmVyZW5jZSB0byB0aGUgb3duZXIncyBWYXVsdCEiKQoKICAgICAgICAvLyBXaXRoZHJhdyB0b2tlbnMgZnJvbSB0aGUgc2lnbmVyJ3Mgc3RvcmVkIHZhdWx0CiAgICAgICAgc2VsZi5zZW50VmF1bHQgPC0gdmF1bHRSZWYud2l0aGRyYXcoYW1vdW50OiBhbW91bnQpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgLy8gR2V0IHRoZSByZWNpcGllbnQncyBwdWJsaWMgYWNjb3VudCBvYmplY3QKICAgICAgICBsZXQgcmVjaXBpZW50QWNjb3VudCA9IGdldEFjY291bnQocmVjaXBpZW50KQoKICAgICAgICAvLyBHZXQgYSByZWZlcmVuY2UgdG8gdGhlIHJlY2lwaWVudCdzIFJlY2VpdmVyCiAgICAgICAgbGV0IHJlY2VpdmVyUmVmID0gcmVjaXBpZW50QWNjb3VudC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5SZWNlaXZlcn0+KDxUb2tlblJlY2VpdmVyUGF0aD4pIQogICAgICAgICAgICAKICAgICAgICAvLyBEZXBvc2l0IHRoZSB3aXRoZHJhd24gdG9rZW5zIGluIHRoZSByZWNpcGllbnQncyByZWNlaXZlcgogICAgICAgIHJlY2VpdmVyUmVmLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKICAgIH0KfQ\u003d\u003d", + "getAddr": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QWRkciAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGZsb3dBZGRyZXNzOiBBZGRyZXNzKTogU3RyaW5nPyB7CiAgICBpZiBsZXQgYWRkcmVzczogRVZNLkVWTUFkZHJlc3MgPSBnZXRBdXRoQWNjb3VudDxhdXRoKEJvcnJvd1ZhbHVlKSAmQWNjb3VudD4oZmxvd0FkZHJlc3MpCiAgICAgICAgLnN0b3JhZ2UuYm9ycm93PCZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oZnJvbTogL3N0b3JhZ2UvZXZtKT8uYWRkcmVzcygpIHsKICAgICAgICBsZXQgYnl0ZXM6IFtVSW50OF0gPSBbXQogICAgICAgIGZvciBieXRlIGluIGFkZHJlc3MuYnl0ZXMgewogICAgICAgICAgICBieXRlcy5hcHBlbmQoYnl0ZSkKICAgICAgICB9CiAgICAgICAgcmV0dXJuIFN0cmluZy5lbmNvZGVIZXgoYnl0ZXMpCiAgICB9CiAgICByZXR1cm4gbmlsCn0\u003d", + "getAssociatedFlowIdentifier": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QXNzb2NpYXRlZEZsb3dJZGVudGlmaWVyIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRVZNIGZyb20gMHg4YzUzMDNlYWEyNjIwMmQ2CgppbXBvcnQgRmxvd0VWTUJyaWRnZUNvbmZpZyBmcm9tIDB4ZGZjMjBhZWU2NTBmY2JkZgoKCmFjY2VzcyhhbGwpCmZ1biBtYWluKGFkZHJlc3M6IFN0cmluZyk6IFN0cmluZz8gewogICAgaWYgbGV0IHR5cGVJbmZvID0gRmxvd0VWTUJyaWRnZUNvbmZpZy5nZXRUeXBlQXNzb2NpYXRlZCh3aXRoOiBFVk0uYWRkcmVzc0Zyb21TdHJpbmcoYWRkcmVzcykpIHsKICAgICAgICByZXR1cm4gdHlwZUluZm8uaWRlbnRpZmllcgogICAgfQogICAgcmV0dXJuIG5pbAp9", + "getBalance": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QmFsYW5jZSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKCmFjY2VzcyhhbGwpCmZ1biBtYWluKGhleEVuY29kZWRBZGRyZXNzOiBTdHJpbmcpOiBVSW50IHsKICAgIGxldCBhZGRyZXNzQnl0ZXMgPSBoZXhFbmNvZGVkQWRkcmVzcy5kZWNvZGVIZXgoKS50b0NvbnN0YW50U2l6ZWQ8W1VJbnQ4OyAyMF0+KCkhCiAgICBsZXQgYWRkcmVzcyA9IEVWTS5FVk1BZGRyZXNzKGJ5dGVzOiBhZGRyZXNzQnl0ZXMpCgogICAgcmV0dXJuIGFkZHJlc3MuYmFsYW5jZSgpLmluQXR0b0ZMT1coKQp9Cg\u003d\u003d", + "getCoaAddr": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0Q29hQWRkciAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKCmFjY2VzcyhhbGwpCmZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBTdHJpbmcgewogICAgbGV0IGFjY291bnQgPSBnZXRBdXRoQWNjb3VudDxhdXRoKFN0b3JhZ2UpICZBY2NvdW50PihhZGRyZXNzKQoKICAgIGxldCBjb2EgPSBhY2NvdW50LnN0b3JhZ2UuYm9ycm93PCZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oCiAgICAgICAgZnJvbTogL3N0b3JhZ2UvZXZtCiAgICApCgogICAgaWYgY29hID09IG5pbCB7IAogICAgICAgIHJldHVybiAiIgogICAgfSBlbHNlIHsKICAgICAgICBsZXQgY29hQWRkciA9IGNvYT8uYWRkcmVzcygpIAoKICAgICAgICBsZXQgYWRkckJ5dGU6IFtVSW50OF0gPSBbXQoKICAgICAgICBmb3IgYnl0ZSBpbiBjb2FBZGRyPy5ieXRlcyEgewogICAgICAgICAgICBhZGRyQnl0ZS5hcHBlbmQoYnl0ZSkKICAgICAgICB9CgogICAgICAgIHJldHVybiBTdHJpbmcuZW5jb2RlSGV4KGFkZHJCeXRlKQogICAgfQp9Cg\u003d\u003d", + "getCoaBalance": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0Q29hQmFsYW5jZSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKCmFjY2VzcyhhbGwpCmZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBVRml4NjQgewogICAgIGxldCBhY2NvdW50ID0gZ2V0QXV0aEFjY291bnQ8YXV0aChTdG9yYWdlKSAmQWNjb3VudD4oYWRkcmVzcykKCiAgICBsZXQgY29hID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzwmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KAogICAgICAgIGZyb206IC9zdG9yYWdlL2V2bQogICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQogICAgCiAgICByZXR1cm4gY29hLmJhbGFuY2UoKS5pbkZMT1coKQp9Cg\u003d\u003d", + "getCode": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0Q29kZSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKCmFjY2VzcyhhbGwpCmZ1biBtYWluKGhleEVuY29kZWRBZGRyZXNzOiBTdHJpbmcpOiBTdHJpbmcgewogICAgbGV0IGFkZHJlc3NCeXRlcyA9IGhleEVuY29kZWRBZGRyZXNzLmRlY29kZUhleCgpLnRvQ29uc3RhbnRTaXplZDxbVUludDg7IDIwXT4oKSEKICAgIGxldCBhZGRyZXNzID0gRVZNLkVWTUFkZHJlc3MoYnl0ZXM6IGFkZHJlc3NCeXRlcykKCiAgICByZXR1cm4gU3RyaW5nLmVuY29kZUhleChhZGRyZXNzLmNvZGUoKSkKfQo\u003d", + "getNonce": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0Tm9uY2UgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBFVk0gZnJvbSAweDhjNTMwM2VhYTI2MjAyZDYKCgphY2Nlc3MoYWxsKQpmdW4gbWFpbihoZXhFbmNvZGVkQWRkcmVzczogU3RyaW5nKTogVUludDY0IHsKICAgIGxldCBhZGRyZXNzQnl0ZXMgPSBoZXhFbmNvZGVkQWRkcmVzcy5kZWNvZGVIZXgoKS50b0NvbnN0YW50U2l6ZWQ8W1VJbnQ4OyAyMF0+KCkhCiAgICBsZXQgYWRkcmVzcyA9IEVWTS5FVk1BZGRyZXNzKGJ5dGVzOiBhZGRyZXNzQnl0ZXMpCgogICAgcmV0dXJuIGFkZHJlc3Mubm9uY2UoKQp9Cg\u003d\u003d", + "newAccountAndCoa": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgbmV3QWNjb3VudEFuZENvYSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IENyeXB0bwppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKaW1wb3J0IEZsb3dUb2tlbiBmcm9tIDB4N2U2MGRmMDQyYTljMDg2OAoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKCnRyYW5zYWN0aW9uKHB1YmxpY0tleTogU3RyaW5nLCBzaWduYXR1cmVBbGdvcml0aG06IFVJbnQ4LCBoYXNoQWxnb3JpdGhtOiBVSW50OCwgd2VpZ2h0OiBVRml4NjQpIHsKICAgIGxldCBzZW50VmF1bHQ6IEBGbG93VG9rZW4uVmF1bHQKICAgIGxldCBhdXRoOiBhdXRoKFN0b3JhZ2UpICZBY2NvdW50CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSkgJkFjY291bnQpIHsKCiAgICAgICAgbGV0IGFjY291bnQgPSBBY2NvdW50KHBheWVyOiBzaWduZXIpCgogICAgICAgIGxldCBrZXkgPSBQdWJsaWNLZXkoCiAgICAgICAgICAgIHB1YmxpY0tleTogcHVibGljS2V5LmRlY29kZUhleCgpLAogICAgICAgICAgICBzaWduYXR1cmVBbGdvcml0aG06IFNpZ25hdHVyZUFsZ29yaXRobShyYXdWYWx1ZTogc2lnbmF0dXJlQWxnb3JpdGhtKSEKICAgICAgICApCgogICAgICAgIGFjY291bnQua2V5cy5hZGQocHVibGljS2V5OiBrZXksIGhhc2hBbGdvcml0aG06IEhhc2hBbGdvcml0aG0ocmF3VmFsdWU6IGhhc2hBbGdvcml0aG0pISwgd2VpZ2h0OiB3ZWlnaHQpCgkJCiAgICAgICAgbGV0IHZhdWx0UmVmID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZGbG93VG9rZW4uVmF1bHQ+KAogICAgICAgICAgICBmcm9tOiAvc3RvcmFnZS9mbG93VG9rZW5WYXVsdAogICAgICAgICkgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgcmVmZXJlbmNlIHRvIHRoZSBvd25lcidzIFZhdWx0ISIpCgogICAgICAgIHNlbGYuc2VudFZhdWx0IDwtIHZhdWx0UmVmLndpdGhkcmF3KGFtb3VudDogMC4wKSBhcyEgQEZsb3dUb2tlbi5WYXVsdAogICAgICAgIHNlbGYuYXV0aCA9IGFjY291bnQKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBsZXQgYWNjb3VudCA8LSBFVk0uY3JlYXRlQ2FkZW5jZU93bmVkQWNjb3VudCgpCiAgICAgICAgbG9nKGFjY291bnQuYWRkcmVzcygpKQogICAgICAgIGFjY291bnQuZGVwb3NpdChmcm9tOiA8LXNlbGYuc2VudFZhdWx0KQoKICAgICAgICBsb2coYWNjb3VudC5iYWxhbmNlKCkpCiAgICAgICAgc2VsZi5hdXRoLnN0b3JhZ2Uuc2F2ZTxARVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KDwtYWNjb3VudCwgdG86IFN0b3JhZ2VQYXRoKGlkZW50aWZpZXI6ICJldm0iKSEpCiAgICB9Cn0K", + "removeCoa": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcmVtb3ZlQ29hIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRVZNIGZyb20gMHg4YzUzMDNlYWEyNjIwMmQ2CgoKdHJhbnNhY3Rpb24oKSB7CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSwgVW5wdWJsaXNoQ2FwYWJpbGl0eSkgJkFjY291bnQpIHsKICAgICAgICBsZXQgY29hUmVmID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PCZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oCiAgICAgICAgICAgIGZyb206IC9zdG9yYWdlL2V2bQogICAgICAgICkgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgcmVmZXJlbmNlIHRvIHRoZSBDT0EhIikKICAgICAgICBpZiBjb2FSZWYgIT0gbmlsIHsKICAgICAgICAgICAgbGV0IGNvYSA8LSBzaWduZXIuc3RvcmFnZS5sb2FkPEBFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oZnJvbTogL3N0b3JhZ2UvZXZtKSAKICAgICAgICAgICAgbGV0IHB1YmxpY1BhdGggPSBQdWJsaWNQYXRoKGlkZW50aWZpZXI6ICJldm0iKSEKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy51bnB1Ymxpc2gocHVibGljUGF0aCkKICAgICAgICAgICAgZGVzdHJveSBjb2EKICAgICAgICB9CiAgICB9Cn0K", + "run": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcnVuIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRVZNIGZyb20gMHg4YzUzMDNlYWEyNjIwMmQ2CgoKdHJhbnNhY3Rpb24oaGV4RW5jb2RlZFR4OiBTdHJpbmcpIHsKICAgIGxldCBjb2E6ICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudAoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgc2VsZi5jb2EgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8JkVWTS5DYWRlbmNlT3duZWRBY2NvdW50PigKICAgICAgICAgICAgZnJvbTogL3N0b3JhZ2UvZXZtCiAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIGxldCB0eFJlc3VsdCA9IEVWTS5ydW4odHg6IGhleEVuY29kZWRUeC5kZWNvZGVIZXgoKSwgY29pbmJhc2U6IHNlbGYuY29hLmFkZHJlc3MoKSkKICAgICAgICAvLyB0b2RvIG9ubHkgdGVtcG9yYXJ5IHVudGlsIHdlIGNvcnJlY3RseSBoYW5kbGUgZmFpbHVyZSBldmVudHMKICAgICAgICBhc3NlcnQoCiAgICAgICAgICAgIHR4UmVzdWx0LnN0YXR1cyA9PSBFVk0uU3RhdHVzLmZhaWxlZCB8fCB0eFJlc3VsdC5zdGF0dXMgPT0gRVZNLlN0YXR1cy5zdWNjZXNzZnVsLAogICAgICAgICAgICBtZXNzYWdlOiAiZXZtX2Vycm9yPSIuY29uY2F0KHR4UmVzdWx0LmVycm9yTWVzc2FnZSkuY29uY2F0KCJcbiIpCiAgICAgICAgKQogICAgfQp9Cg\u003d\u003d", + "transferCoa": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdHJhbnNmZXJDb2EgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHg3ZTYwZGYwNDJhOWMwODY4CgppbXBvcnQgRVZNIGZyb20gMHg4YzUzMDNlYWEyNjIwMmQ2CgoKdHJhbnNhY3Rpb24oYW1vdW50OiBVRml4NjQsIGFkZHJlc3M6IEFkZHJlc3MpIHsKICAgIGxldCBzZW50VmF1bHQ6IEBGbG93VG9rZW4uVmF1bHQKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChTdG9yYWdlLCBFVk0uV2l0aGRyYXcpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IGNvYSA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEVWTS5XaXRoZHJhdykgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50PigKICAgICAgICAgICAgZnJvbTogL3N0b3JhZ2UvZXZtCiAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQoKICAgICAgICBzZWxmLnNlbnRWYXVsdCA8LSBjb2Eud2l0aGRyYXcoYmFsYW5jZTogRVZNLkJhbGFuY2UoYXR0b2Zsb3c6IFVJbnQoYW1vdW50KSAqIDEwMDAwMDAwMDAwMDAwMDAwMCkpIGFzISBARmxvd1Rva2VuLlZhdWx0CiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAgbGV0IHJlY2VpdmVyID0gYWNjb3VudC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5SZWNlaXZlcn0+KC9wdWJsaWMvZmxvd1Rva2VuUmVjZWl2ZXIpIQogICAgICAgIHJlY2VpdmVyLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKICAgIH0KfQo\u003d", + "transferFlowFromCoaToFlow": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdHJhbnNmZXJGbG93RnJvbUNvYVRvRmxvdyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDdlNjBkZjA0MmE5YzA4NjgKCmltcG9ydCBFVk0gZnJvbSAweDhjNTMwM2VhYTI2MjAyZDYKCgp0cmFuc2FjdGlvbihhbW91bnQ6IFVGaXg2NCwgYWRkcmVzczogQWRkcmVzcykgewogICAgbGV0IHNlbnRWYXVsdDogQEZsb3dUb2tlbi5WYXVsdAoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIEVWTS5XaXRoZHJhdykgJkFjY291bnQpIHsKICAgICAgICBsZXQgY29hID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoRVZNLldpdGhkcmF3KSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KAogICAgICAgICAgICBmcm9tOiAvc3RvcmFnZS9ldm0KICAgICAgICApID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IHJlZmVyZW5jZSB0byB0aGUgQ09BISIpCiAgICAgICAgbGV0IHdpdGhkcmF3QmFsYW5jZSA9IEVWTS5CYWxhbmNlKGF0dG9mbG93OiAwKQogICAgICAgIHdpdGhkcmF3QmFsYW5jZS5zZXRGTE9XKGZsb3c6IGFtb3VudCkKICAgICAgICBzZWxmLnNlbnRWYXVsdCA8LSBjb2Eud2l0aGRyYXcoYmFsYW5jZTogd2l0aGRyYXdCYWxhbmNlKSBhcyEgQEZsb3dUb2tlbi5WYXVsdAogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIGxldCBhY2NvdW50ID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgIGxldCByZWNlaXZlciA9IGFjY291bnQuY2FwYWJpbGl0aWVzLmJvcnJvdzwme0Z1bmdpYmxlVG9rZW4uUmVjZWl2ZXJ9PigvcHVibGljL2Zsb3dUb2tlblJlY2VpdmVyKSEKICAgICAgICByZWNlaXZlci5kZXBvc2l0KGZyb206IDwtc2VsZi5zZW50VmF1bHQpCiAgICB9Cn0K", + "transferFlowToEvmAddress": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdHJhbnNmZXJGbG93VG9Fdm1BZGRyZXNzIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKaW1wb3J0IEZsb3dUb2tlbiBmcm9tIDB4N2U2MGRmMDQyYTljMDg2OAoKaW1wb3J0IEVWTSBmcm9tIDB4OGM1MzAzZWFhMjYyMDJkNgoKCi8vLyBUcmFuc2ZlcnMgJEZMT1cgZnJvbSB0aGUgc2lnbmVyJ3MgYWNjb3VudCBDYWRlbmNlIEZsb3cgYmFsYW5jZSB0byB0aGUgcmVjaXBpZW50J3MgaGV4LWVuY29kZWQgRVZNIGFkZHJlc3MuCi8vLyBOb3RlIHRoYXQgYSBDT0EgbXVzdCBoYXZlIGEgJEZMT1cgYmFsYW5jZSBpbiBFVk0gYmVmb3JlIHRyYW5zZmVycmluZyB2YWx1ZSB0byBhbm90aGVyIEVWTSBhZGRyZXNzLgovLy8KdHJhbnNhY3Rpb24ocmVjaXBpZW50RVZNQWRkcmVzc0hleDogU3RyaW5nLCBhbW91bnQ6IFVGaXg2NCwgZ2FzTGltaXQ6IFVJbnQ2NCkgewoKICAgIGxldCBjb2E6IGF1dGgoRVZNLldpdGhkcmF3LCBFVk0uQ2FsbCkgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50CiAgICBsZXQgcmVjaXBpZW50RVZNQWRkcmVzczogRVZNLkVWTUFkZHJlc3MKICAgIHZhciBzZW50VmF1bHQ6IEBGbG93VG9rZW4uVmF1bHQKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChCb3Jyb3dWYWx1ZSwgU2F2ZVZhbHVlKSAmQWNjb3VudCkgewogICAgICAgIGlmIHNpZ25lci5zdG9yYWdlLnR5cGUoYXQ6IC9zdG9yYWdlL2V2bSkgPT0gbmlsIHsKICAgICAgICAgICAgc2lnbmVyLnN0b3JhZ2Uuc2F2ZSg8LUVWTS5jcmVhdGVDYWRlbmNlT3duZWRBY2NvdW50KCksIHRvOiAvc3RvcmFnZS9ldm0pCiAgICAgICAgfQogICAgICAgIHNlbGYuY29hID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoRVZNLldpdGhkcmF3LCBFVk0uQ2FsbCkgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50Pihmcm9tOiAvc3RvcmFnZS9ldm0pCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IHJlZmVyZW5jZSB0byB0aGUgc2lnbmVyJ3MgYnJpZGdlZCBhY2NvdW50IikKCiAgICAgICAgbGV0IHZhdWx0UmVmID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJkZsb3dUb2tlbi5WYXVsdD4oCiAgICAgICAgICAgICAgICBmcm9tOiAvc3RvcmFnZS9mbG93VG9rZW5WYXVsdAogICAgICAgICAgICApID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IHJlZmVyZW5jZSB0byB0aGUgb3duZXIncyBWYXVsdCEiKQogICAgICAgIHNlbGYuc2VudFZhdWx0IDwtIHZhdWx0UmVmLndpdGhkcmF3KGFtb3VudDogYW1vdW50KSBhcyEgQEZsb3dUb2tlbi5WYXVsdAoKICAgICAgICBzZWxmLnJlY2lwaWVudEVWTUFkZHJlc3MgPSBFVk0uYWRkcmVzc0Zyb21TdHJpbmcocmVjaXBpZW50RVZNQWRkcmVzc0hleCkKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBzZWxmLmNvYS5kZXBvc2l0KGZyb206IDwtc2VsZi5zZW50VmF1bHQpCiAgICAgICAgCiAgICAgICAgbGV0IHZhbHVlQmFsYW5jZSA9IEVWTS5CYWxhbmNlKGF0dG9mbG93OiAwKQogICAgICAgIHZhbHVlQmFsYW5jZS5zZXRGTE9XKGZsb3c6IGFtb3VudCkKICAgICAgICBsZXQgdHhSZXN1bHQgPSBzZWxmLmNvYS5jYWxsKAogICAgICAgICAgICB0bzogc2VsZi5yZWNpcGllbnRFVk1BZGRyZXNzLAogICAgICAgICAgICBkYXRhOiBbXSwKICAgICAgICAgICAgZ2FzTGltaXQ6IGdhc0xpbWl0LAogICAgICAgICAgICB2YWx1ZTogdmFsdWVCYWxhbmNlCiAgICAgICAgKQogICAgICAgIGFzc2VydCgKICAgICAgICAgICAgdHhSZXN1bHQuc3RhdHVzID09IEVWTS5TdGF0dXMuZmFpbGVkIHx8IHR4UmVzdWx0LnN0YXR1cyA9PSBFVk0uU3RhdHVzLnN1Y2Nlc3NmdWwsCiAgICAgICAgICAgIG1lc3NhZ2U6ICJldm1fZXJyb3I9Ii5jb25jYXQodHhSZXN1bHQuZXJyb3JNZXNzYWdlKS5jb25jYXQoIlxuIikKICAgICAgICApCgogICAgfQp9", + "withdrawCoa": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgd2l0aGRyYXdDb2EgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHg3ZTYwZGYwNDJhOWMwODY4CgppbXBvcnQgRVZNIGZyb20gMHg4YzUzMDNlYWEyNjIwMmQ2CgoKdHJhbnNhY3Rpb24oYW1vdW50OiBVRml4NjQsIGFkZHJlc3M6IEFkZHJlc3MpIHsKICAgIGxldCBzZW50VmF1bHQ6IEBGbG93VG9rZW4uVmF1bHQKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChTdG9yYWdlLCBFVk0uV2l0aGRyYXcpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IGNvYSA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEVWTS5XaXRoZHJhdykgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50PigKICAgICAgICAgICAgZnJvbTogL3N0b3JhZ2UvZXZtCiAgICAgICAgKSA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIENPQSEiKQogICAgICAgIGxldCB3aXRoZHJhd0JhbGFuY2UgPSBFVk0uQmFsYW5jZShhdHRvZmxvdzogMCkKICAgICAgICB3aXRoZHJhd0JhbGFuY2Uuc2V0RkxPVyhmbG93OiBhbW91bnQpCiAgICAgICAgc2VsZi5zZW50VmF1bHQgPC0gY29hLndpdGhkcmF3KGJhbGFuY2U6IHdpdGhkcmF3QmFsYW5jZSkgYXMhIEBGbG93VG9rZW4uVmF1bHQKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBsZXQgYWNjb3VudCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgICBsZXQgcmVjZWl2ZXIgPSBhY2NvdW50LmNhcGFiaWxpdGllcy5ib3Jyb3c8JntGdW5naWJsZVRva2VuLlJlY2VpdmVyfT4oL3B1YmxpYy9mbG93VG9rZW5SZWNlaXZlcikhCiAgICAgICAgcmVjZWl2ZXIuZGVwb3NpdChmcm9tOiA8LXNlbGYuc2VudFZhdWx0KQogICAgfQp9Cg\u003d\u003d" + }, + "ft": { + "isTokenListEnabled": "CiAgICAvLyBGbG93IFdhbGxldCAtIHRlc3RuZXQgU2NyaXB0ICBpc1Rva2VuTGlzdEVuYWJsZWQgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCgogICAgaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCgogICAgCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tGaWF0VG9rZW4weGE5ODNmZWNiZWQ2MjExNjNWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvVVNEQ1ZhdWx0UmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9VU0RDVmF1bHRCYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRmxvdmF0YXJEdXN0VG9rZW4weDkzOTJhNGE3YzNmNDlhMGJWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRmxvdmF0YXJEdXN0VG9rZW5SZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0Zsb3ZhdGFyRHVzdFRva2VuQmFsYW5jZSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0Zsb3dUb2tlbjB4N2U2MGRmMDQyYTljMDg2OFZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9mbG93VG9rZW5SZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL2Zsb3dUb2tlbkJhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tVU0RDRmxvdzB4NjRhZGYzOWNiYzM1NGZjYlZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy91c2RjRmxvd1JlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvdXNkY0Zsb3dNZXRhZGF0YSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja3N0Rmxvd1Rva2VuMHhlNDVjNjRlY2ZlMzFlNDY1VmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL3N0Rmxvd1Rva2VuUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9zdEZsb3dUb2tlbkJhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tDb3NtaWNHQVRFMHgwMGFmMmFiMzYzZmE0OWU0VmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0Nvc21pY0dBVEVSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0Nvc21pY0dBVEVWYXVsdCkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja1NVR09JMHg1NjZjODEzYjM2MzI3ODNlVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL1NVR09JUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9TVUdPSUJhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tFVk1WTUJyaWRnZWRUb2tlbl8xMTE5Y2E0ZDUxNDU0MzJiN2IxY2QxOTdkMTM2ZGExNWUyMzZlODk2MHhkZmMyMGFlZTY1MGZjYmRmVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0VWTVZNQnJpZGdlZFRva2VuXzExMTljYTRkNTE0NTQzMmI3YjFjZDE5N2QxMzZkYTE1ZTIzNmU4OTZSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0VWTVZNQnJpZGdlZFRva2VuXzExMTljYTRkNTE0NTQzMmI3YjFjZDE5N2QxMzZkYTE1ZTIzNmU4OTZWYXVsdCkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0RhcHBlclV0aWxpdHlDb2luMHg4MmVjMjgzZjg4YTYyZTY1VmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL2RhcHBlclV0aWxpdHlDb2luUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9kYXBwZXJVdGlsaXR5Q29pblJlY2VpdmVyKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrTUVESTB4NTY2YzgxM2IzNjMyNzgzZVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9NRURJMjRLYXJhdFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvTUVESTI0S2FyYXRCYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrS2FyYXR2MjB4NTY2YzgxM2IzNjMyNzgzZVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9rYXJhdHYyUmVjZWl2ZXIwMDMpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9rYXJhdHYyQmFsYW5jZTAwMykKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0tBUkFUWjFMWEdQSzB4NTY2YzgxM2IzNjMyNzgzZVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9LQVJBVFoxTFhHUEtSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0tBUkFUWjFMWEdQS0JhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tLYXJhdDB4NTY2YzgxM2IzNjMyNzgzZVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9rYXJhdFJlY2VpdmVyMDAzKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMva2FyYXRCYWxhbmNlMDAzKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrS0FSQVRaMUpYRFhEMHg1NjZjODEzYjM2MzI3ODNlVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0tBUkFUWjFKWERYRFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvS0FSQVRaMUpYRFhEQmFsYW5jZSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0tBUkFUWjFURUZRMjB4NTY2YzgxM2IzNjMyNzgzZVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9LQVJBVFoxVEVGUTJSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0tBUkFUWjFURUZRMkJhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tUZWxlcG9ydGVkVGV0aGVyVG9rZW4weDJkMjcwZGI5YWM4YzdmZWZWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvdGVsZXBvcnRlZFRldGhlclRva2VuUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy90ZWxlcG9ydGVkVGV0aGVyVG9rZW5CYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrU3Rhcmx5VG9rZW4weGY2MzIxOTA3MmFhZGRkNTBWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvc3Rhcmx5VG9rZW5SZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL3N0YXJseVRva2VuQmFsYW5jZSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0Jsb2N0b1Rva2VuMHg2NTNjZmUzNmQxNDZlN2JlVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL2Jsb2N0b1Rva2VuUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9ibG9jdG9Ub2tlbkJhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tHT1dUS04yMHg1NjZjODEzYjM2MzI3ODNlVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0tSVEtOR09XVEtOMlJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvS1JUS05HT1dUS04yQmFsYW5jZSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0tBUkFUTURWOVQweDU2NmM4MTNiMzYzMjc4M2VWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvS0FSQVRNRFY5VFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvS0FSQVRNRFY5VEJhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tKT1NISU4weDU2NmM4MTNiMzYzMjc4M2VWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvSk9TSElOMjRLYXJhdFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvSk9TSElOMjRLYXJhdEJhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tLQVJBVDJFQTI4SDB4NTY2YzgxM2IzNjMyNzgzZVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9LQVJBVDJFQTI4SFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvS0FSQVQyRUEyOEhCYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRE9HRVRLTjB4NTY2YzgxM2IzNjMyNzgzZVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9ET0dFVEtOUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9ET0dFVEtOQmFsYW5jZSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja1RTVENPTjB4NTY2YzgxM2IzNjMyNzgzZVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9UU1RDT05SZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL1RTVENPTkJhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2thaVNwb3J0c0p1aWNlMHhmOGJhMzIxYWY0YmQzN2JiVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL2FpU3BvcnRzSnVpY2VSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL2FpU3BvcnRzSnVpY2VNZXRhZGF0YSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0RXTEMweDU2NmM4MTNiMzYzMjc4M2VWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRFdMQ1JlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRFdMQ0JhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tGb29Ub2tlbjB4NDMyMDUwMjMyZjlhNDllN1ZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9mb29Ub2tlblZhdWx0KQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvZm9vVG9rZW5WYXVsdCkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja05vY2VuaXgweGE2MjJhZmFkMDdmNjczOWVWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvTm9jZW5peFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvTm9jZW5peFZhdWx0KQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrVVNEQ0Zsb3cweDA4OThmYTQ4OTZkNzM3NTJWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvdXNkY0Zsb3dSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL3VzZGNGbG93TWV0YWRhdGEpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tTb3JhY2hpMHg1NjZjODEzYjM2MzI3ODNlVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL3NvcmFjaGlSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL3NvcmFjaGlCYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrS0FSQVRaMjFNUEtQMHg1NjZjODEzYjM2MzI3ODNlVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0tBUkFUWjIxTVBLUFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvS0FSQVRaMjFNUEtQQmFsYW5jZSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0pQWTI0MHhjYWI4MzAwOTM1ZDkwYjlhVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL2pweTI0UmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9qcHkyNEJhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tQT0lOVDI0MHhjYWI4MzAwOTM1ZDkwYjlhVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL3BvaW50MjRSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL3BvaW50MjRCYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrS0FSQVRaMTg1TVBMMHg1NjZjODEzYjM2MzI3ODNlVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0tBUkFUWjE4NU1QTFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvS0FSQVRaMTg1TVBMQmFsYW5jZSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0hIMjQweGNhYjgzMDA5MzVkOTBiOWFWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvSEgyNFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvSEgyNEJhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tISDI0SzB4Y2FiODMwMDkzNWQ5MGI5YVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9ISDI0S1JlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvSEgyNEtCYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrWWllbGRUb2tlbjB4MmFiNmY0NjllZTBkZmJiNlZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy95aWVsZFRva2VuUmVjZWl2ZXJfMHgyYWI2ZjQ2OWVlMGRmYmI2KQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMveWllbGRUb2tlblZhdWx0XzB4MmFiNmY0NjllZTBkZmJiNikKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0tBUkFUWjFLMFg0TzB4NTY2YzgxM2IzNjMyNzgzZVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9LQVJBVFoxSzBYNE9SZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0tBUkFUWjFLMFg0T0JhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tNT0VUMHgyYWI2ZjQ2OWVlMGRmYmI2VmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL21vZXRUb2tlblJlY2VpdmVyXzB4MmFiNmY0NjllZTBkZmJiNikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL21vZXRUb2tlblZhdWx0XzB4MmFiNmY0NjllZTBkZmJiNikKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0VWTVZNQnJpZGdlZFRva2VuX2E3Y2YyMjYwZTUwMTk1MmM3MTE4OWQwNGZhZDE3YzcwNGRmYjM2ZTYweGRmYzIwYWVlNjUwZmNiZGZWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRVZNVk1CcmlkZ2VkVG9rZW5fYTdjZjIyNjBlNTAxOTUyYzcxMTg5ZDA0ZmFkMTdjNzA0ZGZiMzZlNlJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRVZNVk1CcmlkZ2VkVG9rZW5fYTdjZjIyNjBlNTAxOTUyYzcxMTg5ZDA0ZmFkMTdjNzA0ZGZiMzZlNlZhdWx0KQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrVE9LRU5fSUVPXzEweGNhYjgzMDA5MzVkOTBiOWFWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvVE9LRU5fSUVPXzFSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL1RPS0VOX0lFT18xQmFsYW5jZSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0VWTVZNQnJpZGdlZFRva2VuX2Q0MzE5NTVkNTVhOTllZjY5YmViOTZiYTM0NzE4ZDBmOWZiYzkxYjEweGRmYzIwYWVlNjUwZmNiZGZWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRVZNVk1CcmlkZ2VkVG9rZW5fZDQzMTk1NWQ1NWE5OWVmNjliZWI5NmJhMzQ3MThkMGY5ZmJjOTFiMVJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRVZNVk1CcmlkZ2VkVG9rZW5fZDQzMTk1NWQ1NWE5OWVmNjliZWI5NmJhMzQ3MThkMGY5ZmJjOTFiMVZhdWx0KQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrS0FSQVRaSDI0MlAweGNhYjgzMDA5MzVkOTBiOWFWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvS0FSQVRaSDI0MlBSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0tBUkFUWkgyNDJQQmFsYW5jZSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0tBUkFUWjFET0I4ODB4Y2FiODMwMDkzNWQ5MGI5YVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9LQVJBVFoxRE9CODhSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0tBUkFUWjFET0I4OEJhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tXcmFwcGVkRVRIMTB4ZTExY2FiODVlODVhZTEzN1ZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9XcmFwcGVkRVRIMVZhdWx0KQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvV3JhcHBlZEVUSDFWYXVsdCkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0NIVG9rZW4weDdjMWE2ZTRiN2ViNDE5YzFWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvQ0hUb2tlblJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvQ0hUb2tlblZhdWx0KQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrQVROVG9rZW4weGQxZDEwYWVjZTJkNjFiOWNWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvQVROVG9rZW5SZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0FUTlRva2VuUmVjZWl2ZXIpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tDSFRva2VuMHg5MTlkNjlhOWQwZWZhMzliVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0NIVG9rZW5SZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0NIVG9rZW5WYXVsdCkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja01vY2tVU0RDMHg4NTAzODAzYzNhY2Y2ZDU2VmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL21vY2tVU0RDVG9rZW5SZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL21vY2tVU0RDVG9rZW5WYXVsdCkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja1dyYXBwZWRVU0RDMTB4ZTExY2FiODVlODVhZTEzN1ZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9XcmFwcGVkVVNEQzFWYXVsdCkKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL1dyYXBwZWRVU0RDMVZhdWx0KQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrTW9ja1VTREMweDA4NGEzMDg4OTRkZGNlMTlWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvbW9ja1VTRENUb2tlblJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvbW9ja1VTRENUb2tlblZhdWx0KQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrTW9ja1VTREMweDVkNjk3YzdkNzRiYzA0MzJWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvbW9ja1VTRENUb2tlblJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvbW9ja1VTRENUb2tlblZhdWx0KQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrVG91Y2FuVG9rZW4weGQwMjBjY2M5ZGFhZWE3N2RWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvVG91Y2FuVG9rZW5SZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL1RvdWNhblRva2VuVmF1bHQpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tWYXVsdFNoYXJlVG9rZW5fVjAwMTB4MjM3NjU2NzQ2YmM2OTc2NVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9yZWNlaXZlcl9WMDAxKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvYmFsYW5jZV9WMDAxKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrVmF1bHRTaGFyZVRva2VuX0JPTkQweDIzNzY1Njc0NmJjNjk3NjVWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvcmVjZWl2ZXJfQk9ORCkKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL2JhbGFuY2VfQk9ORCkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0V4YW1wbGVUb2tlbjB4NDUzMTRlNjA2Y2QyYmQxZlZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9leGFtcGxlVG9rZW5SZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL2V4YW1wbGVUb2tlbk1ldGFkYXRhKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrVmF1bHRTaGFyZVRva2VuX1YxMDEweDIzNzY1Njc0NmJjNjk3NjVWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvcmVjZWl2ZXJfVjEwMSkKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL2JhbGFuY2VfVjEwMSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0tBUkFUWjFQUE1WNDB4Y2FiODMwMDkzNWQ5MGI5YVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9LQVJBVFoxUFBNVjRSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0tBUkFUWjFQUE1WNEJhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tNT0VUMHhjMTZjMGIxMjI5ODQzNjA2VmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL21vZXRUb2tlblJlY2VpdmVyXzB4YzE2YzBiMTIyOTg0MzYwNikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL21vZXRUb2tlblZhdWx0XzB4YzE2YzBiMTIyOTg0MzYwNikKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja1RPS0VOX0lFT18zMHhjYWI4MzAwOTM1ZDkwYjlhVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL1RPS0VOX0lFT18zUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9UT0tFTl9JRU9fM0JhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tFeGFtcGxlVG9rZW4weGVkZTA1N2NlOTkxNTE2NmJWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvZXhhbXBsZVRva2VuUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9leGFtcGxlVG9rZW5WYXVsdCkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0VWTVZNQnJpZGdlZFRva2VuX2ViNTY2MDcwOTEyZTgyYTc5NzEyMzJmMDZkY2Y3ZTc5NTY4NjkxYTgweGRmYzIwYWVlNjUwZmNiZGZWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRVZNVk1CcmlkZ2VkVG9rZW5fZWI1NjYwNzA5MTJlODJhNzk3MTIzMmYwNmRjZjdlNzk1Njg2OTFhOFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRVZNVk1CcmlkZ2VkVG9rZW5fZWI1NjYwNzA5MTJlODJhNzk3MTIzMmYwNmRjZjdlNzk1Njg2OTFhOFZhdWx0KQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fNGUyZGNjYWZlODY3MTliN2JmZmFjM2IxMDQxMDMxZGRkMDdhZjVmZjB4ZGZjMjBhZWU2NTBmY2JkZlZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl80ZTJkY2NhZmU4NjcxOWI3YmZmYWMzYjEwNDEwMzFkZGQwN2FmNWZmUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl80ZTJkY2NhZmU4NjcxOWI3YmZmYWMzYjEwNDEwMzFkZGQwN2FmNWZmVmF1bHQpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tNT0VUMHhkMjc5MjBiNjM4NGUyYTc4VmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL21vZXRUb2tlblJlY2VpdmVyXzB4ZDI3OTIwYjYzODRlMmE3OCkKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL21vZXRUb2tlblZhdWx0XzB4ZDI3OTIwYjYzODRlMmE3OCkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja01PRVQweDQyNmYwNDU4Y2VkNjAwMzdWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvbW9ldFRva2VuUmVjZWl2ZXJfMHg0MjZmMDQ1OGNlZDYwMDM3KQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvbW9ldFRva2VuVmF1bHRfMHg0MjZmMDQ1OGNlZDYwMDM3KQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fNDE1NGQ1YjBlMjkzMWEwYTFlNWI3MzNmMTkxNjFhYTdkMmZjNGI5NTB4ZGZjMjBhZWU2NTBmY2JkZlZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl80MTU0ZDViMGUyOTMxYTBhMWU1YjczM2YxOTE2MWFhN2QyZmM0Yjk1UmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl80MTU0ZDViMGUyOTMxYTBhMWU1YjczM2YxOTE2MWFhN2QyZmM0Yjk1VmF1bHQpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tUT0tFTl9JRU9fNDB4Y2FiODMwMDkzNWQ5MGI5YVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9UT0tFTl9JRU9fNFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvVE9LRU5fSUVPXzRCYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrVE9LRU5fSUVPXzUweGNhYjgzMDA5MzVkOTBiOWFWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvVE9LRU5fSUVPXzVSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL1RPS0VOX0lFT181QmFsYW5jZSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0tBUkFUMlA4QlVMMHhjYWI4MzAwOTM1ZDkwYjlhVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0tBUkFUMlA4QlVMUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9LQVJBVDJQOEJVTEJhbGFuY2UpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tFVk1WTUJyaWRnZWRUb2tlbl8yMDhkMDlkMmE2ZGQxNzZlM2U5NWIzZjBkZTE3MmE3NDcxYzViMmQ2MHhkZmMyMGFlZTY1MGZjYmRmVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0VWTVZNQnJpZGdlZFRva2VuXzIwOGQwOWQyYTZkZDE3NmUzZTk1YjNmMGRlMTcyYTc0NzFjNWIyZDZSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0VWTVZNQnJpZGdlZFRva2VuXzIwOGQwOWQyYTZkZDE3NmUzZTk1YjNmMGRlMTcyYTc0NzFjNWIyZDZWYXVsdCkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0dhbWVUb2tlbjB4NDQ2OWY1MjQxYmNiMTFkM1ZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9GYWJhdGthX3B1YmxpY18weDQ0NjlmNTI0MWJjYjExZDMpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9GYWJhdGthX3B1YmxpY18weDQ0NjlmNTI0MWJjYjExZDMpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tHYW1lVG9rZW4weDdmYWE1MWY0Zjk3YmRkZmFWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRmFiYXRrYV9wdWJsaWNfMHg3ZmFhNTFmNGY5N2JkZGZhKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRmFiYXRrYV9wdWJsaWNfMHg3ZmFhNTFmNGY5N2JkZGZhKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fMDU5YTc3MjM5ZGFmYTc3MDk3N2RkOWYxZTk4NjMyYzNlNDU1OTg0ODB4ZGZjMjBhZWU2NTBmY2JkZlZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl8wNTlhNzcyMzlkYWZhNzcwOTc3ZGQ5ZjFlOTg2MzJjM2U0NTU5ODQ4UmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9FVk1WTUJyaWRnZWRUb2tlbl8wNTlhNzcyMzlkYWZhNzcwOTc3ZGQ5ZjFlOTg2MzJjM2U0NTU5ODQ4VmF1bHQpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tFVk1WTUJyaWRnZWRUb2tlbl9kN2Q0M2FiN2IzNjVmMGQwNzg5YWU4M2Y0Mzg1ZmE3MTBmZmRjOThmMHhkZmMyMGFlZTY1MGZjYmRmVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0VWTVZNQnJpZGdlZFRva2VuX2Q3ZDQzYWI3YjM2NWYwZDA3ODlhZTgzZjQzODVmYTcxMGZmZGM5OGZSZWNlaXZlcikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0VWTVZNQnJpZGdlZFRva2VuX2Q3ZDQzYWI3YjM2NWYwZDA3ODlhZTgzZjQzODVmYTcxMGZmZGM5OGZWYXVsdCkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0VWTVZNQnJpZGdlZFRva2VuXzYxYjQ0ZDE5NDg2ZWU0OTI0NDllODNjMTIwMTU4MWM3NTRlOWUxZTEweGRmYzIwYWVlNjUwZmNiZGZWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRVZNVk1CcmlkZ2VkVG9rZW5fNjFiNDRkMTk0ODZlZTQ5MjQ0OWU4M2MxMjAxNTgxYzc1NGU5ZTFlMVJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRVZNVk1CcmlkZ2VkVG9rZW5fNjFiNDRkMTk0ODZlZTQ5MjQ0OWU4M2MxMjAxNTgxYzc1NGU5ZTFlMVZhdWx0KQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrR2FtZVRva2VuMHhmMWMyNDViMGUzNGYyMjM1VmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0ZhYmF0a2FfcHVibGljXzB4ZjFjMjQ1YjBlMzRmMjIzNSkKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0ZhYmF0a2FfcHVibGljXzB4ZjFjMjQ1YjBlMzRmMjIzNSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0dhbWVUb2tlbjB4OGFiYzNkMGM0ZTkxNzEyYlZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9GYWJhdGthX3B1YmxpY18weDhhYmMzZDBjNGU5MTcxMmIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9GYWJhdGthX3B1YmxpY18weDhhYmMzZDBjNGU5MTcxMmIpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tHYW1lVG9rZW4weDYyMWM4MDhiOWE0NDJkMGFWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRmFiYXRrYV9wdWJsaWNfMHg2MjFjODA4YjlhNDQyZDBhKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvRmFiYXRrYV9wdWJsaWNfMHg2MjFjODA4YjlhNDQyZDBhKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrR2FtZVRva2VuMHhhNzM1Mzk5ZWQ0OGMwZDUzVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0ZhYmF0a2FfcHVibGljXzB4YTczNTM5OWVkNDhjMGQ1MykKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0ZhYmF0a2FfcHVibGljXzB4YTczNTM5OWVkNDhjMGQ1MykKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja1lpZWxkVG9rZW4weGQyNTgwY2FmMmVmMDdjMmZWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMveWllbGRUb2tlblJlY2VpdmVyXzB4ZDI1ODBjYWYyZWYwN2MyZikKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL3lpZWxkVG9rZW5WYXVsdF8weGQyNTgwY2FmMmVmMDdjMmYpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tCbG9vbVRva2VuMHg2ZTEyMzIzZjQ1MDE3NTRkVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL2Jsb29tVG9rZW5WYXVsdCkKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL2Jsb29tVG9rZW5WYXVsdCkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0dhbWVUb2tlbjB4NmZjNWQ3NDVlMDU4ZmIwYVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9GYWJhdGthX3B1YmxpY18weDZmYzVkNzQ1ZTA1OGZiMGEpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9GYWJhdGthX3B1YmxpY18weDZmYzVkNzQ1ZTA1OGZiMGEpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tCbG9vbVRva2VuMHhiNzY3YWRkMTk4OTUxNmQ2VmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0Jsb29tVG9rZW5WYXVsdCkKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0Jsb29tVG9rZW5WYXVsdCkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0Jsb29tVG9rZW4weGFlZTlhNTY0MTJjMzBhYTJWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvQmxvb21Ub2tlblZhdWx0KQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvQmxvb21Ub2tlblZhdWx0KQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrQmxvb21Ub2tlbjB4ODU5MzJiNDgyNWYyNzVlY1ZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9CbG9vbVRva2VuVmF1bHQpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9CbG9vbVRva2VuVmF1bHQpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tCbG9vbVRva2VuMHgwODljNzMyYzQzY2FmMDkxVmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0Jsb29tVG9rZW5WYXVsdCkKICAgICAgbGV0IGJhbGFuY2U6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL0Jsb29tVG9rZW5WYXVsdCkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0Jsb29tVG9rZW4weDY5Mzc4MjI5N2ExNWQzMjJWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvQmxvb21Ub2tlblZhdWx0KQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvQmxvb21Ub2tlblZhdWx0KQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICANCgogICAgYWNjZXNzKGFsbCkgZnVuIGNoZWNrTW9ja1BZVVNEMHhiMzYyNjZlNTI0YzZjNzI3VmF1bHQoYWRkcmVzczogQWRkcmVzcykgOiBCb29sIHsKICAgICAgbGV0IHJlY2VpdmVyOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAuY2FwYWJpbGl0aWVzLmV4aXN0cygvcHVibGljL21vY2tQWVVTRFJlY2VpdmVyKQogICAgICBsZXQgYmFsYW5jZTogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvbW9ja1BZVVNEVmF1bHQpCiAgICAgIGxldCBmbGFnID0gcmVjZWl2ZXIgJiYgYmFsYW5jZQogICAgICAgcmV0dXJuIGZsYWcKICAgIH0KICAgIA0KCiAgICBhY2Nlc3MoYWxsKSBmdW4gY2hlY2tHUkFJTDB4ZjEzNzQ5ODYxNmExMWJmZVZhdWx0KGFkZHJlc3M6IEFkZHJlc3MpIDogQm9vbCB7CiAgICAgIGxldCByZWNlaXZlcjogQm9vbCA9IGdldEFjY291bnQoYWRkcmVzcykKICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9HUkFJTFRva2VuUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9HUkFJTFRva2VuQmFsYW5jZSkKICAgICAgbGV0IGZsYWcgPSByZWNlaXZlciAmJiBiYWxhbmNlCiAgICAgICByZXR1cm4gZmxhZwogICAgfQogICAgDQoKICAgIGFjY2VzcyhhbGwpIGZ1biBjaGVja0dPQVQweGYxMzc0OTg2MTZhMTFiZmVWYXVsdChhZGRyZXNzOiBBZGRyZXNzKSA6IEJvb2wgewogICAgICBsZXQgcmVjZWl2ZXI6IEJvb2wgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgICAgIC5jYXBhYmlsaXRpZXMuZXhpc3RzKC9wdWJsaWMvR09BVFRva2VuUmVjZWl2ZXIpCiAgICAgIGxldCBiYWxhbmNlOiBCb29sID0gZ2V0QWNjb3VudChhZGRyZXNzKQogICAgICAgLmNhcGFiaWxpdGllcy5leGlzdHMoL3B1YmxpYy9HT0FUVG9rZW5CYWxhbmNlKQogICAgICBsZXQgZmxhZyA9IHJlY2VpdmVyICYmIGJhbGFuY2UKICAgICAgIHJldHVybiBmbGFnCiAgICB9CiAgICAKICAgIGFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpIDoge1N0cmluZzogQm9vbH0gewogICAgICByZXR1cm4gewogICAgIkEuYTk4M2ZlY2JlZDYyMTE2My5GaWF0VG9rZW4iIDoKICAgIGNoZWNrRmlhdFRva2VuMHhhOTgzZmVjYmVkNjIxMTYzVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjkzOTJhNGE3YzNmNDlhMGIuRmxvdmF0YXJEdXN0VG9rZW4iIDoKICAgIGNoZWNrRmxvdmF0YXJEdXN0VG9rZW4weDkzOTJhNGE3YzNmNDlhMGJWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuN2U2MGRmMDQyYTljMDg2OC5GbG93VG9rZW4iIDoKICAgIGNoZWNrRmxvd1Rva2VuMHg3ZTYwZGYwNDJhOWMwODY4VmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjY0YWRmMzljYmMzNTRmY2IuVVNEQ0Zsb3ciIDoKICAgIGNoZWNrVVNEQ0Zsb3cweDY0YWRmMzljYmMzNTRmY2JWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuZTQ1YzY0ZWNmZTMxZTQ2NS5zdEZsb3dUb2tlbiIgOgogICAgY2hlY2tzdEZsb3dUb2tlbjB4ZTQ1YzY0ZWNmZTMxZTQ2NVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS4wMGFmMmFiMzYzZmE0OWU0LkNvc21pY0dBVEUiIDoKICAgIGNoZWNrQ29zbWljR0FURTB4MDBhZjJhYjM2M2ZhNDllNFZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS41NjZjODEzYjM2MzI3ODNlLlNVR09JIiA6CiAgICBjaGVja1NVR09JMHg1NjZjODEzYjM2MzI3ODNlVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLmRmYzIwYWVlNjUwZmNiZGYuRVZNVk1CcmlkZ2VkVG9rZW5fMTExOWNhNGQ1MTQ1NDMyYjdiMWNkMTk3ZDEzNmRhMTVlMjM2ZTg5NiIgOgogICAgY2hlY2tFVk1WTUJyaWRnZWRUb2tlbl8xMTE5Y2E0ZDUxNDU0MzJiN2IxY2QxOTdkMTM2ZGExNWUyMzZlODk2MHhkZmMyMGFlZTY1MGZjYmRmVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjgyZWMyODNmODhhNjJlNjUuRGFwcGVyVXRpbGl0eUNvaW4iIDoKICAgIGNoZWNrRGFwcGVyVXRpbGl0eUNvaW4weDgyZWMyODNmODhhNjJlNjVWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuNTY2YzgxM2IzNjMyNzgzZS5NRURJIiA6CiAgICBjaGVja01FREkweDU2NmM4MTNiMzYzMjc4M2VWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuNTY2YzgxM2IzNjMyNzgzZS5LYXJhdHYyIiA6CiAgICBjaGVja0thcmF0djIweDU2NmM4MTNiMzYzMjc4M2VWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuNTY2YzgxM2IzNjMyNzgzZS5LQVJBVFoxTFhHUEsiIDoKICAgIGNoZWNrS0FSQVRaMUxYR1BLMHg1NjZjODEzYjM2MzI3ODNlVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjU2NmM4MTNiMzYzMjc4M2UuS2FyYXQiIDoKICAgIGNoZWNrS2FyYXQweDU2NmM4MTNiMzYzMjc4M2VWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuNTY2YzgxM2IzNjMyNzgzZS5LQVJBVFoxSlhEWEQiIDoKICAgIGNoZWNrS0FSQVRaMUpYRFhEMHg1NjZjODEzYjM2MzI3ODNlVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjU2NmM4MTNiMzYzMjc4M2UuS0FSQVRaMVRFRlEyIiA6CiAgICBjaGVja0tBUkFUWjFURUZRMjB4NTY2YzgxM2IzNjMyNzgzZVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS4yZDI3MGRiOWFjOGM3ZmVmLlRlbGVwb3J0ZWRUZXRoZXJUb2tlbiIgOgogICAgY2hlY2tUZWxlcG9ydGVkVGV0aGVyVG9rZW4weDJkMjcwZGI5YWM4YzdmZWZWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuZjYzMjE5MDcyYWFkZGQ1MC5TdGFybHlUb2tlbiIgOgogICAgY2hlY2tTdGFybHlUb2tlbjB4ZjYzMjE5MDcyYWFkZGQ1MFZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS42NTNjZmUzNmQxNDZlN2JlLkJsb2N0b1Rva2VuIiA6CiAgICBjaGVja0Jsb2N0b1Rva2VuMHg2NTNjZmUzNmQxNDZlN2JlVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjU2NmM4MTNiMzYzMjc4M2UuR09XVEtOMiIgOgogICAgY2hlY2tHT1dUS04yMHg1NjZjODEzYjM2MzI3ODNlVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjU2NmM4MTNiMzYzMjc4M2UuS0FSQVRNRFY5VCIgOgogICAgY2hlY2tLQVJBVE1EVjlUMHg1NjZjODEzYjM2MzI3ODNlVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjU2NmM4MTNiMzYzMjc4M2UuSk9TSElOIiA6CiAgICBjaGVja0pPU0hJTjB4NTY2YzgxM2IzNjMyNzgzZVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS41NjZjODEzYjM2MzI3ODNlLktBUkFUMkVBMjhIIiA6CiAgICBjaGVja0tBUkFUMkVBMjhIMHg1NjZjODEzYjM2MzI3ODNlVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjU2NmM4MTNiMzYzMjc4M2UuRE9HRVRLTiIgOgogICAgY2hlY2tET0dFVEtOMHg1NjZjODEzYjM2MzI3ODNlVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjU2NmM4MTNiMzYzMjc4M2UuVFNUQ09OIiA6CiAgICBjaGVja1RTVENPTjB4NTY2YzgxM2IzNjMyNzgzZVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS5mOGJhMzIxYWY0YmQzN2JiLmFpU3BvcnRzSnVpY2UiIDoKICAgIGNoZWNrYWlTcG9ydHNKdWljZTB4ZjhiYTMyMWFmNGJkMzdiYlZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS41NjZjODEzYjM2MzI3ODNlLkRXTEMiIDoKICAgIGNoZWNrRFdMQzB4NTY2YzgxM2IzNjMyNzgzZVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS40MzIwNTAyMzJmOWE0OWU3LkZvb1Rva2VuIiA6CiAgICBjaGVja0Zvb1Rva2VuMHg0MzIwNTAyMzJmOWE0OWU3VmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLmE2MjJhZmFkMDdmNjczOWUuTm9jZW5peCIgOgogICAgY2hlY2tOb2Nlbml4MHhhNjIyYWZhZDA3ZjY3MzllVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjA4OThmYTQ4OTZkNzM3NTIuVVNEQ0Zsb3ciIDoKICAgIGNoZWNrVVNEQ0Zsb3cweDA4OThmYTQ4OTZkNzM3NTJWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuNTY2YzgxM2IzNjMyNzgzZS5Tb3JhY2hpIiA6CiAgICBjaGVja1NvcmFjaGkweDU2NmM4MTNiMzYzMjc4M2VWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuNTY2YzgxM2IzNjMyNzgzZS5LQVJBVFoyMU1QS1AiIDoKICAgIGNoZWNrS0FSQVRaMjFNUEtQMHg1NjZjODEzYjM2MzI3ODNlVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLmNhYjgzMDA5MzVkOTBiOWEuSlBZMjQiIDoKICAgIGNoZWNrSlBZMjQweGNhYjgzMDA5MzVkOTBiOWFWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuY2FiODMwMDkzNWQ5MGI5YS5QT0lOVDI0IiA6CiAgICBjaGVja1BPSU5UMjQweGNhYjgzMDA5MzVkOTBiOWFWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuNTY2YzgxM2IzNjMyNzgzZS5LQVJBVFoxODVNUEwiIDoKICAgIGNoZWNrS0FSQVRaMTg1TVBMMHg1NjZjODEzYjM2MzI3ODNlVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLmNhYjgzMDA5MzVkOTBiOWEuSEgyNCIgOgogICAgY2hlY2tISDI0MHhjYWI4MzAwOTM1ZDkwYjlhVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLmNhYjgzMDA5MzVkOTBiOWEuSEgyNEsiIDoKICAgIGNoZWNrSEgyNEsweGNhYjgzMDA5MzVkOTBiOWFWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuMmFiNmY0NjllZTBkZmJiNi5ZaWVsZFRva2VuIiA6CiAgICBjaGVja1lpZWxkVG9rZW4weDJhYjZmNDY5ZWUwZGZiYjZWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuNTY2YzgxM2IzNjMyNzgzZS5LQVJBVFoxSzBYNE8iIDoKICAgIGNoZWNrS0FSQVRaMUswWDRPMHg1NjZjODEzYjM2MzI3ODNlVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjJhYjZmNDY5ZWUwZGZiYjYuTU9FVCIgOgogICAgY2hlY2tNT0VUMHgyYWI2ZjQ2OWVlMGRmYmI2VmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLmRmYzIwYWVlNjUwZmNiZGYuRVZNVk1CcmlkZ2VkVG9rZW5fYTdjZjIyNjBlNTAxOTUyYzcxMTg5ZDA0ZmFkMTdjNzA0ZGZiMzZlNiIgOgogICAgY2hlY2tFVk1WTUJyaWRnZWRUb2tlbl9hN2NmMjI2MGU1MDE5NTJjNzExODlkMDRmYWQxN2M3MDRkZmIzNmU2MHhkZmMyMGFlZTY1MGZjYmRmVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLmNhYjgzMDA5MzVkOTBiOWEuVE9LRU5fSUVPXzEiIDoKICAgIGNoZWNrVE9LRU5fSUVPXzEweGNhYjgzMDA5MzVkOTBiOWFWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuZGZjMjBhZWU2NTBmY2JkZi5FVk1WTUJyaWRnZWRUb2tlbl9kNDMxOTU1ZDU1YTk5ZWY2OWJlYjk2YmEzNDcxOGQwZjlmYmM5MWIxIiA6CiAgICBjaGVja0VWTVZNQnJpZGdlZFRva2VuX2Q0MzE5NTVkNTVhOTllZjY5YmViOTZiYTM0NzE4ZDBmOWZiYzkxYjEweGRmYzIwYWVlNjUwZmNiZGZWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuY2FiODMwMDkzNWQ5MGI5YS5LQVJBVFpIMjQyUCIgOgogICAgY2hlY2tLQVJBVFpIMjQyUDB4Y2FiODMwMDkzNWQ5MGI5YVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS5jYWI4MzAwOTM1ZDkwYjlhLktBUkFUWjFET0I4OCIgOgogICAgY2hlY2tLQVJBVFoxRE9CODgweGNhYjgzMDA5MzVkOTBiOWFWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuZTExY2FiODVlODVhZTEzNy5XcmFwcGVkRVRIMSIgOgogICAgY2hlY2tXcmFwcGVkRVRIMTB4ZTExY2FiODVlODVhZTEzN1ZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS43YzFhNmU0YjdlYjQxOWMxLkNIVG9rZW4iIDoKICAgIGNoZWNrQ0hUb2tlbjB4N2MxYTZlNGI3ZWI0MTljMVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS5kMWQxMGFlY2UyZDYxYjljLkFUTlRva2VuIiA6CiAgICBjaGVja0FUTlRva2VuMHhkMWQxMGFlY2UyZDYxYjljVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjkxOWQ2OWE5ZDBlZmEzOWIuQ0hUb2tlbiIgOgogICAgY2hlY2tDSFRva2VuMHg5MTlkNjlhOWQwZWZhMzliVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjg1MDM4MDNjM2FjZjZkNTYuTW9ja1VTREMiIDoKICAgIGNoZWNrTW9ja1VTREMweDg1MDM4MDNjM2FjZjZkNTZWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuZTExY2FiODVlODVhZTEzNy5XcmFwcGVkVVNEQzEiIDoKICAgIGNoZWNrV3JhcHBlZFVTREMxMHhlMTFjYWI4NWU4NWFlMTM3VmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjA4NGEzMDg4OTRkZGNlMTkuTW9ja1VTREMiIDoKICAgIGNoZWNrTW9ja1VTREMweDA4NGEzMDg4OTRkZGNlMTlWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuNWQ2OTdjN2Q3NGJjMDQzMi5Nb2NrVVNEQyIgOgogICAgY2hlY2tNb2NrVVNEQzB4NWQ2OTdjN2Q3NGJjMDQzMlZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS5kMDIwY2NjOWRhYWVhNzdkLlRvdWNhblRva2VuIiA6CiAgICBjaGVja1RvdWNhblRva2VuMHhkMDIwY2NjOWRhYWVhNzdkVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjIzNzY1Njc0NmJjNjk3NjUuVmF1bHRTaGFyZVRva2VuX1YwMDEiIDoKICAgIGNoZWNrVmF1bHRTaGFyZVRva2VuX1YwMDEweDIzNzY1Njc0NmJjNjk3NjVWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuMjM3NjU2NzQ2YmM2OTc2NS5WYXVsdFNoYXJlVG9rZW5fQk9ORCIgOgogICAgY2hlY2tWYXVsdFNoYXJlVG9rZW5fQk9ORDB4MjM3NjU2NzQ2YmM2OTc2NVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS40NTMxNGU2MDZjZDJiZDFmLkV4YW1wbGVUb2tlbiIgOgogICAgY2hlY2tFeGFtcGxlVG9rZW4weDQ1MzE0ZTYwNmNkMmJkMWZWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuMjM3NjU2NzQ2YmM2OTc2NS5WYXVsdFNoYXJlVG9rZW5fVjEwMSIgOgogICAgY2hlY2tWYXVsdFNoYXJlVG9rZW5fVjEwMTB4MjM3NjU2NzQ2YmM2OTc2NVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS5jYWI4MzAwOTM1ZDkwYjlhLktBUkFUWjFQUE1WNCIgOgogICAgY2hlY2tLQVJBVFoxUFBNVjQweGNhYjgzMDA5MzVkOTBiOWFWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuYzE2YzBiMTIyOTg0MzYwNi5NT0VUIiA6CiAgICBjaGVja01PRVQweGMxNmMwYjEyMjk4NDM2MDZWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuY2FiODMwMDkzNWQ5MGI5YS5UT0tFTl9JRU9fMyIgOgogICAgY2hlY2tUT0tFTl9JRU9fMzB4Y2FiODMwMDkzNWQ5MGI5YVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS5lZGUwNTdjZTk5MTUxNjZiLkV4YW1wbGVUb2tlbiIgOgogICAgY2hlY2tFeGFtcGxlVG9rZW4weGVkZTA1N2NlOTkxNTE2NmJWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuZGZjMjBhZWU2NTBmY2JkZi5FVk1WTUJyaWRnZWRUb2tlbl9lYjU2NjA3MDkxMmU4MmE3OTcxMjMyZjA2ZGNmN2U3OTU2ODY5MWE4IiA6CiAgICBjaGVja0VWTVZNQnJpZGdlZFRva2VuX2ViNTY2MDcwOTEyZTgyYTc5NzEyMzJmMDZkY2Y3ZTc5NTY4NjkxYTgweGRmYzIwYWVlNjUwZmNiZGZWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuZGZjMjBhZWU2NTBmY2JkZi5FVk1WTUJyaWRnZWRUb2tlbl80ZTJkY2NhZmU4NjcxOWI3YmZmYWMzYjEwNDEwMzFkZGQwN2FmNWZmIiA6CiAgICBjaGVja0VWTVZNQnJpZGdlZFRva2VuXzRlMmRjY2FmZTg2NzE5YjdiZmZhYzNiMTA0MTAzMWRkZDA3YWY1ZmYweGRmYzIwYWVlNjUwZmNiZGZWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuZDI3OTIwYjYzODRlMmE3OC5NT0VUIiA6CiAgICBjaGVja01PRVQweGQyNzkyMGI2Mzg0ZTJhNzhWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuNDI2ZjA0NThjZWQ2MDAzNy5NT0VUIiA6CiAgICBjaGVja01PRVQweDQyNmYwNDU4Y2VkNjAwMzdWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuZGZjMjBhZWU2NTBmY2JkZi5FVk1WTUJyaWRnZWRUb2tlbl80MTU0ZDViMGUyOTMxYTBhMWU1YjczM2YxOTE2MWFhN2QyZmM0Yjk1IiA6CiAgICBjaGVja0VWTVZNQnJpZGdlZFRva2VuXzQxNTRkNWIwZTI5MzFhMGExZTViNzMzZjE5MTYxYWE3ZDJmYzRiOTUweGRmYzIwYWVlNjUwZmNiZGZWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuY2FiODMwMDkzNWQ5MGI5YS5UT0tFTl9JRU9fNCIgOgogICAgY2hlY2tUT0tFTl9JRU9fNDB4Y2FiODMwMDkzNWQ5MGI5YVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS5jYWI4MzAwOTM1ZDkwYjlhLlRPS0VOX0lFT181IiA6CiAgICBjaGVja1RPS0VOX0lFT181MHhjYWI4MzAwOTM1ZDkwYjlhVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLmNhYjgzMDA5MzVkOTBiOWEuS0FSQVQyUDhCVUwiIDoKICAgIGNoZWNrS0FSQVQyUDhCVUwweGNhYjgzMDA5MzVkOTBiOWFWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuZGZjMjBhZWU2NTBmY2JkZi5FVk1WTUJyaWRnZWRUb2tlbl8yMDhkMDlkMmE2ZGQxNzZlM2U5NWIzZjBkZTE3MmE3NDcxYzViMmQ2IiA6CiAgICBjaGVja0VWTVZNQnJpZGdlZFRva2VuXzIwOGQwOWQyYTZkZDE3NmUzZTk1YjNmMGRlMTcyYTc0NzFjNWIyZDYweGRmYzIwYWVlNjUwZmNiZGZWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuNDQ2OWY1MjQxYmNiMTFkMy5HYW1lVG9rZW4iIDoKICAgIGNoZWNrR2FtZVRva2VuMHg0NDY5ZjUyNDFiY2IxMWQzVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjdmYWE1MWY0Zjk3YmRkZmEuR2FtZVRva2VuIiA6CiAgICBjaGVja0dhbWVUb2tlbjB4N2ZhYTUxZjRmOTdiZGRmYVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS5kZmMyMGFlZTY1MGZjYmRmLkVWTVZNQnJpZGdlZFRva2VuXzA1OWE3NzIzOWRhZmE3NzA5NzdkZDlmMWU5ODYzMmMzZTQ1NTk4NDgiIDoKICAgIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fMDU5YTc3MjM5ZGFmYTc3MDk3N2RkOWYxZTk4NjMyYzNlNDU1OTg0ODB4ZGZjMjBhZWU2NTBmY2JkZlZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS5kZmMyMGFlZTY1MGZjYmRmLkVWTVZNQnJpZGdlZFRva2VuX2Q3ZDQzYWI3YjM2NWYwZDA3ODlhZTgzZjQzODVmYTcxMGZmZGM5OGYiIDoKICAgIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fZDdkNDNhYjdiMzY1ZjBkMDc4OWFlODNmNDM4NWZhNzEwZmZkYzk4ZjB4ZGZjMjBhZWU2NTBmY2JkZlZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS5kZmMyMGFlZTY1MGZjYmRmLkVWTVZNQnJpZGdlZFRva2VuXzYxYjQ0ZDE5NDg2ZWU0OTI0NDllODNjMTIwMTU4MWM3NTRlOWUxZTEiIDoKICAgIGNoZWNrRVZNVk1CcmlkZ2VkVG9rZW5fNjFiNDRkMTk0ODZlZTQ5MjQ0OWU4M2MxMjAxNTgxYzc1NGU5ZTFlMTB4ZGZjMjBhZWU2NTBmY2JkZlZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS5mMWMyNDViMGUzNGYyMjM1LkdhbWVUb2tlbiIgOgogICAgY2hlY2tHYW1lVG9rZW4weGYxYzI0NWIwZTM0ZjIyMzVWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuOGFiYzNkMGM0ZTkxNzEyYi5HYW1lVG9rZW4iIDoKICAgIGNoZWNrR2FtZVRva2VuMHg4YWJjM2QwYzRlOTE3MTJiVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjYyMWM4MDhiOWE0NDJkMGEuR2FtZVRva2VuIiA6CiAgICBjaGVja0dhbWVUb2tlbjB4NjIxYzgwOGI5YTQ0MmQwYVZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS5hNzM1Mzk5ZWQ0OGMwZDUzLkdhbWVUb2tlbiIgOgogICAgY2hlY2tHYW1lVG9rZW4weGE3MzUzOTllZDQ4YzBkNTNWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuZDI1ODBjYWYyZWYwN2MyZi5ZaWVsZFRva2VuIiA6CiAgICBjaGVja1lpZWxkVG9rZW4weGQyNTgwY2FmMmVmMDdjMmZWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuNmUxMjMyM2Y0NTAxNzU0ZC5CbG9vbVRva2VuIiA6CiAgICBjaGVja0Jsb29tVG9rZW4weDZlMTIzMjNmNDUwMTc1NGRWYXVsdChhZGRyZXNzOiBhZGRyZXNzKQogICAgLAogICAgIkEuNmZjNWQ3NDVlMDU4ZmIwYS5HYW1lVG9rZW4iIDoKICAgIGNoZWNrR2FtZVRva2VuMHg2ZmM1ZDc0NWUwNThmYjBhVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLmI3NjdhZGQxOTg5NTE2ZDYuQmxvb21Ub2tlbiIgOgogICAgY2hlY2tCbG9vbVRva2VuMHhiNzY3YWRkMTk4OTUxNmQ2VmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLmFlZTlhNTY0MTJjMzBhYTIuQmxvb21Ub2tlbiIgOgogICAgY2hlY2tCbG9vbVRva2VuMHhhZWU5YTU2NDEyYzMwYWEyVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjg1OTMyYjQ4MjVmMjc1ZWMuQmxvb21Ub2tlbiIgOgogICAgY2hlY2tCbG9vbVRva2VuMHg4NTkzMmI0ODI1ZjI3NWVjVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjA4OWM3MzJjNDNjYWYwOTEuQmxvb21Ub2tlbiIgOgogICAgY2hlY2tCbG9vbVRva2VuMHgwODljNzMyYzQzY2FmMDkxVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLjY5Mzc4MjI5N2ExNWQzMjIuQmxvb21Ub2tlbiIgOgogICAgY2hlY2tCbG9vbVRva2VuMHg2OTM3ODIyOTdhMTVkMzIyVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLmIzNjI2NmU1MjRjNmM3MjcuTW9ja1BZVVNEIiA6CiAgICBjaGVja01vY2tQWVVTRDB4YjM2MjY2ZTUyNGM2YzcyN1ZhdWx0KGFkZHJlc3M6IGFkZHJlc3MpCiAgICAsCiAgICAiQS5mMTM3NDk4NjE2YTExYmZlLkdSQUlMIiA6CiAgICBjaGVja0dSQUlMMHhmMTM3NDk4NjE2YTExYmZlVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgICwKICAgICJBLmYxMzc0OTg2MTZhMTFiZmUuR09BVCIgOgogICAgY2hlY2tHT0FUMHhmMTM3NDk4NjE2YTExYmZlVmF1bHQoYWRkcmVzczogYWRkcmVzcykKICAgIH0KICAgIH0KICA\u003d", + "getTokenListBalance": "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\u003d\u003d", + "addToken": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYWRkVG9rZW4gLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgppbXBvcnQgPFRva2VuPiBmcm9tIDxUb2tlbkFkZHJlc3M+Cgp0cmFuc2FjdGlvbiB7CgogICAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSwgQ2FwYWJpbGl0aWVzKSAmQWNjb3VudCkgewoKICAgICAgICBpZiBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8JjxUb2tlbj4uVmF1bHQ+KGZyb206IDxUb2tlblN0b3JhZ2VQYXRoPiApID09IG5pbCB7CiAgICAgICAgICAgIHNpZ25lci5zdG9yYWdlLnNhdmUoPC0gPFRva2VuPi5jcmVhdGVFbXB0eVZhdWx0KHZhdWx0VHlwZTogVHlwZTxAPFRva2VuPi5WYXVsdD4oKSksIHRvOiA8VG9rZW5TdG9yYWdlUGF0aD4pCiAgICAgICAgfQoKICAgICAgICBpZiBzaWduZXIuY2FwYWJpbGl0aWVzLmV4aXN0cyg8VG9rZW5SZWNlaXZlclBhdGg+KSA9PSBmYWxzZSB7CiAgICAgICAgICAgIGxldCByZWNlaXZlckNhcGFiaWxpdHkgPSBzaWduZXIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8JjxUb2tlbj4uVmF1bHQ+KDxUb2tlblN0b3JhZ2VQYXRoPikKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5wdWJsaXNoKHJlY2VpdmVyQ2FwYWJpbGl0eSwgYXQ6IDxUb2tlblJlY2VpdmVyUGF0aD4pCiAgICAgICAgCiAgICAgICAgfQogICAgICAgCiAgICAgICAgaWYgc2lnbmVyLmNhcGFiaWxpdGllcy5leGlzdHMoPFRva2VuQmFsYW5jZVBhdGg+KSA9PSBmYWxzZSB7CiAgICAgICAgICAgIGxldCBiYWxhbmNlQ2FwYWJpbGl0eSA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTwmPFRva2VuPi5WYXVsdD4oPFRva2VuU3RvcmFnZVBhdGg+KQogICAgICAgICAgICBzaWduZXIuY2FwYWJpbGl0aWVzLnB1Ymxpc2goYmFsYW5jZUNhcGFiaWxpdHksIGF0OiA8VG9rZW5CYWxhbmNlUGF0aD4pCiAgICAgICAgfQogICAgCiAgICB9Cn0\u003d", + "enableTokenStorage": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZW5hYmxlVG9rZW5TdG9yYWdlIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKaW1wb3J0IDxUb2tlbj4gZnJvbSA8VG9rZW5BZGRyZXNzPgoKdHJhbnNhY3Rpb24gewoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIENhcGFiaWxpdGllcykgJkFjY291bnQpIHsKCiAgICAgICAgaWYgc2lnbmVyLnN0b3JhZ2UuYm9ycm93PCY8VG9rZW4+LlZhdWx0Pihmcm9tOiA8VG9rZW5TdG9yYWdlUGF0aD4gKSA9PSBuaWwgewogICAgICAgICAgICBzaWduZXIuc3RvcmFnZS5zYXZlKDwtIDxUb2tlbj4uY3JlYXRlRW1wdHlWYXVsdCh2YXVsdFR5cGU6IFR5cGU8QDxUb2tlbj4uVmF1bHQ+KCkpLCB0bzogPFRva2VuU3RvcmFnZVBhdGg+KQogICAgICAgIH0KCiAgICAgICAgaWYgc2lnbmVyLmNhcGFiaWxpdGllcy5leGlzdHMoPFRva2VuUmVjZWl2ZXJQYXRoPikgPT0gZmFsc2UgewogICAgICAgICAgICBsZXQgcmVjZWl2ZXJDYXBhYmlsaXR5ID0gc2lnbmVyLmNhcGFiaWxpdGllcy5zdG9yYWdlLmlzc3VlPCY8VG9rZW4+LlZhdWx0Pig8VG9rZW5TdG9yYWdlUGF0aD4pCiAgICAgICAgICAgIHNpZ25lci5jYXBhYmlsaXRpZXMucHVibGlzaChyZWNlaXZlckNhcGFiaWxpdHksIGF0OiA8VG9rZW5SZWNlaXZlclBhdGg+KQogICAgICAgIAogICAgICAgIH0KICAgICAgIAogICAgICAgIGlmIHNpZ25lci5jYXBhYmlsaXRpZXMuZXhpc3RzKDxUb2tlbkJhbGFuY2VQYXRoPikgPT0gZmFsc2UgewogICAgICAgICAgICBsZXQgYmFsYW5jZUNhcGFiaWxpdHkgPSBzaWduZXIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8JjxUb2tlbj4uVmF1bHQ+KDxUb2tlblN0b3JhZ2VQYXRoPikKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5wdWJsaXNoKGJhbGFuY2VDYXBhYmlsaXR5LCBhdDogPFRva2VuQmFsYW5jZVBhdGg+KQogICAgICAgIH0KICAgIAogICAgfQp9", + "enableTokenStorageV2": "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", + "getTokenBalanceStorage": "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\u003d\u003d", + "transferEvmTokens": "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\u003d", + "transferTokens": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdHJhbnNmZXJUb2tlbnMgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgppbXBvcnQgPFRva2VuPiBmcm9tIDxUb2tlbkFkZHJlc3M+CgoKdHJhbnNhY3Rpb24oYW1vdW50OiBVRml4NjQsIHJlY2lwaWVudDogQWRkcmVzcykgewoKICAgIC8vIFRoZSBWYXVsdCByZXNvdXJjZSB0aGF0IGhvbGRzIHRoZSB0b2tlbnMgdGhhdCBhcmUgYmVpbmcgdHJhbnNmZXJlZAogICAgbGV0IHNlbnRWYXVsdDogQHtGdW5naWJsZVRva2VuLlZhdWx0fQoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgICAvLyBHZXQgYSByZWZlcmVuY2UgdG8gdGhlIHNpZ25lcidzIHN0b3JlZCB2YXVsdAogICAgICAgIGxldCB2YXVsdFJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICY8VG9rZW4+LlZhdWx0Pihmcm9tOiA8VG9rZW5TdG9yYWdlUGF0aD4pCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IHJlZmVyZW5jZSB0byB0aGUgb3duZXIncyBWYXVsdCEiKQoKICAgICAgICAvLyBXaXRoZHJhdyB0b2tlbnMgZnJvbSB0aGUgc2lnbmVyJ3Mgc3RvcmVkIHZhdWx0CiAgICAgICAgc2VsZi5zZW50VmF1bHQgPC0gdmF1bHRSZWYud2l0aGRyYXcoYW1vdW50OiBhbW91bnQpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgLy8gR2V0IHRoZSByZWNpcGllbnQncyBwdWJsaWMgYWNjb3VudCBvYmplY3QKICAgICAgICBsZXQgcmVjaXBpZW50QWNjb3VudCA9IGdldEFjY291bnQocmVjaXBpZW50KQoKICAgICAgICAvLyBHZXQgYSByZWZlcmVuY2UgdG8gdGhlIHJlY2lwaWVudCdzIFJlY2VpdmVyCiAgICAgICAgbGV0IHJlY2VpdmVyUmVmID0gcmVjaXBpZW50QWNjb3VudC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5WYXVsdH0+KDxUb2tlblJlY2VpdmVyUGF0aD4pIQogICAgICAgICAgICAKICAgICAgICAvLyBEZXBvc2l0IHRoZSB3aXRoZHJhd24gdG9rZW5zIGluIHRoZSByZWNpcGllbnQncyByZWNlaXZlcgogICAgICAgIHJlY2VpdmVyUmVmLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKCiAgICB9Cn0\u003d", + "transferTokensV3": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdHJhbnNmZXJUb2tlbnNWMyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCmltcG9ydCBTdG9yYWdlUmVudCBmcm9tIDB4ZDUwMDg0YTFhNDNiMTUwNwoKaW1wb3J0IDxUb2tlbj4gZnJvbSA8VG9rZW5BZGRyZXNzPgoKCnRyYW5zYWN0aW9uKGFtb3VudDogVUZpeDY0LCByZWNpcGllbnQ6IEFkZHJlc3MpIHsKCiAgICAvLyBUaGUgVmF1bHQgcmVzb3VyY2UgdGhhdCBob2xkcyB0aGUgdG9rZW5zIHRoYXQgYXJlIGJlaW5nIHRyYW5zZmVyZWQKICAgIGxldCBzZW50VmF1bHQ6IEB7RnVuZ2libGVUb2tlbi5WYXVsdH0KCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChTdG9yYWdlLCBCb3Jyb3dWYWx1ZSkgJkFjY291bnQpIHsKICAgICAgICAgLy8gR2V0IGEgcmVmZXJlbmNlIHRvIHRoZSBzaWduZXIncyBzdG9yZWQgdmF1bHQKICAgICAgICBsZXQgdmF1bHRSZWYgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAmPFRva2VuPi5WYXVsdD4oZnJvbTogPFRva2VuU3RvcmFnZVBhdGg+KQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyByZWZlcmVuY2UgdG8gdGhlIG93bmVyJ3MgVmF1bHQhIikKCiAgICAgICAgLy8gV2l0aGRyYXcgdG9rZW5zIGZyb20gdGhlIHNpZ25lcidzIHN0b3JlZCB2YXVsdAogICAgICAgIHNlbGYuc2VudFZhdWx0IDwtIHZhdWx0UmVmLndpdGhkcmF3KGFtb3VudDogYW1vdW50KQogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIC8vIEdldCB0aGUgcmVjaXBpZW50J3MgcHVibGljIGFjY291bnQgb2JqZWN0CiAgICAgICAgbGV0IHJlY2lwaWVudEFjY291bnQgPSBnZXRBY2NvdW50KHJlY2lwaWVudCkKCiAgICAgICAgLy8gR2V0IGEgcmVmZXJlbmNlIHRvIHRoZSByZWNpcGllbnQncyBSZWNlaXZlcgogICAgICAgIGxldCByZWNlaXZlclJlZiA9IHJlY2lwaWVudEFjY291bnQuY2FwYWJpbGl0aWVzLmJvcnJvdzwme0Z1bmdpYmxlVG9rZW4uVmF1bHR9Pig8VG9rZW5SZWNlaXZlclBhdGg+KSEKICAgICAgICAgICAgCiAgICAgICAgLy8gRGVwb3NpdCB0aGUgd2l0aGRyYXduIHRva2VucyBpbiB0aGUgcmVjaXBpZW50J3MgcmVjZWl2ZXIKICAgICAgICByZWNlaXZlclJlZi5kZXBvc2l0KGZyb206IDwtc2VsZi5zZW50VmF1bHQpCiAgICAgICAgU3RvcmFnZVJlbnQudHJ5UmVmaWxsKHJlY2lwaWVudCkKCiAgICB9Cn0\u003d" }, "hybridCustody": { - "addNFTCollectionToDelegator": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYWRkTkZUQ29sbGVjdGlvblRvRGVsZWdhdG9yIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgSHlicmlkQ3VzdG9keSBmcm9tIDB4Mjk0ZTQ0ZTFlYzY5OTNjNgoKCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4NjMxZTg4YWU3ZjFkN2MyMAoKaW1wb3J0IDxUb2tlbj4gZnJvbSA8VG9rZW5BZGRyZXNzPgoKdHJhbnNhY3Rpb24ocGFyZW50OiBBZGRyZXNzLCBpc1B1YmxpYzogQm9vbCkgewogICAgcHJlcGFyZShhY2N0OiBhdXRoKFN0b3JhZ2UsIENhcGFiaWxpdGllcykgJkFjY291bnQpIHsKICAgICAgICBsZXQgbyA9IGFjY3Quc3RvcmFnZS5ib3Jyb3c8YXV0aChIeWJyaWRDdXN0b2R5Lk93bmVyKSAmSHlicmlkQ3VzdG9keS5Pd25lZEFjY291bnQ+KGZyb206IEh5YnJpZEN1c3RvZHkuT3duZWRBY2NvdW50U3RvcmFnZVBhdGgpCiAgICAgICAgICAgID8/IHBhbmljKCJvd25lZCBhY2NvdW50IG5vdCBmb3VuZCIpCiAgICAgICAgbGV0IGNoaWxkOiAmSHlicmlkQ3VzdG9keS5DaGlsZEFjY291bnQgPSBvLmJvcnJvd0NoaWxkQWNjb3VudChwYXJlbnQ6IHBhcmVudCkKICAgICAgICAgICAgPz8gcGFuaWMoImNoaWxkIGFjY291bnQgbm90IGZvdW5kIikKCiAgICAgICAgbGV0IGNhcCA9IGFjY3QuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8JkV4YW1wbGVORlQuQ29sbGVjdGlvbj4oRXhhbXBsZU5GVC5Db2xsZWN0aW9uU3RvcmFnZVBhdGgpCiAgICAgICAgby5hZGRDYXBhYmlsaXR5VG9EZWxlZ2F0b3IocGFyZW50OiBwYXJlbnQsIGNhcDogY2FwLCBpc1B1YmxpYzogaXNQdWJsaWMpCiAgICB9Cn0\u003d", - "batchBridgeChildNFTFromEvm": "// Flow Wallet - testnet Script  batchBridgeChildNFTFromEvm - v2.72
// <platform_info>

import MetadataViews from 0x631e88ae7f1d7c20

import ViewResolver from 0x631e88ae7f1d7c20

import NonFungibleToken from 0x631e88ae7f1d7c20

import FungibleToken from 0x9a0766d93b6608b7

import FlowToken from 0x7e60df042a9c0868

import FungibleTokenMetadataViews from 0x9a0766d93b6608b7

import ScopedFTProviders from 0xdfc20aee650fcbdf

import EVM from 0x8c5303eaa26202d6

import FlowEVMBridgeUtils from 0xdfc20aee650fcbdf

import FlowEVMBridge from 0xdfc20aee650fcbdf

import FlowEVMBridgeConfig from 0xdfc20aee650fcbdf

import HybridCustody from 0x294e44e1ec6993c6

import CapabilityFilter from 0x294e44e1ec6993c6

import CrossVMMetadataViews from 0x631e88ae7f1d7c20


transaction(nftIdentifier: String, child: Address, ids: [UInt256]) {

    prepare(signer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        let coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        // Construct the NFT type from the provided identifier
        let nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        let m = signer.storage.borrow<auth(HybridCustody.Manage) &HybridCustody.Manager>(from: HybridCustody.ManagerStoragePath)
            ?? panic("manager does not exist")
        let childAcct = m.borrowAccount(addr: child) ?? panic("child account not found")

        /* --- Retrieve the NFT --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        let viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = viewResolver.resolveContractView(
                resourceType: nil,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")

        let capType = Type<&{NonFungibleToken.CollectionPublic}>()
        let controllerID = childAcct.getControllerIDForType(type: capType, forPath: collectionData.storagePath)
            ?? panic("no controller found for capType")

        let cap = childAcct.getCapability(controllerID: controllerID, type: capType) ?? panic("no cap found")
        let publicCap = cap as! Capability<&{NonFungibleToken.CollectionPublic}>
        assert(publicCap.check(), message: "invalid public capability")

        // Get a reference to the child's stored vault
        let collectionRef = publicCap.borrow()!

        // Calculate the approximate fee for the bridge
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000) + (FlowEVMBridgeConfig.baseFee * UFix64(ids.length))

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        let scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )

        // Unwrap NFTs if applicable
        unwrapNFTsIfApplicable(coa, nftIDs: ids, nftType: nftType, viewResolver: viewResolver)

        // Bridge NFTs from EVM to child flow account
        for id in ids {
            let nft: @{NonFungibleToken.NFT} <- coa.withdrawNFT(
                type: nftType,
                id: id,
                feeProvider: &scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )

            assert(
                nft.getType() == nftType,
                message: "Bridged nft type mismatch - requeswted: ".concat(nftType.identifier)
                    .concat(", received: ").concat(nft.getType().identifier)
            )

            collectionRef.deposit(token: <- nft)
        }

        // Destroy the ScopedFTProvider
        destroy scopedProvider
    }
}

/// Unwraps NFTs from a project's custom ERC721 wrapper contract to bridged NFTs on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
///
access(all) fun unwrapNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt256],
    nftType: Type,
    viewResolver: &{ViewResolver}
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            for id in nftIDs {
                // Unwrap NFT if it is wrapped
                if isNFTWrapped(coa,
                    nftID: id,
                    underlying: underlyingAddress,
                    wrapper: crossVMPointer.evmContractAddress
                ) {
                    let res = mustCall(coa, crossVMPointer.evmContractAddress,
                        functionSig: "withdrawTo(address,uint256[])",
                        args: [coa.address(), [id]]
                    )
                    let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                    assert(decodedRes.length == 1, message: "Invalid response length")
                    assert(decodedRes[0] as! Bool, message: "Failed to unwrap NFT")
                }
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is wrapped in the underlying ERC721 contract
///
access(all) fun isNFTWrapped(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftID: UInt256,
    underlying: EVM.EVMAddress,
    wrapper: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: underlying,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return false
    if res.status != EVM.Status.successful || res.data.length == 0{
        return false
    }

    // Decode and compare the addresses
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    let owner = decodedResult[0] as! EVM.EVMAddress
    return owner.toString() == wrapper.toString()
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", - "batchBridgeChildNFTToEvm": "// Flow Wallet - testnet Script  batchBridgeChildNFTToEvm - v2.72
// <platform_info>

import MetadataViews from 0x631e88ae7f1d7c20

import ViewResolver from 0x631e88ae7f1d7c20

import NonFungibleToken from 0x631e88ae7f1d7c20

import FungibleToken from 0x9a0766d93b6608b7

import FlowToken from 0x7e60df042a9c0868

import FungibleTokenMetadataViews from 0x9a0766d93b6608b7

import ScopedFTProviders from 0xdfc20aee650fcbdf

import EVM from 0x8c5303eaa26202d6

import FlowEVMBridgeUtils from 0xdfc20aee650fcbdf

import FlowEVMBridge from 0xdfc20aee650fcbdf

import FlowEVMBridgeConfig from 0xdfc20aee650fcbdf

import HybridCustody from 0x294e44e1ec6993c6

import CapabilityFilter from 0x294e44e1ec6993c6

import CrossVMMetadataViews from 0x631e88ae7f1d7c20


transaction(nftIdentifier: String, child: Address, ids: [UInt64]) {
    prepare(signer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, Capabilities, SaveValue) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        let coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        let m = signer.storage.borrow<auth(HybridCustody.Manage) &HybridCustody.Manager>(from: HybridCustody.ManagerStoragePath)
            ?? panic("manager does not exist")
        let childAcct = m.borrowAccount(addr: child) ?? panic("child account not found")

         // Construct the NFT type from the provided identifier
        let nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Retrieve the NFT --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        let viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = viewResolver.resolveContractView(
                resourceType: nil,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        var collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            )

        // Create collection if it doesn't exist
        if collection == nil {
            signer.storage.save(<- collectionData.createEmptyCollection(), to: collectionData.storagePath)
            signer.capabilities.unpublish(collectionData.publicPath)
            signer.capabilities.publish(
                signer.capabilities.storage.issue<&{NonFungibleToken.Collection}>(collectionData.storagePath),
                at: collectionData.publicPath
            )

            // Borrow authorized withdraw reference to the signer's collection
            collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            )!
        }

        let capType = Type<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider}>()
        let controllerID = childAcct.getControllerIDForType(type: capType, forPath: collectionData.storagePath)
            ?? panic("no controller found for capType")

        let cap = childAcct.getCapability(controllerID: controllerID, type: capType) ?? panic("no cap found")
        let providerCap = cap as! Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider}>
        assert(providerCap.check(), message: "invalid provider capability")

        let id = ids[0]
        // Get a reference to the child's stored vault
        let collectionRef = providerCap.borrow()!
        let childNft <- collectionRef.withdraw(withdrawID: id)
        collection!.deposit(token: <-childNft)
        // // Withdraw tokens from the signer's stored vault
        let currentStorageUsage = signer.storage.used
        let nft <- collection!.withdraw(withdrawID: id)
        let withdrawnStorageUsage = signer.storage.used
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(
                bytes: 400_000
            ) + (FlowEVMBridgeConfig.baseFee * UFix64(ids.length))

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        let scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )

        // Execute the bridge
        coa.depositNFT(
            nft: <- nft,
            feeProvider: &scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        var idx = 0
        for nftId in ids {
            if idx == 0 {
                idx = idx + 1
                continue
            }

            let nft <- collectionRef.withdraw(withdrawID: nftId)
            coa.depositNFT(
                nft: <- nft,
                feeProvider: &scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
            idx = idx + 1
        }
        // Destroy the ScopedFTProvider
        destroy scopedProvider

        // Wrap NFTs if applicable
        wrapAndTransferNFTsIfApplicable(coa,
            nftIDs: ids,
            nftType: nftType,
            viewResolver: viewResolver,
            recipientIfNotCoa: nil
        )
    }
}

/// Wraps and transfers bridged NFTs into a project's custom ERC721 wrapper contract on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
/// @param recipientIfNotCoa: The EVM address to transfer the wrapped NFTs to, nil if the NFTs should stay in signer's COA
///
access(all) fun wrapAndTransferNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt64],
    nftType: Type,
    viewResolver: &{ViewResolver},
    recipientIfNotCoa: EVM.EVMAddress?
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            // Wrap NFTs if underlying ERC721 address matches bridge's associated address for NFT type
            if underlyingAddress.equals(FlowEVMBridgeConfig.getEVMAddressAssociated(with: nftType)!) {
                // Approve contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, true]
                )

                // Wrap NFTs with provided IDs, and check if the call was successful
                let res = mustCall(coa, crossVMPointer.evmContractAddress,
                    functionSig: "depositFor(address,uint256[])",
                    args: [coa.address(), nftIDs]
                )
                let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                assert(decodedRes.length == 1, message: "Invalid response length")
                assert(decodedRes[0] as! Bool, message: "Failed to wrap NFTs")

                // Transfer NFTs to recipient if provided
                if let to = recipientIfNotCoa {
                    mustTransferNFTs(coa, crossVMPointer.evmContractAddress, nftIDs: nftIDs, to: to)
                }

                // Revoke approval for contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, false]
                )
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is owned by the provided EVM address
///
access(all) fun isOwner(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    _ nftID: UInt64,
    _ ownerToCheck: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: erc721Address,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )
    assert(res.status == EVM.Status.successful, message: "Call to ERC721.ownerOf(uint256) failed")
    let decodedRes = EVM.decodeABI(types: [Type<EVM.EVMAddress>()], data: res.data)
    if decodedRes.length == 1 {
        let actualOwner = decodedRes[0] as! EVM.EVMAddress
        return actualOwner.equals(ownerToCheck)
    }
    return false
}

/// Transfers NFTs from the provided COA to the provided EVM address
///
access(all) fun mustTransferNFTs(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    nftIDs: [UInt64],
    to: EVM.EVMAddress
) {
    for id in nftIDs {
        assert(isOwner(coa, erc721Address, id, coa.address()), message: "NFT not owned by signer's COA")
        mustCall(coa, erc721Address,
            functionSig: "safeTransferFrom(address,address,uint256)",
            args: [coa.address(), to, id]
        )
        assert(isOwner(coa, erc721Address, id, to), message: "NFT not transferred to recipient")
    }
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", - "batchBridgeChildNFTToEvmAddress": "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\u003d\u003d", - "batchSendChildNFT": "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\u003d", - "batchSendChildNFTToChild": "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\u003d\u003d", - "batchTransferChildNFT": "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", - "batchTransferNFTToChild": "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\u003d\u003d", - "bridgeChildFTFromEvm": "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\u003d", - "bridgeChildFTToEvm": "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\u003d\u003d", - "bridgeChildFTToEvmAddress": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYnJpZGdlQ2hpbGRGVFRvRXZtQWRkcmVzcyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IE1ldGFkYXRhVmlld3MgZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCmltcG9ydCBWaWV3UmVzb2x2ZXIgZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCmltcG9ydCBOb25GdW5naWJsZVRva2VuIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDdlNjBkZjA0MmE5YzA4NjgKCmltcG9ydCBGdW5naWJsZVRva2VuTWV0YWRhdGFWaWV3cyBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKCmltcG9ydCBTY29wZWRGVFByb3ZpZGVycyBmcm9tIDB4ZGZjMjBhZWU2NTBmY2JkZgoKCmltcG9ydCBFVk0gZnJvbSAweDhjNTMwM2VhYTI2MjAyZDYKCgppbXBvcnQgRmxvd0VWTUJyaWRnZVV0aWxzIGZyb20gMHhkZmMyMGFlZTY1MGZjYmRmCgppbXBvcnQgRmxvd0VWTUJyaWRnZSBmcm9tIDB4ZGZjMjBhZWU2NTBmY2JkZgoKaW1wb3J0IEZsb3dFVk1CcmlkZ2VDb25maWcgZnJvbSAweGRmYzIwYWVlNjUwZmNiZGYKCgppbXBvcnQgSHlicmlkQ3VzdG9keSBmcm9tIDB4Mjk0ZTQ0ZTFlYzY5OTNjNgoKaW1wb3J0IENhcGFiaWxpdHlGaWx0ZXIgZnJvbSAweDI5NGU0NGUxZWM2OTkzYzYKCgoKdHJhbnNhY3Rpb24odmF1bHRJZGVudGlmaWVyOiBTdHJpbmcsIGNoaWxkOiBBZGRyZXNzLCBhbW91bnQ6IFVGaXg2NCwgcmVjaXBpZW50OlN0cmluZykgewogICAgLy8gVGhlIFZhdWx0IHJlc291cmNlIHRoYXQgaG9sZHMgdGhlIHRva2VucyB0aGF0IGFyZSBiZWluZyB0cmFuc2ZlcnJlZAogICAgbGV0IHBheW1lbnRWYXVsdDogQHtGdW5naWJsZVRva2VuLlZhdWx0fQogICAgLy8gbGV0IGNvYTogYXV0aChFVk0uQnJpZGdlKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQKICAgIGxldCBzY29wZWRQcm92aWRlcjogQFNjb3BlZEZUUHJvdmlkZXJzLlNjb3BlZEZUUHJvdmlkZXIKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChTdG9yYWdlLCBDb3B5VmFsdWUsIEJvcnJvd1ZhbHVlLCBJc3N1ZVN0b3JhZ2VDYXBhYmlsaXR5Q29udHJvbGxlciwgUHVibGlzaENhcGFiaWxpdHksIFNhdmVWYWx1ZSkgJkFjY291bnQpIHsKCiAgICAgICAgLyogLS0tIFJlZmVyZW5jZSB0aGUgc2lnbmVyJ3MgQ2FkZW5jZU93bmVkQWNjb3VudCAtLS0gKi8KICAgICAgICAvLwogICAgICAgIC8vIEJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgc2lnbmVyJ3MgQ09BCiAgICAgICAgLy8gc2VsZi5jb2EgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChFVk0uQnJpZGdlKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KGZyb206IC9zdG9yYWdlL2V2bSkKICAgICAgICAvLyAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgQ09BIGZyb20gcHJvdmlkZWQgZ2F0ZXdheSBhZGRyZXNzIikKCiAgICAgICAgLyogLS0tIFJldHJpZXZlIHRoZSBmdW5kcyAtLS0gKi8KICAgICAgICAvLwogICAgICAgIC8vIEJvcnJvdyBhIHJlZmVyZW5jZSB0byB0aGUgRnVuZ2libGVUb2tlbiBWYXVsdAogICAgICAgIGxldCB2YXVsdFR5cGUgPSBDb21wb3NpdGVUeXBlKHZhdWx0SWRlbnRpZmllcikKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBjb25zdHJ1Y3QgVmF1bHQgdHlwZSBmcm9tIGlkZW50aWZpZXI6ICIuY29uY2F0KHZhdWx0SWRlbnRpZmllcikpCiAgICAgICAgLy8gUGFyc2UgdGhlIFZhdWx0IGlkZW50aWZpZXIgaW50byBpdHMgY29tcG9uZW50cwogICAgICAgIGxldCB0b2tlbkNvbnRyYWN0QWRkcmVzcyA9IEZsb3dFVk1CcmlkZ2VVdGlscy5nZXRDb250cmFjdEFkZHJlc3MoZnJvbVR5cGU6IHZhdWx0VHlwZSkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBnZXQgY29udHJhY3QgYWRkcmVzcyBmcm9tIGlkZW50aWZpZXI6ICIuY29uY2F0KHZhdWx0SWRlbnRpZmllcikpCiAgICAgICAgbGV0IHRva2VuQ29udHJhY3ROYW1lID0gRmxvd0VWTUJyaWRnZVV0aWxzLmdldENvbnRyYWN0TmFtZShmcm9tVHlwZTogdmF1bHRUeXBlKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGdldCBjb250cmFjdCBuYW1lIGZyb20gaWRlbnRpZmllcjogIi5jb25jYXQodmF1bHRJZGVudGlmaWVyKSkKCiAgICAgICAgbGV0IHZpZXdSZXNvbHZlciA9IGdldEFjY291bnQodG9rZW5Db250cmFjdEFkZHJlc3MpLmNvbnRyYWN0cy5ib3Jyb3c8JntWaWV3UmVzb2x2ZXJ9PihuYW1lOiB0b2tlbkNvbnRyYWN0TmFtZSkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgVmlld1Jlc29sdmVyIGZyb20gRnVuZ2libGVUb2tlbiBjb250cmFjdCIpCiAgICAgICAgbGV0IHZhdWx0RGF0YSA9IHZpZXdSZXNvbHZlci5yZXNvbHZlQ29udHJhY3RWaWV3KAogICAgICAgICAgICAgICAgcmVzb3VyY2VUeXBlOiBuaWwsCiAgICAgICAgICAgICAgICB2aWV3VHlwZTogVHlwZTxGdW5naWJsZVRva2VuTWV0YWRhdGFWaWV3cy5GVFZhdWx0RGF0YT4oKQogICAgICAgICAgICApIGFzISBGdW5naWJsZVRva2VuTWV0YWRhdGFWaWV3cy5GVFZhdWx0RGF0YT8gPz8gcGFuaWMoIkNvdWxkIG5vdCByZXNvbHZlIEZUVmF1bHREYXRhIHZpZXciKQogICAgICAgIGxldCB2YXVsdCA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5WYXVsdH0+KAogICAgICAgICAgICAgICAgZnJvbTogdmF1bHREYXRhLnN0b3JhZ2VQYXRoCiAgICAgICAgICAgICkgPz8gcGFuaWMoIkNvdWxkIG5vdCBhY2Nlc3Mgc2lnbmVyJ3MgRnVuZ2libGVUb2tlbiBWYXVsdCIpCgogICAgICAgIC8vIHNpZ25lciBpcyB0aGUgcGFyZW50IGFjY291bnQKICAgICAgICAvLyBnZXQgdGhlIG1hbmFnZXIgcmVzb3VyY2UgYW5kIGJvcnJvdyBjaGlsZEFjY291bnQKICAgICAgICBsZXQgbSA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEh5YnJpZEN1c3RvZHkuTWFuYWdlKSAmSHlicmlkQ3VzdG9keS5NYW5hZ2VyPihmcm9tOiBIeWJyaWRDdXN0b2R5Lk1hbmFnZXJTdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIm1hbmFnZXIgZG9lcyBub3QgZXhpc3QiKQogICAgICAgIGxldCBjaGlsZEFjY3QgPSBtLmJvcnJvd0FjY291bnQoYWRkcjogY2hpbGQpID8/IHBhbmljKCJjaGlsZCBhY2NvdW50IG5vdCBmb3VuZCIpCiAgICAgICAgCiAgICAgCiAgICAgICAgLy9nZXQgRnQgY2FwIGZyb20gY2hpbGQgYWNjb3VudAogICAgICAgIGxldCBjYXBUeXBlID0gVHlwZTxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+KCkKICAgICAgICBsZXQgY29udHJvbGxlcklEID0gY2hpbGRBY2N0LmdldENvbnRyb2xsZXJJREZvclR5cGUodHlwZTogY2FwVHlwZSwgZm9yUGF0aDogdmF1bHREYXRhLnN0b3JhZ2VQYXRoKQogICAgICAgICAgICA/PyBwYW5pYygibm8gY29udHJvbGxlciBmb3VuZCBmb3IgY2FwVHlwZSIpCiAgICAgICAgCiAgICAgICAgbGV0IGNhcCA9IGNoaWxkQWNjdC5nZXRDYXBhYmlsaXR5KGNvbnRyb2xsZXJJRDogY29udHJvbGxlcklELCB0eXBlOiBjYXBUeXBlKSA/PyBwYW5pYygibm8gY2FwIGZvdW5kIikKICAgICAgICBsZXQgcHJvdmlkZXJDYXAgPSBjYXAgYXMhIENhcGFiaWxpdHk8YXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAme0Z1bmdpYmxlVG9rZW4uUHJvdmlkZXJ9PgogICAgICAgIGFzc2VydChwcm92aWRlckNhcC5jaGVjaygpLCBtZXNzYWdlOiAiaW52YWxpZCBwcm92aWRlciBjYXBhYmlsaXR5IikKICAgICAgICAKICAgICAgICAvLyBHZXQgYSByZWZlcmVuY2UgdG8gdGhlIGNoaWxkJ3Mgc3RvcmVkIHZhdWx0CiAgICAgICAgbGV0IHZhdWx0UmVmID0gcHJvdmlkZXJDYXAuYm9ycm93KCkhCgogICAgICAgIC8vIFdpdGhkcmF3IHRva2VucyBmcm9tIHRoZSBzaWduZXIncyBzdG9yZWQgdmF1bHQKCiAgICAgICAgdmF1bHQuZGVwb3NpdChmcm9tOiA8LSB2YXVsdFJlZi53aXRoZHJhdyhhbW91bnQ6IGFtb3VudCkpCiAgICAgICAgICAgLy8gV2l0aGRyYXcgdGhlIHJlcXVlc3RlZCBiYWxhbmNlICYgY2FsY3VsYXRlIHRoZSBhcHByb3hpbWF0ZSBicmlkZ2UgZmVlIGJhc2VkIG9uIHN0b3JhZ2UgdXNhZ2UKICAgICAgICBsZXQgY3VycmVudFN0b3JhZ2VVc2FnZSA9IHNpZ25lci5zdG9yYWdlLnVzZWQKICAgICAgICBzZWxmLnBheW1lbnRWYXVsdCA8LSB2YXVsdC53aXRoZHJhdyhhbW91bnQ6IGFtb3VudCkKICAgICAgICBsZXQgd2l0aGRyYXduU3RvcmFnZVVzYWdlID0gc2lnbmVyLnN0b3JhZ2UudXNlZAogICAgICAgIC8vIEFwcHJveGltYXRlIHRoZSBicmlkZ2UgZmVlIGJhc2VkIG9uIHRoZSBkaWZmZXJlbmNlIGluIHN0b3JhZ2UgdXNhZ2Ugd2l0aCBzb21lIGJ1ZmZlcgogICAgICAgIGxldCBhcHByb3hGZWUgPSBGbG93RVZNQnJpZGdlVXRpbHMuY2FsY3VsYXRlQnJpZGdlRmVlKAogICAgICAgICAgICAgICAgYnl0ZXM6IDQwMF8wMDAKICAgICAgICAgICAgKQoKICAgICAgICAvKiAtLS0gQ29uZmlndXJlIGEgU2NvcGVkRlRQcm92aWRlciAtLS0gKi8KICAgICAgICAvLwogICAgICAgIC8vIElzc3VlIGFuZCBzdG9yZSBicmlkZ2UtZGVkaWNhdGVkIFByb3ZpZGVyIENhcGFiaWxpdHkgaW4gc3RvcmFnZSBpZiBuZWNlc3NhcnkKICAgICAgICBpZiBzaWduZXIuc3RvcmFnZS50eXBlKGF0OiBGbG93RVZNQnJpZGdlQ29uZmlnLnByb3ZpZGVyQ2FwYWJpbGl0eVN0b3JhZ2VQYXRoKSA9PSBuaWwgewogICAgICAgICAgICBsZXQgcHJvdmlkZXJDYXAgPSBzaWduZXIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8YXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAme0Z1bmdpYmxlVG9rZW4uUHJvdmlkZXJ9PigKICAgICAgICAgICAgICAgIC9zdG9yYWdlL2Zsb3dUb2tlblZhdWx0CiAgICAgICAgICAgICkKICAgICAgICAgICAgc2lnbmVyLnN0b3JhZ2Uuc2F2ZShwcm92aWRlckNhcCwgdG86IEZsb3dFVk1CcmlkZ2VDb25maWcucHJvdmlkZXJDYXBhYmlsaXR5U3RvcmFnZVBhdGgpCiAgICAgICAgfQogICAgICAgIC8vIENvcHkgdGhlIHN0b3JlZCBQcm92aWRlciBjYXBhYmlsaXR5IGFuZCBjcmVhdGUgYSBTY29wZWRGVFByb3ZpZGVyCiAgICAgICAgbGV0IHByb3ZpZGVyQ2FwQ29weSA9IHNpZ25lci5zdG9yYWdlLmNvcHk8Q2FwYWJpbGl0eTxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+PigKICAgICAgICAgICAgICAgIGZyb206IEZsb3dFVk1CcmlkZ2VDb25maWcucHJvdmlkZXJDYXBhYmlsaXR5U3RvcmFnZVBhdGgKICAgICAgICAgICAgKSA/PyBwYW5pYygiSW52YWxpZCBQcm92aWRlciBDYXBhYmlsaXR5IGZvdW5kIGluIHN0b3JhZ2UuIikKICAgICAgICBsZXQgcHJvdmlkZXJGaWx0ZXIgPSBTY29wZWRGVFByb3ZpZGVycy5BbGxvd2FuY2VGaWx0ZXIoYXBwcm94RmVlKQogICAgICAgIHNlbGYuc2NvcGVkUHJvdmlkZXIgPC0gU2NvcGVkRlRQcm92aWRlcnMuY3JlYXRlU2NvcGVkRlRQcm92aWRlcigKICAgICAgICAgICAgcHJvdmlkZXI6IHByb3ZpZGVyQ2FwQ29weSwKICAgICAgICAgICAgZmlsdGVyczogWyBwcm92aWRlckZpbHRlciBdLAogICAgICAgICAgICBleHBpcmF0aW9uOiBnZXRDdXJyZW50QmxvY2soKS50aW1lc3RhbXAgKyAxLjAKICAgICAgICApCgogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIGxldCByZWNpcGllbnRFVk1BZGRyZXNzID0gRVZNLmFkZHJlc3NGcm9tU3RyaW5nKHJlY2lwaWVudCkKICAgICAgICBGbG93RVZNQnJpZGdlLmJyaWRnZVRva2Vuc1RvRVZNKAogICAgICAgICAgICB2YXVsdDogPC1zZWxmLnBheW1lbnRWYXVsdCwKICAgICAgICAgICAgdG86IHJlY2lwaWVudEVWTUFkZHJlc3MsCiAgICAgICAgICAgIGZlZVByb3ZpZGVyOiAmc2VsZi5zY29wZWRQcm92aWRlciBhcyBhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0KICAgICAgICApCiAgICAgICAgLy8gRGVzdHJveSB0aGUgU2NvcGVkRlRQcm92aWRlcgogICAgICAgIGRlc3Ryb3kgc2VsZi5zY29wZWRQcm92aWRlcgogICAgfQp9CiA\u003d", - "bridgeChildNFTFromEvm": "// Flow Wallet - testnet Script  bridgeChildNFTFromEvm - v2.72
// <platform_info>

import MetadataViews from 0x631e88ae7f1d7c20

import ViewResolver from 0x631e88ae7f1d7c20

import NonFungibleToken from 0x631e88ae7f1d7c20

import FungibleToken from 0x9a0766d93b6608b7

import FlowToken from 0x7e60df042a9c0868

import FungibleTokenMetadataViews from 0x9a0766d93b6608b7

import ScopedFTProviders from 0xdfc20aee650fcbdf

import EVM from 0x8c5303eaa26202d6

import FlowEVMBridgeUtils from 0xdfc20aee650fcbdf

import FlowEVMBridge from 0xdfc20aee650fcbdf

import FlowEVMBridgeConfig from 0xdfc20aee650fcbdf

import HybridCustody from 0x294e44e1ec6993c6

import CapabilityFilter from 0x294e44e1ec6993c6

import CrossVMMetadataViews from 0x631e88ae7f1d7c20


transaction(nftIdentifier: String, child: Address, id: UInt256) {

    prepare(signer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        let coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        // Construct the NFT type from the provided identifier
        let nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        let m = signer.storage.borrow<auth(HybridCustody.Manage) &HybridCustody.Manager>(from: HybridCustody.ManagerStoragePath)
            ?? panic("manager does not exist")
        let childAcct = m.borrowAccount(addr: child) ?? panic("child account not found")

        /* --- Retrieve the NFT --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        let viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = viewResolver.resolveContractView(
                resourceType: nil,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")

        let capType = Type<&{NonFungibleToken.CollectionPublic}>()
        let controllerID = childAcct.getControllerIDForType(type: capType, forPath: collectionData.storagePath)
            ?? panic("no controller found for capType")

        let cap = childAcct.getCapability(controllerID: controllerID, type: capType) ?? panic("no cap found")
        let publicCap = cap as! Capability<&{NonFungibleToken.CollectionPublic}>
        assert(publicCap.check(), message: "invalid public capability")

        // Get a reference to the child's stored vault
        let collectionRef = publicCap.borrow()!

        // Calculate the approximate fee for the bridge
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(bytes: 400_000)

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        let scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )

        // Unwrap NFTs if applicable
        unwrapNFTsIfApplicable(coa as auth(EVM.Call) &EVM.CadenceOwnedAccount, nftIDs: [id], nftType: nftType, viewResolver: viewResolver)

        let nft: @{NonFungibleToken.NFT} <- coa.withdrawNFT(
            type: nftType,
            id: id,
            feeProvider: &scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )

        assert(
            nft.getType() == nftType,
            message: "Bridged nft type mismatch - requeswted: ".concat(nftType.identifier)
                .concat(", received: ").concat(nft.getType().identifier)
        )

        collectionRef.deposit(token: <- nft)
        // Destroy the ScopedFTProvider
        destroy scopedProvider
    }
}

/// Unwraps NFTs from a project's custom ERC721 wrapper contract to bridged NFTs on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
///
access(all) fun unwrapNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt256],
    nftType: Type,
    viewResolver: &{ViewResolver}
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            for id in nftIDs {
                // Unwrap NFT if it is wrapped
                if isNFTWrapped(coa,
                    nftID: id,
                    underlying: underlyingAddress,
                    wrapper: crossVMPointer.evmContractAddress
                ) {
                    let res = mustCall(coa, crossVMPointer.evmContractAddress,
                        functionSig: "withdrawTo(address,uint256[])",
                        args: [coa.address(), [id]]
                    )
                    let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                    assert(decodedRes.length == 1, message: "Invalid response length")
                    assert(decodedRes[0] as! Bool, message: "Failed to unwrap NFT")
                }
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is wrapped in the underlying ERC721 contract
///
access(all) fun isNFTWrapped(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftID: UInt256,
    underlying: EVM.EVMAddress,
    wrapper: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: underlying,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return false
    if res.status != EVM.Status.successful || res.data.length == 0{
        return false
    }

    // Decode and compare the addresses
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    let owner = decodedResult[0] as! EVM.EVMAddress
    return owner.toString() == wrapper.toString()
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", - "bridgeChildNFTToEvm": "// Flow Wallet - testnet Script  bridgeChildNFTToEvm - v2.72
// <platform_info>

import MetadataViews from 0x631e88ae7f1d7c20

import ViewResolver from 0x631e88ae7f1d7c20

import NonFungibleToken from 0x631e88ae7f1d7c20

import FungibleToken from 0x9a0766d93b6608b7

import FlowToken from 0x7e60df042a9c0868

import FungibleTokenMetadataViews from 0x9a0766d93b6608b7

import ScopedFTProviders from 0xdfc20aee650fcbdf

import EVM from 0x8c5303eaa26202d6

import FlowEVMBridgeUtils from 0xdfc20aee650fcbdf

import FlowEVMBridge from 0xdfc20aee650fcbdf

import FlowEVMBridgeConfig from 0xdfc20aee650fcbdf

import HybridCustody from 0x294e44e1ec6993c6

import CapabilityFilter from 0x294e44e1ec6993c6

import CrossVMMetadataViews from 0x631e88ae7f1d7c20


transaction(nftIdentifier: String, id: UInt64, child: Address) {

    let nft: @{NonFungibleToken.NFT}
    let coa: auth(EVM.Bridge, EVM.Call) &EVM.CadenceOwnedAccount
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let nftType: Type
    let viewResolver: &{ViewResolver}
    prepare(signer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, Capabilities, SaveValue) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        let m = signer.storage.borrow<auth(HybridCustody.Manage) &HybridCustody.Manager>(from: HybridCustody.ManagerStoragePath)
            ?? panic("manager does not exist")
        let childAcct = m.borrowAccount(addr: child) ?? panic("child account not found")

         // Construct the NFT type from the provided identifier
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: self.nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Retrieve the NFT --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: nil,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        var collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            )

        // Create collection if it doesn't exist
        if collection == nil {
            signer.storage.save(<- collectionData.createEmptyCollection(), to: collectionData.storagePath)
            signer.capabilities.unpublish(collectionData.publicPath)
            signer.capabilities.publish(
                signer.capabilities.storage.issue<&{NonFungibleToken.Collection}>(collectionData.storagePath),
                at: collectionData.publicPath
            )

            // Borrow authorized withdraw reference to the signer's collection
            collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            )!
        }

        let capType = Type<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider}>()
        let controllerID = childAcct.getControllerIDForType(type: capType, forPath: collectionData.storagePath)
            ?? panic("no controller found for capType")

        let cap = childAcct.getCapability(controllerID: controllerID, type: capType) ?? panic("no cap found")
        let providerCap = cap as! Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider}>
        assert(providerCap.check(), message: "invalid provider capability")

        // Get a reference to the child's stored vault
        let collectionRef = providerCap.borrow()!
        let childNft <- collectionRef.withdraw(withdrawID: id)
        collection!.deposit(token: <-childNft)
        // // Withdraw tokens from the signer's stored vault
        let currentStorageUsage = signer.storage.used
        self.nft <- collection!.withdraw(withdrawID: id)
        let withdrawnStorageUsage = signer.storage.used
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(
                bytes: 400_000
            )

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    execute {
        // Execute the bridge
        self.coa.depositNFT(
            nft: <-self.nft,
            feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        // Destroy the ScopedFTProvider
        destroy self.scopedProvider

        // Wrap NFTs if applicable
        wrapAndTransferNFTsIfApplicable(
            self.coa,
            nftIDs: [id],
            nftType: self.nftType,
            viewResolver: self.viewResolver,
            recipientIfNotCoa: nil
        )
    }
}

/// Wraps and transfers bridged NFTs into a project's custom ERC721 wrapper contract on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
/// @param recipientIfNotCoa: The EVM address to transfer the wrapped NFTs to, nil if the NFTs should stay in signer's COA
///
access(all) fun wrapAndTransferNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt64],
    nftType: Type,
    viewResolver: &{ViewResolver},
    recipientIfNotCoa: EVM.EVMAddress?
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            // Wrap NFTs if underlying ERC721 address matches bridge's associated address for NFT type
            if underlyingAddress.equals(FlowEVMBridgeConfig.getEVMAddressAssociated(with: nftType)!) {
                // Approve contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, true]
                )

                // Wrap NFTs with provided IDs, and check if the call was successful
                let res = mustCall(coa, crossVMPointer.evmContractAddress,
                    functionSig: "depositFor(address,uint256[])",
                    args: [coa.address(), nftIDs]
                )
                let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                assert(decodedRes.length == 1, message: "Invalid response length")
                assert(decodedRes[0] as! Bool, message: "Failed to wrap NFTs")

                // Transfer NFTs to recipient if provided
                if let to = recipientIfNotCoa {
                    mustTransferNFTs(coa, crossVMPointer.evmContractAddress, nftIDs: nftIDs, to: to)
                }

                // Revoke approval for contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, false]
                )
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is owned by the provided EVM address
///
access(all) fun isOwner(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    _ nftID: UInt64,
    _ ownerToCheck: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: erc721Address,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )
    assert(res.status == EVM.Status.successful, message: "Call to ERC721.ownerOf(uint256) failed")
    let decodedRes = EVM.decodeABI(types: [Type<EVM.EVMAddress>()], data: res.data)
    if decodedRes.length == 1 {
        let actualOwner = decodedRes[0] as! EVM.EVMAddress
        return actualOwner.equals(ownerToCheck)
    }
    return false
}

/// Transfers NFTs from the provided COA to the provided EVM address
///
access(all) fun mustTransferNFTs(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    nftIDs: [UInt64],
    to: EVM.EVMAddress
) {
    for id in nftIDs {
        assert(isOwner(coa, erc721Address, id, coa.address()), message: "NFT not owned by signer's COA")
        mustCall(coa, erc721Address,
            functionSig: "safeTransferFrom(address,address,uint256)",
            args: [coa.address(), to, id]
        )
        assert(isOwner(coa, erc721Address, id, to), message: "NFT not transferred to recipient")
    }
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", - "bridgeChildNFTToEvmAddress": "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\u003d\u003d", - "checkChildLinkedCollections": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY2hlY2tDaGlsZExpbmtlZENvbGxlY3Rpb25zIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgSHlicmlkQ3VzdG9keSBmcm9tIDB4Mjk0ZTQ0ZTFlYzY5OTNjNgoKaW1wb3J0IENhcGFiaWxpdHlGaWx0ZXIgZnJvbSAweDI5NGU0NGUxZWM2OTkzYzYKCmltcG9ydCBOb25GdW5naWJsZVRva2VuIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgoKYWNjZXNzKGFsbCkgZnVuIG1haW4ocGFyZW50OiBBZGRyZXNzLCBjaGlsZDogQWRkcmVzcywgaWRlbnRpZmllcjogU3RyaW5nKTogQm9vbCB7CiAgICBsZXQgbWdyID0gZ2V0QXV0aEFjY291bnQocGFyZW50KS5ib3Jyb3c8Jkh5YnJpZEN1c3RvZHkuTWFuYWdlcj4oZnJvbTogSHlicmlkQ3VzdG9keS5NYW5hZ2VyU3RvcmFnZVBhdGgpCiAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgbWFuYWdlciBmcm9tIHBhcmVudCIpCiAgICBsZXQgY2hpbGQgPSBtZ3IuYm9ycm93QWNjb3VudChhZGRyOiBjaGlsZCkgPz8gcGFuaWMoIkNoaWxkIGFjY291bnQgbm90IGZvdW5kIikKCiAgICBsZXQgY2FwID0gY2hpbGQuZ2V0Q2FwYWJpbGl0eSgKICAgICAgICAgICAgcGF0aDogUHJpdmF0ZVBhdGgoaWRlbnRpZmllcjogaWRlbnRpZmllcikhIGFzIENhcGFiaWxpdHlQYXRoLAogICAgICAgICAgICB0eXBlOiBUeXBlPCZ7Tm9uRnVuZ2libGVUb2tlbi5Qcm92aWRlciwgTm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9uUHVibGljfT4oKQogICAgICAgICkgYXMhIENhcGFiaWxpdHk8JntOb25GdW5naWJsZVRva2VuLlByb3ZpZGVyLCBOb25GdW5naWJsZVRva2VuLkNvbGxlY3Rpb25QdWJsaWN9Pj8KCiAgICAKICAgIHJldHVybiBjYXAgIT0gbmlsCn0gICAKICAgIA\u003d\u003d", - "checkChildLinkedVaults": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY2hlY2tDaGlsZExpbmtlZFZhdWx0cyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEh5YnJpZEN1c3RvZHkgZnJvbSAweDI5NGU0NGUxZWM2OTkzYzYKCmltcG9ydCBDYXBhYmlsaXR5RmlsdGVyIGZyb20gMHgyOTRlNDRlMWVjNjk5M2M2CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKHBhcmVudDogQWRkcmVzcywgY2hpbGQ6IEFkZHJlc3MsIHBhdGg6IFN0cmluZyk6IEJvb2wgewogIGxldCBhY2NvdW50ID0gZ2V0QXV0aEFjY291bnQ8YXV0aChTdG9yYWdlKSAmQWNjb3VudD4ocGFyZW50KQogIGxldCBtYW5hZ2VyID0gZ2V0QXV0aEFjY291bnQ8YXV0aChTdG9yYWdlKSAmQWNjb3VudD4ocGFyZW50KS5zdG9yYWdlLmJvcnJvdzxhdXRoKEh5YnJpZEN1c3RvZHkuTWFuYWdlKSAmSHlicmlkQ3VzdG9keS5NYW5hZ2VyPihmcm9tOiBIeWJyaWRDdXN0b2R5Lk1hbmFnZXJTdG9yYWdlUGF0aCkgPz8gcGFuaWMgKCJtYW5hZ2VyIGRvZXMgbm90IGV4aXN0IikKICAKICBsZXQgcHJvdmlkZXJUeXBlID0gVHlwZTxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+KCkKCiAgbGV0IGFkZHIgPSBnZXRBdXRoQWNjb3VudDxhdXRoKFN0b3JhZ2UsIENhcGFiaWxpdGllcykgJkFjY291bnQ+KGNoaWxkKQogIAogIGxldCBjaGlsZEFjY3QgPSBtYW5hZ2VyLmJvcnJvd0FjY291bnQoYWRkcjogY2hpbGQpID8/IHBhbmljKCJjaGlsZCBhY2NvdW50IG5vdCBmb3VuZCIpCgogIGxldCBjb250cm9sbGVycyA9IGFkZHIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuZ2V0Q29udHJvbGxlcnMoZm9yUGF0aDogU3RvcmFnZVBhdGgoaWRlbnRpZmllcjogcGF0aCkhKQogIHZhciBmbGFnID0gZmFsc2UKCiAgZm9yIGMgaW4gY29udHJvbGxlcnMgewogICAgaWYgIWMuYm9ycm93VHlwZS5pc1N1YnR5cGUob2Y6IHByb3ZpZGVyVHlwZSkgewogICAgICBjb250aW51ZQogICAgfQoKICAgIGlmIGxldCBjYXAgPSBjaGlsZEFjY3QuZ2V0Q2FwYWJpbGl0eShjb250cm9sbGVySUQ6IGMuY2FwYWJpbGl0eUlELCB0eXBlOiBwcm92aWRlclR5cGUpIHsKICAgICAgbGV0IHByb3ZpZGVyQ2FwID0gY2FwIGFzISBDYXBhYmlsaXR5PCZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+IAoKICAgICAgaWYgIXByb3ZpZGVyQ2FwLmNoZWNrKCl7CiAgICAgICAgY29udGludWUKICAgICAgfQoKICAgICAgZmxhZyA9IHRydWUKICAgICAgYnJlYWsKICAgIH0KICB9CgogIHJldHVybiBmbGFnCn0gCiAgICA\u003d", - "checkChildRecieveVaults": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY2hlY2tDaGlsZFJlY2lldmVWYXVsdHMgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBIeWJyaWRDdXN0b2R5IGZyb20gMHgyOTRlNDRlMWVjNjk5M2M2CgppbXBvcnQgQ2FwYWJpbGl0eUZpbHRlciBmcm9tIDB4Mjk0ZTQ0ZTFlYzY5OTNjNgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihwYXJlbnQ6IEFkZHJlc3MsIGNoaWxkOiBBZGRyZXNzLCBwYXRoOiBTdHJpbmcpOiBCb29sIHsKICBsZXQgYWNjb3VudCA9IGdldEF1dGhBY2NvdW50PGF1dGgoU3RvcmFnZSkgJkFjY291bnQ+KHBhcmVudCkKICBsZXQgbWFuYWdlciA9IGdldEF1dGhBY2NvdW50PGF1dGgoU3RvcmFnZSkgJkFjY291bnQ+KHBhcmVudCkuc3RvcmFnZS5ib3Jyb3c8YXV0aChIeWJyaWRDdXN0b2R5Lk1hbmFnZSkgJkh5YnJpZEN1c3RvZHkuTWFuYWdlcj4oZnJvbTogSHlicmlkQ3VzdG9keS5NYW5hZ2VyU3RvcmFnZVBhdGgpID8/IHBhbmljICgibWFuYWdlciBkb2VzIG5vdCBleGlzdCIpCiAgCiAgbGV0IHJlY2VpdmVyVHlwZSA9IFR5cGU8JntGdW5naWJsZVRva2VuLlJlY2VpdmVyfT4oKQoKICBsZXQgYWRkciA9IGdldEF1dGhBY2NvdW50PGF1dGgoU3RvcmFnZSwgQ2FwYWJpbGl0aWVzKSAmQWNjb3VudD4oY2hpbGQpCiAgCiAgbGV0IGNoaWxkQWNjdCA9IG1hbmFnZXIuYm9ycm93QWNjb3VudChhZGRyOiBjaGlsZCkgPz8gcGFuaWMoImNoaWxkIGFjY291bnQgbm90IGZvdW5kIikKCiAgbGV0IGNvbnRyb2xsZXJzID0gYWRkci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5nZXRDb250cm9sbGVycyhmb3JQYXRoOiBTdG9yYWdlUGF0aChpZGVudGlmaWVyOiBwYXRoKSEpCiAgdmFyIGZsYWcgPSBmYWxzZQoKICBmb3IgYyBpbiBjb250cm9sbGVycyB7CiAgICBpZiAhYy5ib3Jyb3dUeXBlLmlzU3VidHlwZShvZjogcmVjZWl2ZXJUeXBlKSB7CiAgICAgIGNvbnRpbnVlCiAgICB9CgogICAgaWYgbGV0IGNhcCA9IGNoaWxkQWNjdC5nZXRDYXBhYmlsaXR5KGNvbnRyb2xsZXJJRDogYy5jYXBhYmlsaXR5SUQsIHR5cGU6IHJlY2VpdmVyVHlwZSkgewogICAgICBsZXQgcHJvdmlkZXJDYXAgPSBjYXAgYXMhIENhcGFiaWxpdHk8JntGdW5naWJsZVRva2VuLlJlY2VpdmVyfT4gCgogICAgICBpZiAhcHJvdmlkZXJDYXAuY2hlY2soKXsKICAgICAgICBjb250aW51ZQogICAgICB9CgogICAgICBmbGFnID0gdHJ1ZQogICAgICBicmVhawogICAgfQogIH0KCiAgcmV0dXJuIGZsYWcKfSAKICAgIA\u003d\u003d", - "editChildAccount": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZWRpdENoaWxkQWNjb3VudCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEh5YnJpZEN1c3RvZHkgZnJvbSAweDI5NGU0NGUxZWM2OTkzYzYKCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgoKdHJhbnNhY3Rpb24oY2hpbGRBZGRyZXNzOiBBZGRyZXNzLCBuYW1lOiBTdHJpbmcsIGRlc2NyaXB0aW9uOiBTdHJpbmcsIHRodW1ibmFpbDogU3RyaW5nKSB7CiAgICBwcmVwYXJlKGFjY3Q6IEF1dGhBY2NvdW50KSB7CiAgICAgICAgbGV0IG0gPSBhY2N0LmJvcnJvdzwmSHlicmlkQ3VzdG9keS5NYW5hZ2VyPihmcm9tOiBIeWJyaWRDdXN0b2R5Lk1hbmFnZXJTdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIm1hbmFnZXIgbm90IGZvdW5kIikKICAgICAgICAKICAgICAgICBsZXQgZCA9IE1ldGFkYXRhVmlld3MuRGlzcGxheSgKICAgICAgICAgICAgbmFtZTogbmFtZSwKICAgICAgICAgICAgZGVzY3JpcHRpb246IGRlc2NyaXB0aW9uLAogICAgICAgICAgICB0aHVtYm5haWw6IE1ldGFkYXRhVmlld3MuSFRUUEZpbGUodXJsOiB0aHVtYm5haWwpCiAgICAgICAgKQoKICAgICAgICBtLnNldENoaWxkQWNjb3VudERpc3BsYXkoYWRkcmVzczogY2hpbGRBZGRyZXNzLCBkKQogICAgfQp9", - "getAccessibleChildAccountNFTs": "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\u003d", - "getAccessibleCoinInfo": "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", - "getAccessibleCollectionAndIdsDisplay": "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\u003d\u003d", - "getChildAccountAllowTypes": "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\u003d\u003d", - "getChildAccountFTCapabilities": "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\u003d\u003d", - "getChildAccountMeta": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0Q2hpbGRBY2NvdW50TWV0YSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEh5YnJpZEN1c3RvZHkgZnJvbSAweDI5NGU0NGUxZWM2OTkzYzYKCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgoKYWNjZXNzKGFsbCkgZnVuIG1haW4ocGFyZW50OiBBZGRyZXNzKToge0FkZHJlc3M6IEFueVN0cnVjdH0gewogICAgbGV0IGFjY3QgPSBnZXRBdXRoQWNjb3VudDxhdXRoKFN0b3JhZ2UpICZBY2NvdW50PihwYXJlbnQpCiAgICBsZXQgbSA9IGFjY3Quc3RvcmFnZS5ib3Jyb3c8Jkh5YnJpZEN1c3RvZHkuTWFuYWdlcj4oZnJvbTogSHlicmlkQ3VzdG9keS5NYW5hZ2VyU3RvcmFnZVBhdGgpCgogICAgaWYgbSA9PSBuaWwgewogICAgICAgIHJldHVybiB7fQogICAgfSBlbHNlIHsKICAgICAgICB2YXIgZGF0YToge0FkZHJlc3M6IEFueVN0cnVjdH0gPSB7fQogICAgICAgIGZvciBhZGRyZXNzIGluIG0/LmdldENoaWxkQWRkcmVzc2VzKCkhIHsKICAgICAgICAgICAgbGV0IGMgPSBtPy5nZXRDaGlsZEFjY291bnREaXNwbGF5KGFkZHJlc3M6IGFkZHJlc3MpIAogICAgICAgICAgICBkYXRhLmluc2VydChrZXk6IGFkZHJlc3MsIGMpCiAgICAgICAgfQogICAgICAgIHJldHVybiBkYXRhCiAgICB9Cn0\u003d", - "getChildAddresses": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0Q2hpbGRBZGRyZXNzZXMgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBIeWJyaWRDdXN0b2R5IGZyb20gMHgyOTRlNDRlMWVjNjk5M2M2CgoKYWNjZXNzKGFsbCkgZnVuIG1haW4ocGFyZW50OiBBZGRyZXNzKTogW0FkZHJlc3NdIHsKICAgIGxldCBhY2N0ID0gZ2V0QXV0aEFjY291bnQ8YXV0aChTdG9yYWdlKSAmQWNjb3VudD4ocGFyZW50KQogICAgbGV0IG1hbmFnZXIgPSBhY2N0LnN0b3JhZ2UuYm9ycm93PCZIeWJyaWRDdXN0b2R5Lk1hbmFnZXI+KGZyb206IEh5YnJpZEN1c3RvZHkuTWFuYWdlclN0b3JhZ2VQYXRoKQogICAgICAgID8/IHBhbmljKCJtYW5hZ2VyIG5vdCBmb3VuZCIpCiAgICByZXR1cm4gIG1hbmFnZXIuZ2V0Q2hpbGRBZGRyZXNzZXMoKQp9", - "getExamplenftCollectionFromDelegator": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0RXhhbXBsZW5mdENvbGxlY3Rpb25Gcm9tRGVsZWdhdG9yIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgSHlicmlkQ3VzdG9keSBmcm9tIDB4Mjk0ZTQ0ZTFlYzY5OTNjNgoKCmltcG9ydCBOb25GdW5naWJsZVRva2VuIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgppbXBvcnQgPFRva2VuPiBmcm9tIDxUb2tlbkFkZHJlc3M+CgphY2Nlc3MoYWxsKSBmdW4gbWFpbihwYXJlbnQ6IEFkZHJlc3MsIGNoaWxkOiBBZGRyZXNzLCBpc1B1YmxpYzogQm9vbCkgewogICAgbGV0IG0gPSBnZXRBdXRoQWNjb3VudDxhdXRoKFN0b3JhZ2UpICZBY2NvdW50PihwYXJlbnQpLnN0b3JhZ2UuYm9ycm93PGF1dGgoSHlicmlkQ3VzdG9keS5NYW5hZ2UpICZIeWJyaWRDdXN0b2R5Lk1hbmFnZXI+KGZyb206IEh5YnJpZEN1c3RvZHkuTWFuYWdlclN0b3JhZ2VQYXRoKQogICAgICAgID8/IHBhbmljKCJtYW5hZ2VyIG5vdCBmb3VuZCIpCiAgICBsZXQgYWNjdCA9IG0uYm9ycm93QWNjb3VudChhZGRyOiBjaGlsZCkKICAgICAgICA/PyBwYW5pYygiY2hpbGQgYWNjb3VudCBub3QgZm91bmQgaW4gbWFuYWdlciIpCgogICAgbGV0IHQgPSBUeXBlPENhcGFiaWxpdHk8JkV4YW1wbGVORlQuQ29sbGVjdGlvbj4+KCkKCiAgICBsZXQgY2FwID0gKGlzUHVibGljID8gYWNjdC5nZXRQdWJsaWNDYXBGcm9tRGVsZWdhdG9yKHR5cGU6IHQpIDogYWNjdC5nZXRQcml2YXRlQ2FwRnJvbURlbGVnYXRvcih0eXBlOiB0KSkKICAgICAgICA/PyBwYW5pYygiY2FwYWJpbGl0eSBub3QgZm91bmQiKQogICAgCiAgICBhc3NlcnQoY2FwLmdldFR5cGUoKSA9PSB0LCBtZXNzYWdlOiAibWlzbWF0Y2hlZCBjYXBhYmlsaXR5IHR5cGVzIikKfQ\u003d\u003d", - "publishToParent": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcHVibGlzaFRvUGFyZW50IC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgojYWxsb3dBY2NvdW50TGlua2luZwoKaW1wb3J0IEh5YnJpZEN1c3RvZHkgZnJvbSAweDI5NGU0NGUxZWM2OTkzYzYKCmltcG9ydCBDYXBhYmlsaXR5RmFjdG9yeSBmcm9tIDB4Mjk0ZTQ0ZTFlYzY5OTNjNgoKaW1wb3J0IENhcGFiaWxpdHlGaWx0ZXIgZnJvbSAweDI5NGU0NGUxZWM2OTkzYzYKCmltcG9ydCBDYXBhYmlsaXR5RGVsZWdhdG9yIGZyb20gMHgyOTRlNDRlMWVjNjk5M2M2CgoKdHJhbnNhY3Rpb24ocGFyZW50OiBBZGRyZXNzLCBmYWN0b3J5QWRkcmVzczogQWRkcmVzcywgZmlsdGVyQWRkcmVzczogQWRkcmVzcykgewogICAgcHJlcGFyZShhY2N0OiBhdXRoKFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IG93bmVkID0gYWNjdC5zdG9yYWdlLmJvcnJvdzxhdXRoKEh5YnJpZEN1c3RvZHkuT3duZXIpICZIeWJyaWRDdXN0b2R5Lk93bmVkQWNjb3VudD4oZnJvbTogSHlicmlkQ3VzdG9keS5Pd25lZEFjY291bnRTdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIm93bmVkIGFjY291bnQgbm90IGZvdW5kIikKCiAgICAgICAgbGV0IGZhY3RvcnkgPSBnZXRBY2NvdW50KGZhY3RvcnlBZGRyZXNzKS5jYXBhYmlsaXRpZXMuZ2V0PCZDYXBhYmlsaXR5RmFjdG9yeS5NYW5hZ2VyPihDYXBhYmlsaXR5RmFjdG9yeS5QdWJsaWNQYXRoKQogICAgICAgIGFzc2VydChmYWN0b3J5LmNoZWNrKCksIG1lc3NhZ2U6ICJmYWN0b3J5IGFkZHJlc3MgaXMgbm90IGNvbmZpZ3VyZWQgcHJvcGVybHkiKQoKICAgICAgICBsZXQgZmlsdGVyID0gZ2V0QWNjb3VudChmaWx0ZXJBZGRyZXNzKS5jYXBhYmlsaXRpZXMuZ2V0PCZ7Q2FwYWJpbGl0eUZpbHRlci5GaWx0ZXJ9PihDYXBhYmlsaXR5RmlsdGVyLlB1YmxpY1BhdGgpCiAgICAgICAgYXNzZXJ0KGZpbHRlci5jaGVjaygpLCBtZXNzYWdlOiAiY2FwYWJpbGl0eSBmaWx0ZXIgaXMgbm90IGNvbmZpZ3VyZWQgcHJvcGVybHkiKQoKICAgICAgICBvd25lZC5wdWJsaXNoVG9QYXJlbnQocGFyZW50QWRkcmVzczogcGFyZW50LCBmYWN0b3J5OiBmYWN0b3J5LCBmaWx0ZXI6IGZpbHRlcikKICAgIH0KfQ\u003d\u003d", - "redeemAccount": "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\u003d\u003d", - "sendChildFT": "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\u003d", - "sendChildFTToChild": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgc2VuZENoaWxkRlRUb0NoaWxkIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgSHlicmlkQ3VzdG9keSBmcm9tIDB4Mjk0ZTQ0ZTFlYzY5OTNjNgoKCi8vIEhDLW93bmVkIGltcG9ydHMKaW1wb3J0IENhcGFiaWxpdHlGYWN0b3J5IGZyb20gMHgyOTRlNDRlMWVjNjk5M2M2CgppbXBvcnQgQ2FwYWJpbGl0eUZpbHRlciBmcm9tIDB4Mjk0ZTQ0ZTFlYzY5OTNjNgoKCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgppbXBvcnQgPFRva2VuPiBmcm9tIDxUb2tlbkFkZHJlc3M+CgoKdHJhbnNhY3Rpb24oYWRkcmVzczogQWRkcmVzcywgcmVjZWl2ZXI6IEFkZHJlc3MsIHBhdGg6IFN0cmluZywgYW1vdW50OiBVRml4NjQgKSB7CgogIC8vIFRoZSBWYXVsdCByZXNvdXJjZSB0aGF0IGhvbGRzIHRoZSB0b2tlbnMgdGhhdCBhcmUgYmVpbmcgdHJhbnNmZXJyZWQKICBsZXQgcGF5bWVudFZhdWx0OiBAe0Z1bmdpYmxlVG9rZW4uVmF1bHR9CiAgbGV0IHZhdWx0RGF0YTogRnVuZ2libGVUb2tlbk1ldGFkYXRhVmlld3MuRlRWYXVsdERhdGEKCiAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSkgJkFjY291bnQpIHsKICAgICAgLy8gc2lnbmVyIGlzIHRoZSBwYXJlbnQgYWNjb3VudAogICAgICAvLyBnZXQgdGhlIG1hbmFnZXIgcmVzb3VyY2UgYW5kIGJvcnJvdyBjaGlsZEFjY291bnQKICAgICAgbGV0IG0gPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChIeWJyaWRDdXN0b2R5Lk1hbmFnZSkgJkh5YnJpZEN1c3RvZHkuTWFuYWdlcj4oZnJvbTogSHlicmlkQ3VzdG9keS5NYW5hZ2VyU3RvcmFnZVBhdGgpCiAgICAgICAgICA/PyBwYW5pYygibWFuYWdlciBkb2VzIG5vdCBleGlzdCIpCiAgICAgIGxldCBjaGlsZEFjY3QgPSBtLmJvcnJvd0FjY291bnQoYWRkcjogYWRkcmVzcykgPz8gcGFuaWMoImNoaWxkIGFjY291bnQgbm90IGZvdW5kIikKICAgICAgCiAgICAgIHNlbGYudmF1bHREYXRhID0gPFRva2VuPi5yZXNvbHZlQ29udHJhY3RWaWV3KHJlc291cmNlVHlwZTogbmlsLCB2aWV3VHlwZTogVHlwZTxGdW5naWJsZVRva2VuTWV0YWRhdGFWaWV3cy5GVFZhdWx0RGF0YT4oKSkgYXMhIEZ1bmdpYmxlVG9rZW5NZXRhZGF0YVZpZXdzLkZUVmF1bHREYXRhPwogICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBnZXQgdGhlIHZhdWx0IGRhdGEgdmlldyBmb3IgPFRva2VuPiAiKQoKICAgICAgLy9nZXQgRnQgY2FwIGZyb20gY2hpbGQgYWNjb3VudAogICAgICBsZXQgY2FwVHlwZSA9IFR5cGU8YXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAme0Z1bmdpYmxlVG9rZW4uUHJvdmlkZXJ9PigpCiAgICAgIGxldCBjb250cm9sbGVySUQgPSBjaGlsZEFjY3QuZ2V0Q29udHJvbGxlcklERm9yVHlwZSh0eXBlOiBjYXBUeXBlLCBmb3JQYXRoOiBzZWxmLnZhdWx0RGF0YS5zdG9yYWdlUGF0aCkKICAgICAgICAgID8/IHBhbmljKCJubyBjb250cm9sbGVyIGZvdW5kIGZvciBjYXBUeXBlIikKICAgICAgCiAgICAgIGxldCBjYXAgPSBjaGlsZEFjY3QuZ2V0Q2FwYWJpbGl0eShjb250cm9sbGVySUQ6IGNvbnRyb2xsZXJJRCwgdHlwZTogY2FwVHlwZSkgPz8gcGFuaWMoIm5vIGNhcCBmb3VuZCIpCiAgICAgIGxldCBwcm92aWRlckNhcCA9IGNhcCBhcyEgQ2FwYWJpbGl0eTxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+CiAgICAgIGFzc2VydChwcm92aWRlckNhcC5jaGVjaygpLCBtZXNzYWdlOiAiaW52YWxpZCBwcm92aWRlciBjYXBhYmlsaXR5IikKICAgICAgCiAgICAgIC8vIEdldCBhIHJlZmVyZW5jZSB0byB0aGUgY2hpbGQncyBzdG9yZWQgdmF1bHQKICAgICAgbGV0IHZhdWx0UmVmID0gcHJvdmlkZXJDYXAuYm9ycm93KCkhCgogICAgICAvLyBXaXRoZHJhdyB0b2tlbnMgZnJvbSB0aGUgc2lnbmVyJ3Mgc3RvcmVkIHZhdWx0CiAgICAgIHNlbGYucGF5bWVudFZhdWx0IDwtIHZhdWx0UmVmLndpdGhkcmF3KGFtb3VudDogYW1vdW50KQogIH0KCiAgZXhlY3V0ZSB7CgogICAgICAvLyBHZXQgdGhlIHJlY2lwaWVudCdzIHB1YmxpYyBhY2NvdW50IG9iamVjdAogICAgICBsZXQgcmVjaXBpZW50ID0gZ2V0QWNjb3VudChyZWNlaXZlcikKCiAgICAgIC8vIEdldCBhIHJlZmVyZW5jZSB0byB0aGUgcmVjaXBpZW50J3MgUmVjZWl2ZXIKICAgICAgbGV0IHJlY2VpdmVyUmVmID0gcmVjaXBpZW50LmNhcGFiaWxpdGllcy5nZXQ8JntGdW5naWJsZVRva2VuLlJlY2VpdmVyfT4oc2VsZi52YXVsdERhdGEucmVjZWl2ZXJQYXRoKSEuYm9ycm93KCkKICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IHJlY2VpdmVyIHJlZmVyZW5jZSB0byB0aGUgcmVjaXBpZW50J3MgVmF1bHQiKQoKICAgICAgLy8gRGVwb3NpdCB0aGUgd2l0aGRyYXduIHRva2VucyBpbiB0aGUgcmVjaXBpZW50J3MgcmVjZWl2ZXIKICAgICAgcmVjZWl2ZXJSZWYuZGVwb3NpdChmcm9tOiA8LXNlbGYucGF5bWVudFZhdWx0KQogIH0KfQog", - "sendChildFTWithParent": "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\u003d", - "sendChildNFT": "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", - "sendChildNFTToChild": "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", - "setupOwnedAccount": "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", - "setupOwnedAccountAndPublishToParent": "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", - "transferChildFT": "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\u003d\u003d", - "transferChildNFT": "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\u003d\u003d", - "transferNFTToChild": "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", - "unlinkChildAccount": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdW5saW5rQ2hpbGRBY2NvdW50IC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgSHlicmlkQ3VzdG9keSBmcm9tIDB4Mjk0ZTQ0ZTFlYzY5OTNjNgoKCnRyYW5zYWN0aW9uKGNoaWxkOiBBZGRyZXNzKSB7CiAgICBwcmVwYXJlIChhY2N0OiBhdXRoKFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IG1hbmFnZXIgPSBhY2N0LnN0b3JhZ2UuYm9ycm93PGF1dGgoSHlicmlkQ3VzdG9keS5NYW5hZ2UpICZIeWJyaWRDdXN0b2R5Lk1hbmFnZXI+KGZyb206IEh5YnJpZEN1c3RvZHkuTWFuYWdlclN0b3JhZ2VQYXRoKQogICAgICAgICAgICA/PyBwYW5pYygibWFuYWdlciBub3QgZm91bmQiKQogICAgICAgIG1hbmFnZXIucmVtb3ZlQ2hpbGQoYWRkcjogY2hpbGQpCiAgICB9Cn0\u003d" + "addNFTCollectionToDelegator": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYWRkTkZUQ29sbGVjdGlvblRvRGVsZWdhdG9yIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgSHlicmlkQ3VzdG9keSBmcm9tIDB4Mjk0ZTQ0ZTFlYzY5OTNjNgoKCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4NjMxZTg4YWU3ZjFkN2MyMAoKaW1wb3J0IDxUb2tlbj4gZnJvbSA8VG9rZW5BZGRyZXNzPgoKdHJhbnNhY3Rpb24ocGFyZW50OiBBZGRyZXNzLCBpc1B1YmxpYzogQm9vbCkgewogICAgcHJlcGFyZShhY2N0OiBhdXRoKFN0b3JhZ2UsIENhcGFiaWxpdGllcykgJkFjY291bnQpIHsKICAgICAgICBsZXQgbyA9IGFjY3Quc3RvcmFnZS5ib3Jyb3c8YXV0aChIeWJyaWRDdXN0b2R5Lk93bmVyKSAmSHlicmlkQ3VzdG9keS5Pd25lZEFjY291bnQ+KGZyb206IEh5YnJpZEN1c3RvZHkuT3duZWRBY2NvdW50U3RvcmFnZVBhdGgpCiAgICAgICAgICAgID8/IHBhbmljKCJvd25lZCBhY2NvdW50IG5vdCBmb3VuZCIpCiAgICAgICAgbGV0IGNoaWxkOiAmSHlicmlkQ3VzdG9keS5DaGlsZEFjY291bnQgPSBvLmJvcnJvd0NoaWxkQWNjb3VudChwYXJlbnQ6IHBhcmVudCkKICAgICAgICAgICAgPz8gcGFuaWMoImNoaWxkIGFjY291bnQgbm90IGZvdW5kIikKCiAgICAgICAgbGV0IGNhcCA9IGFjY3QuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8JkV4YW1wbGVORlQuQ29sbGVjdGlvbj4oRXhhbXBsZU5GVC5Db2xsZWN0aW9uU3RvcmFnZVBhdGgpCiAgICAgICAgby5hZGRDYXBhYmlsaXR5VG9EZWxlZ2F0b3IocGFyZW50OiBwYXJlbnQsIGNhcDogY2FwLCBpc1B1YmxpYzogaXNQdWJsaWMpCiAgICB9Cn0\u003d", + "batchBridgeChildNFTFromEvm": "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\u003d", + "batchBridgeChildNFTToEvm": "// Flow Wallet - testnet Script  batchBridgeChildNFTToEvm - v2.78
// <platform_info>

import MetadataViews from 0x631e88ae7f1d7c20

import ViewResolver from 0x631e88ae7f1d7c20

import NonFungibleToken from 0x631e88ae7f1d7c20

import FungibleToken from 0x9a0766d93b6608b7

import FlowToken from 0x7e60df042a9c0868

import FungibleTokenMetadataViews from 0x9a0766d93b6608b7

import ScopedFTProviders from 0xdfc20aee650fcbdf

import EVM from 0x8c5303eaa26202d6

import FlowEVMBridgeUtils from 0xdfc20aee650fcbdf

import FlowEVMBridge from 0xdfc20aee650fcbdf

import FlowEVMBridgeConfig from 0xdfc20aee650fcbdf

import HybridCustody from 0x294e44e1ec6993c6

import CapabilityFilter from 0x294e44e1ec6993c6

import CrossVMMetadataViews from 0x631e88ae7f1d7c20


transaction(nftIdentifier: String, child: Address, ids: [UInt64]) {
    prepare(signer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, Capabilities, SaveValue) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        let coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        let m = signer.storage.borrow<auth(HybridCustody.Manage) &HybridCustody.Manager>(from: HybridCustody.ManagerStoragePath)
            ?? panic("manager does not exist")
        let childAcct = m.borrowAccount(addr: child) ?? panic("child account not found")

         // Construct the NFT type from the provided identifier
        let nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Retrieve the NFT --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        let viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = viewResolver.resolveContractView(
                resourceType: nil,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        var collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            )

        // Create collection if it doesn't exist
        if collection == nil {
            signer.storage.save(<- collectionData.createEmptyCollection(), to: collectionData.storagePath)
            signer.capabilities.unpublish(collectionData.publicPath)
            signer.capabilities.publish(
                signer.capabilities.storage.issue<&{NonFungibleToken.Collection}>(collectionData.storagePath),
                at: collectionData.publicPath
            )

            // Borrow authorized withdraw reference to the signer's collection
            collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            )!
        }

        let capType = Type<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider}>()
        let controllerID = childAcct.getControllerIDForType(type: capType, forPath: collectionData.storagePath)
            ?? panic("no controller found for capType")

        let cap = childAcct.getCapability(controllerID: controllerID, type: capType) ?? panic("no cap found")
        let providerCap = cap as! Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider}>
        assert(providerCap.check(), message: "invalid provider capability")

        let id = ids[0]
        // Get a reference to the child's stored vault
        let collectionRef = providerCap.borrow()!
        let childNft <- collectionRef.withdraw(withdrawID: id)
        collection!.deposit(token: <-childNft)
        // // Withdraw tokens from the signer's stored vault
        let currentStorageUsage = signer.storage.used
        let nft <- collection!.withdraw(withdrawID: id)
        let withdrawnStorageUsage = signer.storage.used
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(
                bytes: 400_000
            ) + (FlowEVMBridgeConfig.baseFee * UFix64(ids.length))

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        let scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )

        // Execute the bridge
        coa.depositNFT(
            nft: <- nft,
            feeProvider: &scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        var idx = 0
        for nftId in ids {
            if idx == 0 {
                idx = idx + 1
                continue
            }

            let nft <- collectionRef.withdraw(withdrawID: nftId)
            coa.depositNFT(
                nft: <- nft,
                feeProvider: &scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
            )
            idx = idx + 1
        }
        // Destroy the ScopedFTProvider
        destroy scopedProvider

        // Wrap NFTs if applicable
        wrapAndTransferNFTsIfApplicable(coa,
            nftIDs: ids,
            nftType: nftType,
            viewResolver: viewResolver,
            recipientIfNotCoa: nil
        )
    }
}

/// Wraps and transfers bridged NFTs into a project's custom ERC721 wrapper contract on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
/// @param recipientIfNotCoa: The EVM address to transfer the wrapped NFTs to, nil if the NFTs should stay in signer's COA
///
access(all) fun wrapAndTransferNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt64],
    nftType: Type,
    viewResolver: &{ViewResolver},
    recipientIfNotCoa: EVM.EVMAddress?
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            // Wrap NFTs if underlying ERC721 address matches bridge's associated address for NFT type
            if underlyingAddress.equals(FlowEVMBridgeConfig.getEVMAddressAssociated(with: nftType)!) {
                // Approve contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, true]
                )

                // Wrap NFTs with provided IDs, and check if the call was successful
                let res = mustCall(coa, crossVMPointer.evmContractAddress,
                    functionSig: "depositFor(address,uint256[])",
                    args: [coa.address(), nftIDs]
                )
                let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                assert(decodedRes.length == 1, message: "Invalid response length")
                assert(decodedRes[0] as! Bool, message: "Failed to wrap NFTs")

                // Transfer NFTs to recipient if provided
                if let to = recipientIfNotCoa {
                    mustTransferNFTs(coa, crossVMPointer.evmContractAddress, nftIDs: nftIDs, to: to)
                }

                // Revoke approval for contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, false]
                )
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is owned by the provided EVM address
///
access(all) fun isOwner(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    _ nftID: UInt64,
    _ ownerToCheck: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: erc721Address,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )
    assert(res.status == EVM.Status.successful, message: "Call to ERC721.ownerOf(uint256) failed")
    let decodedRes = EVM.decodeABI(types: [Type<EVM.EVMAddress>()], data: res.data)
    if decodedRes.length == 1 {
        let actualOwner = decodedRes[0] as! EVM.EVMAddress
        return actualOwner.equals(ownerToCheck)
    }
    return false
}

/// Transfers NFTs from the provided COA to the provided EVM address
///
access(all) fun mustTransferNFTs(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    nftIDs: [UInt64],
    to: EVM.EVMAddress
) {
    for id in nftIDs {
        assert(isOwner(coa, erc721Address, id, coa.address()), message: "NFT not owned by signer's COA")
        mustCall(coa, erc721Address,
            functionSig: "safeTransferFrom(address,address,uint256)",
            args: [coa.address(), to, id]
        )
        assert(isOwner(coa, erc721Address, id, to), message: "NFT not transferred to recipient")
    }
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", + "batchBridgeChildNFTToEvmAddress": "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\u003d\u003d", + "batchSendChildNFT": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYmF0Y2hTZW5kQ2hpbGRORlQgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBIeWJyaWRDdXN0b2R5IGZyb20gMHgyOTRlNDRlMWVjNjk5M2M2CgppbXBvcnQgQ2FwYWJpbGl0eUZpbHRlciBmcm9tIDB4Mjk0ZTQ0ZTFlYzY5OTNjNgoKaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgoKaW1wb3J0IDxORlQ+IGZyb20gPE5GVEFkZHJlc3M+CgoKdHJhbnNhY3Rpb24oY2hpbGRBZGRyOiBBZGRyZXNzLCByZWNlaXZlcjogQWRkcmVzcywgaWRlbnRpZmllcjogU3RyaW5nLCBpZHM6IFtVSW50NjRdKSB7CiAgcHJlcGFyZShzaWduZXI6IGF1dGgoU3RvcmFnZSkgJkFjY291bnQpIHsKICAgIC8vIHNpZ25lciBpcyB0aGUgcGFyZW50IGFjY291bnQKICAgIC8vIGdldCB0aGUgbWFuYWdlciByZXNvdXJjZSBhbmQgYm9ycm93IGNoaWxkQWNjb3VudAogICAgbGV0IG0gPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChIeWJyaWRDdXN0b2R5Lk1hbmFnZSkgJkh5YnJpZEN1c3RvZHkuTWFuYWdlcj4oZnJvbTogSHlicmlkQ3VzdG9keS5NYW5hZ2VyU3RvcmFnZVBhdGgpCiAgICAgICAgPz8gcGFuaWMoIm1hbmFnZXIgZG9lcyBub3QgZXhpc3QiKQogICAgbGV0IGNoaWxkQWNjdCA9IG0uYm9ycm93QWNjb3VudChhZGRyOiBjaGlsZEFkZHIpID8/IHBhbmljKCJjaGlsZCBhY2NvdW50IG5vdCBmb3VuZCIpCiAgICAKICAgIGxldCBjb2xsZWN0aW9uRGF0YSA9IDxORlQ+LnJlc29sdmVDb250cmFjdFZpZXcocmVzb3VyY2VUeXBlOiBuaWwsIHZpZXdUeXBlOiBUeXBlPE1ldGFkYXRhVmlld3MuTkZUQ29sbGVjdGlvbkRhdGE+KCkpIGFzISBNZXRhZGF0YVZpZXdzLk5GVENvbGxlY3Rpb25EYXRhPwogICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgZ2V0IHRoZSB2YXVsdCBkYXRhIHZpZXcgZm9yIDxORlQ+ICIpCgogICAgLy9nZXQgRnQgY2FwIGZyb20gY2hpbGQgYWNjb3VudAogICAgbGV0IGNhcFR5cGUgPSBUeXBlPGF1dGgoTm9uRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntOb25GdW5naWJsZVRva2VuLlByb3ZpZGVyfT4oKQogICAgbGV0IGNvbnRyb2xsZXJJRCA9IGNoaWxkQWNjdC5nZXRDb250cm9sbGVySURGb3JUeXBlKHR5cGU6IGNhcFR5cGUsIGZvclBhdGg6IGNvbGxlY3Rpb25EYXRhLnN0b3JhZ2VQYXRoKQogICAgICAgID8/IHBhbmljKCJubyBjb250cm9sbGVyIGZvdW5kIGZvciBjYXBUeXBlIikKICAgIAogICAgbGV0IGNhcCA9IGNoaWxkQWNjdC5nZXRDYXBhYmlsaXR5KGNvbnRyb2xsZXJJRDogY29udHJvbGxlcklELCB0eXBlOiBjYXBUeXBlKSA/PyBwYW5pYygibm8gY2FwIGZvdW5kIikKICAgIGxldCBwcm92aWRlckNhcCA9IGNhcCBhcyEgQ2FwYWJpbGl0eTxhdXRoKE5vbkZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7Tm9uRnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+CiAgICBhc3NlcnQocHJvdmlkZXJDYXAuY2hlY2soKSwgbWVzc2FnZTogImludmFsaWQgcHJvdmlkZXIgY2FwYWJpbGl0eSIpCiAgICAKICAgIC8vIEdldCBhIHJlZmVyZW5jZSB0byB0aGUgY2hpbGQncyBzdG9yZWQgdmF1bHQKICAgIGxldCBjb2xsZWN0aW9uUmVmID0gcHJvdmlkZXJDYXAuYm9ycm93KCkhCgogICAKICAgIGxldCByZWNlaXZlckFjYyA9IGdldEFjY291bnQocmVjZWl2ZXIpCiAgICBsZXQgcmVjZWl2ZXJSZWYgPSAgcmVjZWl2ZXJBY2MuY2FwYWJpbGl0aWVzLmdldDwme05vbkZ1bmdpYmxlVG9rZW4uUmVjZWl2ZXJ9Pihjb2xsZWN0aW9uRGF0YS5wdWJsaWNQYXRoKSEuYm9ycm93KCkKICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IHJlY2VpdmVyIHJlZmVyZW5jZSB0byB0aGUgcmVjaXBpZW50J3MgVmF1bHQiKQogICAgCiAgICBmb3IgaWQgaW4gaWRzIHsKICAgICAgICAvLyBXaXRoZHJhdyB0b2tlbnMgZnJvbSB0aGUgc2lnbmVyJ3Mgc3RvcmVkIHZhdWx0CiAgICAgICAgbGV0IG5mdCA8LSBjb2xsZWN0aW9uUmVmLndpdGhkcmF3KHdpdGhkcmF3SUQ6IGlkKQogICAgICAgIHJlY2VpdmVyUmVmLmRlcG9zaXQodG9rZW46IDwtIG5mdCkKICAgIH0KICB9Cn0\u003d", + "batchSendChildNFTToChild": "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\u003d\u003d", + "batchTransferChildNFT": "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", + "batchTransferNFTToChild": "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\u003d\u003d", + "bridgeChildFTFromEvm": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYnJpZGdlQ2hpbGRGVEZyb21Fdm0gLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgppbXBvcnQgVmlld1Jlc29sdmVyIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4NjMxZTg4YWU3ZjFkN2MyMAoKCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHg3ZTYwZGYwNDJhOWMwODY4CgppbXBvcnQgRnVuZ2libGVUb2tlbk1ldGFkYXRhVmlld3MgZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCgppbXBvcnQgU2NvcGVkRlRQcm92aWRlcnMgZnJvbSAweGRmYzIwYWVlNjUwZmNiZGYKCgppbXBvcnQgRVZNIGZyb20gMHg4YzUzMDNlYWEyNjIwMmQ2CgoKaW1wb3J0IEZsb3dFVk1CcmlkZ2VVdGlscyBmcm9tIDB4ZGZjMjBhZWU2NTBmY2JkZgoKaW1wb3J0IEZsb3dFVk1CcmlkZ2UgZnJvbSAweGRmYzIwYWVlNjUwZmNiZGYKCmltcG9ydCBGbG93RVZNQnJpZGdlQ29uZmlnIGZyb20gMHhkZmMyMGFlZTY1MGZjYmRmCgoKCmltcG9ydCBIeWJyaWRDdXN0b2R5IGZyb20gMHgyOTRlNDRlMWVjNjk5M2M2CgppbXBvcnQgQ2FwYWJpbGl0eUZpbHRlciBmcm9tIDB4Mjk0ZTQ0ZTFlYzY5OTNjNgoKCnRyYW5zYWN0aW9uKHZhdWx0SWRlbnRpZmllcjogU3RyaW5nLCBjaGlsZDogQWRkcmVzcywgYW1vdW50OiBVSW50MjU2KSB7CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChCb3Jyb3dWYWx1ZSwgQ29weVZhbHVlLCBJc3N1ZVN0b3JhZ2VDYXBhYmlsaXR5Q29udHJvbGxlciwgUHVibGlzaENhcGFiaWxpdHksIFNhdmVWYWx1ZSwgVW5wdWJsaXNoQ2FwYWJpbGl0eSkgJkFjY291bnQpIHsKICAgICAgICAvLyBCb3Jyb3cgYSByZWZlcmVuY2UgdG8gdGhlIHNpZ25lcidzIENPQQogICAgICAgIGxldCBjb2EgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChFVk0uQnJpZGdlKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQ+KGZyb206IC9zdG9yYWdlL2V2bSkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgQ09BIGZyb20gcHJvdmlkZWQgZ2F0ZXdheSBhZGRyZXNzIikKICAgICAgICBsZXQgdmF1bHRUeXBlID0gQ29tcG9zaXRlVHlwZSh2YXVsdElkZW50aWZpZXIpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgY29uc3RydWN0IFZhdWx0IHR5cGUgZnJvbSBpZGVudGlmaWVyOiAiLmNvbmNhdCh2YXVsdElkZW50aWZpZXIpKQogICAgICAgIC8vIFBhcnNlIHRoZSBWYXVsdCBpZGVudGlmaWVyIGludG8gaXRzIGNvbXBvbmVudHMKICAgICAgICBsZXQgdG9rZW5Db250cmFjdEFkZHJlc3MgPSBGbG93RVZNQnJpZGdlVXRpbHMuZ2V0Q29udHJhY3RBZGRyZXNzKGZyb21UeXBlOiB2YXVsdFR5cGUpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgZ2V0IGNvbnRyYWN0IGFkZHJlc3MgZnJvbSBpZGVudGlmaWVyOiAiLmNvbmNhdCh2YXVsdElkZW50aWZpZXIpKQogICAgICAgIGxldCB0b2tlbkNvbnRyYWN0TmFtZSA9IEZsb3dFVk1CcmlkZ2VVdGlscy5nZXRDb250cmFjdE5hbWUoZnJvbVR5cGU6IHZhdWx0VHlwZSkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBnZXQgY29udHJhY3QgbmFtZSBmcm9tIGlkZW50aWZpZXI6ICIuY29uY2F0KHZhdWx0SWRlbnRpZmllcikpCgogICAgICAgIC8qIC0tLSBSZXRyaWV2ZSB0aGUgZnVuZHMgLS0tICovCiAgICAgICAgLy8KICAgICAgICAvLyBCb3Jyb3cgYSByZWZlcmVuY2UgdG8gdGhlIEZ1bmdpYmxlVG9rZW4gVmF1bHQKICAgICAgICBsZXQgdmlld1Jlc29sdmVyID0gZ2V0QWNjb3VudCh0b2tlbkNvbnRyYWN0QWRkcmVzcykuY29udHJhY3RzLmJvcnJvdzwme1ZpZXdSZXNvbHZlcn0+KG5hbWU6IHRva2VuQ29udHJhY3ROYW1lKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBWaWV3UmVzb2x2ZXIgZnJvbSBGdW5naWJsZVRva2VuIGNvbnRyYWN0IikKICAgICAgICBsZXQgdmF1bHREYXRhID0gdmlld1Jlc29sdmVyLnJlc29sdmVDb250cmFjdFZpZXcoCiAgICAgICAgICAgICAgICByZXNvdXJjZVR5cGU6IG5pbCwKICAgICAgICAgICAgICAgIHZpZXdUeXBlOiBUeXBlPEZ1bmdpYmxlVG9rZW5NZXRhZGF0YVZpZXdzLkZUVmF1bHREYXRhPigpCiAgICAgICAgICAgICkgYXMhIEZ1bmdpYmxlVG9rZW5NZXRhZGF0YVZpZXdzLkZUVmF1bHREYXRhPyA/PyBwYW5pYygiQ291bGQgbm90IHJlc29sdmUgRlRWYXVsdERhdGEgdmlldyIpCgogICAgICAgIC8vIHNpZ25lciBpcyB0aGUgcGFyZW50IGFjY291bnQKICAgICAgICAvLyBnZXQgdGhlIG1hbmFnZXIgcmVzb3VyY2UgYW5kIGJvcnJvdyBjaGlsZEFjY291bnQKICAgICAgICBsZXQgbSA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKEh5YnJpZEN1c3RvZHkuTWFuYWdlKSAmSHlicmlkQ3VzdG9keS5NYW5hZ2VyPihmcm9tOiBIeWJyaWRDdXN0b2R5Lk1hbmFnZXJTdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIm1hbmFnZXIgZG9lcyBub3QgZXhpc3QiKQogICAgICAgIGxldCBjaGlsZEFjY3QgPSBtLmJvcnJvd0FjY291bnQoYWRkcjogY2hpbGQpID8/IHBhbmljKCJjaGlsZCBhY2NvdW50IG5vdCBmb3VuZCIpCiAgICAgICAgCiAgICAgCiAgICAgICAgLy9nZXQgRnQgY2FwIGZyb20gY2hpbGQgYWNjb3VudAogICAgICAgIGxldCBjYXBUeXBlID0gVHlwZTwme0Z1bmdpYmxlVG9rZW4uUmVjZWl2ZXJ9PigpCiAgICAgICAgbGV0IGNvbnRyb2xsZXJJRCA9IGNoaWxkQWNjdC5nZXRDb250cm9sbGVySURGb3JUeXBlKHR5cGU6IGNhcFR5cGUsIGZvclBhdGg6IHZhdWx0RGF0YS5zdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIm5vIGNvbnRyb2xsZXIgZm91bmQgZm9yIGNhcFR5cGUiKQogICAgICAgIAogICAgICAgIGxldCBjYXAgPSBjaGlsZEFjY3QuZ2V0Q2FwYWJpbGl0eShjb250cm9sbGVySUQ6IGNvbnRyb2xsZXJJRCwgdHlwZTogY2FwVHlwZSkgPz8gcGFuaWMoIm5vIGNhcCBmb3VuZCIpCiAgICAgICAgbGV0IHByb3ZpZGVyQ2FwID0gY2FwIGFzISBDYXBhYmlsaXR5PCZ7RnVuZ2libGVUb2tlbi5SZWNlaXZlcn0+CiAgICAgICAgYXNzZXJ0KHByb3ZpZGVyQ2FwLmNoZWNrKCksIG1lc3NhZ2U6ICJpbnZhbGlkIHByb3ZpZGVyIGNhcGFiaWxpdHkiKQogICAgICAgIAogICAgICAgIC8vIEdldCBhIHJlZmVyZW5jZSB0byB0aGUgY2hpbGQncyBzdG9yZWQgdmF1bHQKICAgICAgICBsZXQgdmF1bHRSZWYgPSBwcm92aWRlckNhcC5ib3Jyb3coKSEKCiAgICAgIAogICAgICAgIGxldCBhcHByb3hGZWUgPSBGbG93RVZNQnJpZGdlVXRpbHMuY2FsY3VsYXRlQnJpZGdlRmVlKGJ5dGVzOiA0MDBfMDAwKQogICAgICAgIC8qIC0tLSBDb25maWd1cmUgYSBTY29wZWRGVFByb3ZpZGVyIC0tLSAqLwogICAgICAgIC8vCiAgICAgICAgLy8gSXNzdWUgYW5kIHN0b3JlIGJyaWRnZS1kZWRpY2F0ZWQgUHJvdmlkZXIgQ2FwYWJpbGl0eSBpbiBzdG9yYWdlIGlmIG5lY2Vzc2FyeQogICAgICAgIGlmIHNpZ25lci5zdG9yYWdlLnR5cGUoYXQ6IEZsb3dFVk1CcmlkZ2VDb25maWcucHJvdmlkZXJDYXBhYmlsaXR5U3RvcmFnZVBhdGgpID09IG5pbCB7CiAgICAgICAgICAgIGxldCBwcm92aWRlckNhcCA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+KAogICAgICAgICAgICAgICAgL3N0b3JhZ2UvZmxvd1Rva2VuVmF1bHQKICAgICAgICAgICAgKQogICAgICAgICAgICBzaWduZXIuc3RvcmFnZS5zYXZlKHByb3ZpZGVyQ2FwLCB0bzogRmxvd0VWTUJyaWRnZUNvbmZpZy5wcm92aWRlckNhcGFiaWxpdHlTdG9yYWdlUGF0aCkKICAgICAgICB9CiAgICAgICAgLy8gQ29weSB0aGUgc3RvcmVkIFByb3ZpZGVyIGNhcGFiaWxpdHkgYW5kIGNyZWF0ZSBhIFNjb3BlZEZUUHJvdmlkZXIKICAgICAgICBsZXQgcHJvdmlkZXJDYXBDb3B5ID0gc2lnbmVyLnN0b3JhZ2UuY29weTxDYXBhYmlsaXR5PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntGdW5naWJsZVRva2VuLlByb3ZpZGVyfT4+KAogICAgICAgICAgICAgICAgZnJvbTogRmxvd0VWTUJyaWRnZUNvbmZpZy5wcm92aWRlckNhcGFiaWxpdHlTdG9yYWdlUGF0aAogICAgICAgICAgICApID8/IHBhbmljKCJJbnZhbGlkIFByb3ZpZGVyIENhcGFiaWxpdHkgZm91bmQgaW4gc3RvcmFnZS4iKQogICAgICAgIGxldCBwcm92aWRlckZpbHRlciA9IFNjb3BlZEZUUHJvdmlkZXJzLkFsbG93YW5jZUZpbHRlcihhcHByb3hGZWUpCiAgICAgICAgbGV0IHNjb3BlZFByb3ZpZGVyIDwtIFNjb3BlZEZUUHJvdmlkZXJzLmNyZWF0ZVNjb3BlZEZUUHJvdmlkZXIoCiAgICAgICAgICAgIHByb3ZpZGVyOiBwcm92aWRlckNhcENvcHksCiAgICAgICAgICAgIGZpbHRlcnM6IFsgcHJvdmlkZXJGaWx0ZXIgXSwKICAgICAgICAgICAgZXhwaXJhdGlvbjogZ2V0Q3VycmVudEJsb2NrKCkudGltZXN0YW1wICsgMS4wCiAgICAgICAgKQoKICAgICAgICBsZXQgdmF1bHQ6IEB7RnVuZ2libGVUb2tlbi5WYXVsdH0gPC0gY29hLndpdGhkcmF3VG9rZW5zKAogICAgICAgICAgICB0eXBlOiB2YXVsdFR5cGUsCiAgICAgICAgICAgIGFtb3VudDogYW1vdW50LAogICAgICAgICAgICBmZWVQcm92aWRlcjogJnNjb3BlZFByb3ZpZGVyIGFzIGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntGdW5naWJsZVRva2VuLlByb3ZpZGVyfQogICAgICAgICkKCiAgICAgICAgdmF1bHRSZWYuZGVwb3NpdChmcm9tOiA8LSB2YXVsdCkKICAgICAgICBkZXN0cm95IHNjb3BlZFByb3ZpZGVyCiAgICB9Cgp9CiA\u003d", + "bridgeChildFTToEvm": "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\u003d\u003d", + "bridgeChildFTToEvmAddress": "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\u003d", + "bridgeChildNFTFromEvm": "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\u003d", + "bridgeChildNFTToEvm": "// Flow Wallet - testnet Script  bridgeChildNFTToEvm - v2.78
// <platform_info>

import MetadataViews from 0x631e88ae7f1d7c20

import ViewResolver from 0x631e88ae7f1d7c20

import NonFungibleToken from 0x631e88ae7f1d7c20

import FungibleToken from 0x9a0766d93b6608b7

import FlowToken from 0x7e60df042a9c0868

import FungibleTokenMetadataViews from 0x9a0766d93b6608b7

import ScopedFTProviders from 0xdfc20aee650fcbdf

import EVM from 0x8c5303eaa26202d6

import FlowEVMBridgeUtils from 0xdfc20aee650fcbdf

import FlowEVMBridge from 0xdfc20aee650fcbdf

import FlowEVMBridgeConfig from 0xdfc20aee650fcbdf

import HybridCustody from 0x294e44e1ec6993c6

import CapabilityFilter from 0x294e44e1ec6993c6

import CrossVMMetadataViews from 0x631e88ae7f1d7c20


transaction(nftIdentifier: String, id: UInt64, child: Address) {

    let nft: @{NonFungibleToken.NFT}
    let coa: auth(EVM.Bridge, EVM.Call) &EVM.CadenceOwnedAccount
    let scopedProvider: @ScopedFTProviders.ScopedFTProvider
    let nftType: Type
    let viewResolver: &{ViewResolver}
    prepare(signer: auth(CopyValue, BorrowValue, IssueStorageCapabilityController, Capabilities, SaveValue) &Account) {
        /* --- Reference the signer's CadenceOwnedAccount --- */
        //
        // Borrow a reference to the signer's COA
        self.coa = signer.storage.borrow<auth(EVM.Call, EVM.Bridge) &EVM.CadenceOwnedAccount>(from: /storage/evm)
            ?? panic("Could not borrow COA from provided gateway address")

        let m = signer.storage.borrow<auth(HybridCustody.Manage) &HybridCustody.Manager>(from: HybridCustody.ManagerStoragePath)
            ?? panic("manager does not exist")
        let childAcct = m.borrowAccount(addr: child) ?? panic("child account not found")

         // Construct the NFT type from the provided identifier
        self.nftType = CompositeType(nftIdentifier)
            ?? panic("Could not construct NFT type from identifier: ".concat(nftIdentifier))
        let nftContractAddress = FlowEVMBridgeUtils.getContractAddress(fromType: self.nftType)
            ?? panic("Could not get contract address from identifier: ".concat(nftIdentifier))
        let nftContractName = FlowEVMBridgeUtils.getContractName(fromType: self.nftType)
            ?? panic("Could not get contract name from identifier: ".concat(nftIdentifier))

        /* --- Retrieve the NFT --- */
        //
        // Borrow a reference to the NFT collection, configuring if necessary
        self.viewResolver = getAccount(nftContractAddress).contracts.borrow<&{ViewResolver}>(name: nftContractName)
            ?? panic("Could not borrow ViewResolver from NFT contract")
        let collectionData = self.viewResolver.resolveContractView(
                resourceType: nil,
                viewType: Type<MetadataViews.NFTCollectionData>()
            ) as! MetadataViews.NFTCollectionData? ?? panic("Could not resolve NFTCollectionData view")
        var collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            )

        // Create collection if it doesn't exist
        if collection == nil {
            signer.storage.save(<- collectionData.createEmptyCollection(), to: collectionData.storagePath)
            signer.capabilities.unpublish(collectionData.publicPath)
            signer.capabilities.publish(
                signer.capabilities.storage.issue<&{NonFungibleToken.Collection}>(collectionData.storagePath),
                at: collectionData.publicPath
            )

            // Borrow authorized withdraw reference to the signer's collection
            collection = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: collectionData.storagePath
            )!
        }

        let capType = Type<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider}>()
        let controllerID = childAcct.getControllerIDForType(type: capType, forPath: collectionData.storagePath)
            ?? panic("no controller found for capType")

        let cap = childAcct.getCapability(controllerID: controllerID, type: capType) ?? panic("no cap found")
        let providerCap = cap as! Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider}>
        assert(providerCap.check(), message: "invalid provider capability")

        // Get a reference to the child's stored vault
        let collectionRef = providerCap.borrow()!
        let childNft <- collectionRef.withdraw(withdrawID: id)
        collection!.deposit(token: <-childNft)
        // // Withdraw tokens from the signer's stored vault
        let currentStorageUsage = signer.storage.used
        self.nft <- collection!.withdraw(withdrawID: id)
        let withdrawnStorageUsage = signer.storage.used
        let approxFee = FlowEVMBridgeUtils.calculateBridgeFee(
                bytes: 400_000
            )

        /* --- Configure a ScopedFTProvider --- */
        //
        // Issue and store bridge-dedicated Provider Capability in storage if necessary
        if signer.storage.type(at: FlowEVMBridgeConfig.providerCapabilityStoragePath) == nil {
            let providerCap = signer.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>(
                /storage/flowTokenVault
            )
            signer.storage.save(providerCap, to: FlowEVMBridgeConfig.providerCapabilityStoragePath)
        }
        // Copy the stored Provider capability and create a ScopedFTProvider
        let providerCapCopy = signer.storage.copy<Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>>(
                from: FlowEVMBridgeConfig.providerCapabilityStoragePath
            ) ?? panic("Invalid Provider Capability found in storage.")
        let providerFilter = ScopedFTProviders.AllowanceFilter(approxFee)
        self.scopedProvider <- ScopedFTProviders.createScopedFTProvider(
                provider: providerCapCopy,
                filters: [ providerFilter ],
                expiration: getCurrentBlock().timestamp + 1.0
            )
    }

    execute {
        // Execute the bridge
        self.coa.depositNFT(
            nft: <-self.nft,
            feeProvider: &self.scopedProvider as auth(FungibleToken.Withdraw) &{FungibleToken.Provider}
        )
        // Destroy the ScopedFTProvider
        destroy self.scopedProvider

        // Wrap NFTs if applicable
        wrapAndTransferNFTsIfApplicable(
            self.coa,
            nftIDs: [id],
            nftType: self.nftType,
            viewResolver: self.viewResolver,
            recipientIfNotCoa: nil
        )
    }
}

/// Wraps and transfers bridged NFTs into a project's custom ERC721 wrapper contract on EVM, if applicable.
/// Enables projects to use their own ERC721 contract while leveraging the bridge's underlying contract,
/// until direct custom contract support is added to the bridge.
///
/// @param coa: The COA of the signer
/// @param nftIDs: The IDs of the NFTs to wrap
/// @param nftType: The type of the NFTs to wrap
/// @param viewResolver: The ViewResolver of the NFT contract
/// @param recipientIfNotCoa: The EVM address to transfer the wrapped NFTs to, nil if the NFTs should stay in signer's COA
///
access(all) fun wrapAndTransferNFTsIfApplicable(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    nftIDs: [UInt64],
    nftType: Type,
    viewResolver: &{ViewResolver},
    recipientIfNotCoa: EVM.EVMAddress?
) {
    // Get the project-defined ERC721 address if it exists
    if let crossVMPointer = viewResolver.resolveContractView(
            resourceType: nftType,
            viewType: Type<CrossVMMetadataViews.EVMPointer>()
    ) as! CrossVMMetadataViews.EVMPointer? {
        // Get the underlying ERC721 address if it exists
        if let underlyingAddress = getUnderlyingERC721Address(coa, crossVMPointer.evmContractAddress) {
            // Wrap NFTs if underlying ERC721 address matches bridge's associated address for NFT type
            if underlyingAddress.equals(FlowEVMBridgeConfig.getEVMAddressAssociated(with: nftType)!) {
                // Approve contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, true]
                )

                // Wrap NFTs with provided IDs, and check if the call was successful
                let res = mustCall(coa, crossVMPointer.evmContractAddress,
                    functionSig: "depositFor(address,uint256[])",
                    args: [coa.address(), nftIDs]
                )
                let decodedRes = EVM.decodeABI(types: [Type<Bool>()], data: res.data)
                assert(decodedRes.length == 1, message: "Invalid response length")
                assert(decodedRes[0] as! Bool, message: "Failed to wrap NFTs")

                // Transfer NFTs to recipient if provided
                if let to = recipientIfNotCoa {
                    mustTransferNFTs(coa, crossVMPointer.evmContractAddress, nftIDs: nftIDs, to: to)
                }

                // Revoke approval for contract to withdraw underlying NFTs from signer's coa
                mustCall(coa, underlyingAddress,
                    functionSig: "setApprovalForAll(address,bool)",
                    args: [crossVMPointer.evmContractAddress, false]
                )
            }
        }
    }
}

/// Gets the underlying ERC721 address if it exists (i.e. if the ERC721 is a wrapper)
///
access(all) fun getUnderlyingERC721Address(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ wrapperAddress: EVM.EVMAddress
): EVM.EVMAddress? {
    let res = coa.call(
        to: wrapperAddress,
        data: EVM.encodeABIWithSignature("underlying()", []),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )

    // If the call fails, return nil
    if res.status != EVM.Status.successful || res.data.length == 0 {
        return nil
    }

    // Decode and return the underlying ERC721 address
    let decodedResult = EVM.decodeABI(
        types: [Type<EVM.EVMAddress>()],
        data: res.data
    )
    assert(decodedResult.length == 1, message: "Invalid response length")
    return decodedResult[0] as! EVM.EVMAddress
}

/// Checks if the provided NFT is owned by the provided EVM address
///
access(all) fun isOwner(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    _ nftID: UInt64,
    _ ownerToCheck: EVM.EVMAddress
): Bool {
    let res = coa.call(
        to: erc721Address,
        data: EVM.encodeABIWithSignature("ownerOf(uint256)", [nftID]),
        gasLimit: 100_000,
        value: EVM.Balance(attoflow: 0)
    )
    assert(res.status == EVM.Status.successful, message: "Call to ERC721.ownerOf(uint256) failed")
    let decodedRes = EVM.decodeABI(types: [Type<EVM.EVMAddress>()], data: res.data)
    if decodedRes.length == 1 {
        let actualOwner = decodedRes[0] as! EVM.EVMAddress
        return actualOwner.equals(ownerToCheck)
    }
    return false
}

/// Transfers NFTs from the provided COA to the provided EVM address
///
access(all) fun mustTransferNFTs(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ erc721Address: EVM.EVMAddress,
    nftIDs: [UInt64],
    to: EVM.EVMAddress
) {
    for id in nftIDs {
        assert(isOwner(coa, erc721Address, id, coa.address()), message: "NFT not owned by signer's COA")
        mustCall(coa, erc721Address,
            functionSig: "safeTransferFrom(address,address,uint256)",
            args: [coa.address(), to, id]
        )
        assert(isOwner(coa, erc721Address, id, to), message: "NFT not transferred to recipient")
    }
}

/// Calls a function on an EVM contract from provided coa
///
access(all) fun mustCall(
    _ coa: auth(EVM.Call) &EVM.CadenceOwnedAccount,
    _ contractAddr: EVM.EVMAddress,
    functionSig: String,
    args: [AnyStruct]
): EVM.Result {
    let res = coa.call(
        to: contractAddr,
        data: EVM.encodeABIWithSignature(functionSig, args),
        gasLimit: 4_000_000,
        value: EVM.Balance(attoflow: 0)
    )

    assert(res.status == EVM.Status.successful,
        message: "Failed to call '".concat(functionSig)
            .concat("\n\t error code: ").concat(res.errorCode.toString())
            .concat("\n\t error message: ").concat(res.errorMessage)
            .concat("\n\t gas used: ").concat(res.gasUsed.toString())
            .concat("\n\t caller address: 0x").concat(coa.address().toString())
            .concat("\n\t contract address: 0x").concat(contractAddr.toString())
    )

    return res
}
", + "bridgeChildNFTToEvmAddress": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYnJpZGdlQ2hpbGRORlRUb0V2bUFkZHJlc3MgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgppbXBvcnQgVmlld1Jlc29sdmVyIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4NjMxZTg4YWU3ZjFkN2MyMAoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDdlNjBkZjA0MmE5YzA4NjgKCmltcG9ydCBGdW5naWJsZVRva2VuTWV0YWRhdGFWaWV3cyBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKaW1wb3J0IFNjb3BlZEZUUHJvdmlkZXJzIGZyb20gMHhkZmMyMGFlZTY1MGZjYmRmCgppbXBvcnQgRVZNIGZyb20gMHg4YzUzMDNlYWEyNjIwMmQ2CgppbXBvcnQgRmxvd0VWTUJyaWRnZVV0aWxzIGZyb20gMHhkZmMyMGFlZTY1MGZjYmRmCgppbXBvcnQgRmxvd0VWTUJyaWRnZSBmcm9tIDB4ZGZjMjBhZWU2NTBmY2JkZgoKaW1wb3J0IEZsb3dFVk1CcmlkZ2VDb25maWcgZnJvbSAweGRmYzIwYWVlNjUwZmNiZGYKCmltcG9ydCBIeWJyaWRDdXN0b2R5IGZyb20gMHgyOTRlNDRlMWVjNjk5M2M2CgppbXBvcnQgQ2FwYWJpbGl0eUZpbHRlciBmcm9tIDB4Mjk0ZTQ0ZTFlYzY5OTNjNgoKaW1wb3J0IENyb3NzVk1NZXRhZGF0YVZpZXdzIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgoKdHJhbnNhY3Rpb24obmZ0SWRlbnRpZmllcjogU3RyaW5nLCBjaGlsZDogQWRkcmVzcywgaWQ6IFVJbnQ2NCwgcmVjaXBpZW50OlN0cmluZykgewoKICAgIGxldCBuZnQ6IEB7Tm9uRnVuZ2libGVUb2tlbi5ORlR9CiAgICBsZXQgY29hOiBhdXRoKEVWTS5DYWxsKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQKICAgIGxldCBzY29wZWRQcm92aWRlcjogQFNjb3BlZEZUUHJvdmlkZXJzLlNjb3BlZEZUUHJvdmlkZXIKICAgIGxldCBuZnRUeXBlOiBUeXBlCiAgICBsZXQgdmlld1Jlc29sdmVyOiAme1ZpZXdSZXNvbHZlcn0KCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChDb3B5VmFsdWUsIEJvcnJvd1ZhbHVlLCBJc3N1ZVN0b3JhZ2VDYXBhYmlsaXR5Q29udHJvbGxlciwgQ2FwYWJpbGl0aWVzLCBTYXZlVmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgLy8gUmV0cmlldmUgb3IgY3JlYXRlIENPQQogICAgICAgIGlmIGxldCBjb2EgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChFVk0uQ2FsbCkgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50Pihmcm9tOiAvc3RvcmFnZS9ldm0pIHsKICAgICAgICAgICAgc2VsZi5jb2EgPSBjb2EKICAgICAgICB9IGVsc2UgewogICAgICAgICAgICBzaWduZXIuc3RvcmFnZS5zYXZlPEBFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oPC0gRVZNLmNyZWF0ZUNhZGVuY2VPd25lZEFjY291bnQoKSwgdG86IC9zdG9yYWdlL2V2bSkKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5wdWJsaXNoKAogICAgICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5zdG9yYWdlLmlzc3VlPCZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oL3N0b3JhZ2UvZXZtKSwKICAgICAgICAgICAgICAgIGF0OiAvcHVibGljL2V2bQogICAgICAgICAgICApCiAgICAgICAgICAgIHNlbGYuY29hID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoRVZNLkNhbGwpICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudD4oZnJvbTogL3N0b3JhZ2UvZXZtKSEKICAgICAgICB9CgogICAgICAgIC8vIFJldHJpZXZlIG9yIGNyZWF0ZSBjaGlsZCBhY2NvdW50CiAgICAgICAgbGV0IG0gPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChIeWJyaWRDdXN0b2R5Lk1hbmFnZSkgJkh5YnJpZEN1c3RvZHkuTWFuYWdlcj4oZnJvbTogSHlicmlkQ3VzdG9keS5NYW5hZ2VyU3RvcmFnZVBhdGgpCiAgICAgICAgICAgID8/IHBhbmljKCJtYW5hZ2VyIGRvZXMgbm90IGV4aXN0IikKICAgICAgICBsZXQgY2hpbGRBY2N0ID0gbS5ib3Jyb3dBY2NvdW50KGFkZHI6IGNoaWxkKSA/PyBwYW5pYygiY2hpbGQgYWNjb3VudCBub3QgZm91bmQiKQoKICAgICAgICAgLy8gQ29uc3RydWN0IHRoZSBORlQgdHlwZSBmcm9tIHRoZSBwcm92aWRlZCBpZGVudGlmaWVyCiAgICAgICAgc2VsZi5uZnRUeXBlID0gQ29tcG9zaXRlVHlwZShuZnRJZGVudGlmaWVyKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGNvbnN0cnVjdCBORlQgdHlwZSBmcm9tIGlkZW50aWZpZXI6ICIuY29uY2F0KG5mdElkZW50aWZpZXIpKQogICAgICAgIGxldCBuZnRDb250cmFjdEFkZHJlc3MgPSBGbG93RVZNQnJpZGdlVXRpbHMuZ2V0Q29udHJhY3RBZGRyZXNzKGZyb21UeXBlOiBzZWxmLm5mdFR5cGUpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgZ2V0IGNvbnRyYWN0IGFkZHJlc3MgZnJvbSBpZGVudGlmaWVyOiAiLmNvbmNhdChuZnRJZGVudGlmaWVyKSkKICAgICAgICBsZXQgbmZ0Q29udHJhY3ROYW1lID0gRmxvd0VWTUJyaWRnZVV0aWxzLmdldENvbnRyYWN0TmFtZShmcm9tVHlwZTogc2VsZi5uZnRUeXBlKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGdldCBjb250cmFjdCBuYW1lIGZyb20gaWRlbnRpZmllcjogIi5jb25jYXQobmZ0SWRlbnRpZmllcikpCgogICAgICAgIC8qIC0tLSBSZXRyaWV2ZSB0aGUgTkZUIC0tLSAqLwogICAgICAgIC8vCiAgICAgICAgLy8gQm9ycm93IGEgcmVmZXJlbmNlIHRvIHRoZSBORlQgY29sbGVjdGlvbiwgY29uZmlndXJpbmcgaWYgbmVjZXNzYXJ5CiAgICAgICAgc2VsZi52aWV3UmVzb2x2ZXIgPSBnZXRBY2NvdW50KG5mdENvbnRyYWN0QWRkcmVzcykuY29udHJhY3RzLmJvcnJvdzwme1ZpZXdSZXNvbHZlcn0+KG5hbWU6IG5mdENvbnRyYWN0TmFtZSkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgVmlld1Jlc29sdmVyIGZyb20gTkZUIGNvbnRyYWN0IikKICAgICAgICBsZXQgY29sbGVjdGlvbkRhdGEgPSBzZWxmLnZpZXdSZXNvbHZlci5yZXNvbHZlQ29udHJhY3RWaWV3KAogICAgICAgICAgICAgICAgcmVzb3VyY2VUeXBlOiBuaWwsCiAgICAgICAgICAgICAgICB2aWV3VHlwZTogVHlwZTxNZXRhZGF0YVZpZXdzLk5GVENvbGxlY3Rpb25EYXRhPigpCiAgICAgICAgICAgICkgYXMhIE1ldGFkYXRhVmlld3MuTkZUQ29sbGVjdGlvbkRhdGE/ID8/IHBhbmljKCJDb3VsZCBub3QgcmVzb2x2ZSBORlRDb2xsZWN0aW9uRGF0YSB2aWV3IikKICAgICAgICB2YXIgY29sbGVjdGlvbiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzxhdXRoKE5vbkZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7Tm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9ufT4oCiAgICAgICAgICAgICAgICBmcm9tOiBjb2xsZWN0aW9uRGF0YS5zdG9yYWdlUGF0aAogICAgICAgICAgICApCgogICAgICAgIC8vIENyZWF0ZSBjb2xsZWN0aW9uIGlmIGl0IGRvZXNuJ3QgZXhpc3QKICAgICAgICBpZiBjb2xsZWN0aW9uID09IG5pbCB7CiAgICAgICAgICAgIHNpZ25lci5zdG9yYWdlLnNhdmUoPC0gY29sbGVjdGlvbkRhdGEuY3JlYXRlRW1wdHlDb2xsZWN0aW9uKCksIHRvOiBjb2xsZWN0aW9uRGF0YS5zdG9yYWdlUGF0aCkKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy51bnB1Ymxpc2goY29sbGVjdGlvbkRhdGEucHVibGljUGF0aCkKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5wdWJsaXNoKAogICAgICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5zdG9yYWdlLmlzc3VlPCZ7Tm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9ufT4oY29sbGVjdGlvbkRhdGEuc3RvcmFnZVBhdGgpLAogICAgICAgICAgICAgICAgYXQ6IGNvbGxlY3Rpb25EYXRhLnB1YmxpY1BhdGgKICAgICAgICAgICAgKQoKICAgICAgICAgICAgLy8gQm9ycm93IGF1dGhvcml6ZWQgd2l0aGRyYXcgcmVmZXJlbmNlIHRvIHRoZSBzaWduZXIncyBjb2xsZWN0aW9uCiAgICAgICAgICAgIGNvbGxlY3Rpb24gPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChOb25GdW5naWJsZVRva2VuLldpdGhkcmF3KSAme05vbkZ1bmdpYmxlVG9rZW4uQ29sbGVjdGlvbn0+KAogICAgICAgICAgICAgICAgZnJvbTogY29sbGVjdGlvbkRhdGEuc3RvcmFnZVBhdGgKICAgICAgICAgICAgKSEKICAgICAgICB9CgoKICAgICAgICBsZXQgY2FwVHlwZSA9IFR5cGU8YXV0aChOb25GdW5naWJsZVRva2VuLldpdGhkcmF3KSAme05vbkZ1bmdpYmxlVG9rZW4uUHJvdmlkZXJ9PigpCiAgICAgICAgbGV0IGNvbnRyb2xsZXJJRCA9IGNoaWxkQWNjdC5nZXRDb250cm9sbGVySURGb3JUeXBlKHR5cGU6IGNhcFR5cGUsIGZvclBhdGg6IGNvbGxlY3Rpb25EYXRhLnN0b3JhZ2VQYXRoKQogICAgICAgICAgICA/PyBwYW5pYygibm8gY29udHJvbGxlciBmb3VuZCBmb3IgY2FwVHlwZSIpCgogICAgICAgIGxldCBjYXAgPSBjaGlsZEFjY3QuZ2V0Q2FwYWJpbGl0eShjb250cm9sbGVySUQ6IGNvbnRyb2xsZXJJRCwgdHlwZTogY2FwVHlwZSkgPz8gcGFuaWMoIm5vIGNhcCBmb3VuZCIpCiAgICAgICAgbGV0IHByb3ZpZGVyQ2FwID0gY2FwIGFzISBDYXBhYmlsaXR5PGF1dGgoTm9uRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntOb25GdW5naWJsZVRva2VuLlByb3ZpZGVyfT4KICAgICAgICBhc3NlcnQocHJvdmlkZXJDYXAuY2hlY2soKSwgbWVzc2FnZTogImludmFsaWQgcHJvdmlkZXIgY2FwYWJpbGl0eSIpCgogICAgICAgIC8vIEdldCBhIHJlZmVyZW5jZSB0byB0aGUgY2hpbGQncyBzdG9yZWQgdmF1bHQKICAgICAgICBsZXQgY29sbGVjdGlvblJlZiA9IHByb3ZpZGVyQ2FwLmJvcnJvdygpIQogICAgICAgIGxldCBjaGlsZE5mdCA8LSBjb2xsZWN0aW9uUmVmLndpdGhkcmF3KHdpdGhkcmF3SUQ6IGlkKQogICAgICAgIGNvbGxlY3Rpb24hLmRlcG9zaXQodG9rZW46IDwtY2hpbGROZnQpCiAgICAgICAgLy8gLy8gV2l0aGRyYXcgdG9rZW5zIGZyb20gdGhlIHNpZ25lcidzIHN0b3JlZCB2YXVsdAogICAgICAgIGxldCBjdXJyZW50U3RvcmFnZVVzYWdlID0gc2lnbmVyLnN0b3JhZ2UudXNlZAogICAgICAgIHNlbGYubmZ0IDwtIGNvbGxlY3Rpb24hLndpdGhkcmF3KHdpdGhkcmF3SUQ6IGlkKQogICAgICAgIGxldCB3aXRoZHJhd25TdG9yYWdlVXNhZ2UgPSBzaWduZXIuc3RvcmFnZS51c2VkCiAgICAgICAgbGV0IGFwcHJveEZlZSA9IEZsb3dFVk1CcmlkZ2VVdGlscy5jYWxjdWxhdGVCcmlkZ2VGZWUoCiAgICAgICAgICAgICAgICBieXRlczogNDAwXzAwMAogICAgICAgICAgICApCgogICAgICAgIC8qIC0tLSBDb25maWd1cmUgYSBTY29wZWRGVFByb3ZpZGVyIC0tLSAqLwogICAgICAgIC8vCiAgICAgICAgLy8gSXNzdWUgYW5kIHN0b3JlIGJyaWRnZS1kZWRpY2F0ZWQgUHJvdmlkZXIgQ2FwYWJpbGl0eSBpbiBzdG9yYWdlIGlmIG5lY2Vzc2FyeQogICAgICAgIGlmIHNpZ25lci5zdG9yYWdlLnR5cGUoYXQ6IEZsb3dFVk1CcmlkZ2VDb25maWcucHJvdmlkZXJDYXBhYmlsaXR5U3RvcmFnZVBhdGgpID09IG5pbCB7CiAgICAgICAgICAgIGxldCBwcm92aWRlckNhcCA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+KAogICAgICAgICAgICAgICAgL3N0b3JhZ2UvZmxvd1Rva2VuVmF1bHQKICAgICAgICAgICAgKQogICAgICAgICAgICBzaWduZXIuc3RvcmFnZS5zYXZlKHByb3ZpZGVyQ2FwLCB0bzogRmxvd0VWTUJyaWRnZUNvbmZpZy5wcm92aWRlckNhcGFiaWxpdHlTdG9yYWdlUGF0aCkKICAgICAgICB9CgogICAgICAgIC8vIENvcHkgdGhlIHN0b3JlZCBQcm92aWRlciBjYXBhYmlsaXR5IGFuZCBjcmVhdGUgYSBTY29wZWRGVFByb3ZpZGVyCiAgICAgICAgbGV0IHByb3ZpZGVyQ2FwQ29weSA9IHNpZ25lci5zdG9yYWdlLmNvcHk8Q2FwYWJpbGl0eTxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+PigKICAgICAgICAgICAgICAgIGZyb206IEZsb3dFVk1CcmlkZ2VDb25maWcucHJvdmlkZXJDYXBhYmlsaXR5U3RvcmFnZVBhdGgKICAgICAgICAgICAgKSA/PyBwYW5pYygiSW52YWxpZCBQcm92aWRlciBDYXBhYmlsaXR5IGZvdW5kIGluIHN0b3JhZ2UuIikKICAgICAgICBsZXQgcHJvdmlkZXJGaWx0ZXIgPSBTY29wZWRGVFByb3ZpZGVycy5BbGxvd2FuY2VGaWx0ZXIoYXBwcm94RmVlKQogICAgICAgIHNlbGYuc2NvcGVkUHJvdmlkZXIgPC0gU2NvcGVkRlRQcm92aWRlcnMuY3JlYXRlU2NvcGVkRlRQcm92aWRlcigKICAgICAgICAgICAgICAgIHByb3ZpZGVyOiBwcm92aWRlckNhcENvcHksCiAgICAgICAgICAgICAgICBmaWx0ZXJzOiBbIHByb3ZpZGVyRmlsdGVyIF0sCiAgICAgICAgICAgICAgICBleHBpcmF0aW9uOiBnZXRDdXJyZW50QmxvY2soKS50aW1lc3RhbXAgKyAxLjAKICAgICAgICAgICAgKQogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIC8vIEV4ZWN1dGUgdGhlIGJyaWRnZQogICAgICAgIHNlbGYuY29hLmRlcG9zaXRORlQoCiAgICAgICAgICAgIG5mdDogPC0gc2VsZi5uZnQsCiAgICAgICAgICAgIGZlZVByb3ZpZGVyOiAmc2VsZi5zY29wZWRQcm92aWRlciBhcyBhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0KICAgICAgICApCgogICAgICAgIC8vIERlc3Ryb3kgdGhlIFNjb3BlZEZUUHJvdmlkZXIKICAgICAgICBkZXN0cm95IHNlbGYuc2NvcGVkUHJvdmlkZXIKCiAgICAgICAgLy8gV3JhcCBhbmQgdHJhbnNmZXIgTkZUcyBpZiBhcHBsaWNhYmxlCiAgICAgICAgd3JhcEFuZFRyYW5zZmVyTkZUc0lmQXBwbGljYWJsZShzZWxmLmNvYSwKICAgICAgICAgICAgbmZ0SURzOiBbaWRdLAogICAgICAgICAgICBuZnRUeXBlOiBzZWxmLm5mdFR5cGUsCiAgICAgICAgICAgIHZpZXdSZXNvbHZlcjogc2VsZi52aWV3UmVzb2x2ZXIsCiAgICAgICAgICAgIHJlY2lwaWVudElmTm90Q29hOiBFVk0uYWRkcmVzc0Zyb21TdHJpbmcocmVjaXBpZW50KQogICAgICAgICkKICAgIH0KfQoKLy8vIFdyYXBzIGFuZCB0cmFuc2ZlcnMgYnJpZGdlZCBORlRzIGludG8gYSBwcm9qZWN0J3MgY3VzdG9tIEVSQzcyMSB3cmFwcGVyIGNvbnRyYWN0IG9uIEVWTSwgaWYgYXBwbGljYWJsZS4KLy8vIEVuYWJsZXMgcHJvamVjdHMgdG8gdXNlIHRoZWlyIG93biBFUkM3MjEgY29udHJhY3Qgd2hpbGUgbGV2ZXJhZ2luZyB0aGUgYnJpZGdlJ3MgdW5kZXJseWluZyBjb250cmFjdCwKLy8vIHVudGlsIGRpcmVjdCBjdXN0b20gY29udHJhY3Qgc3VwcG9ydCBpcyBhZGRlZCB0byB0aGUgYnJpZGdlLgovLy8KLy8vIEBwYXJhbSBjb2E6IFRoZSBDT0Egb2YgdGhlIHNpZ25lcgovLy8gQHBhcmFtIG5mdElEczogVGhlIElEcyBvZiB0aGUgTkZUcyB0byB3cmFwCi8vLyBAcGFyYW0gbmZ0VHlwZTogVGhlIHR5cGUgb2YgdGhlIE5GVHMgdG8gd3JhcAovLy8gQHBhcmFtIHZpZXdSZXNvbHZlcjogVGhlIFZpZXdSZXNvbHZlciBvZiB0aGUgTkZUIGNvbnRyYWN0Ci8vLyBAcGFyYW0gcmVjaXBpZW50SWZOb3RDb2E6IFRoZSBFVk0gYWRkcmVzcyB0byB0cmFuc2ZlciB0aGUgd3JhcHBlZCBORlRzIHRvLCBuaWwgaWYgdGhlIE5GVHMgc2hvdWxkIHN0YXkgaW4gc2lnbmVyJ3MgQ09BCi8vLwphY2Nlc3MoYWxsKSBmdW4gd3JhcEFuZFRyYW5zZmVyTkZUc0lmQXBwbGljYWJsZSgKICAgIF8gY29hOiBhdXRoKEVWTS5DYWxsKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQsCiAgICBuZnRJRHM6IFtVSW50NjRdLAogICAgbmZ0VHlwZTogVHlwZSwKICAgIHZpZXdSZXNvbHZlcjogJntWaWV3UmVzb2x2ZXJ9LAogICAgcmVjaXBpZW50SWZOb3RDb2E6IEVWTS5FVk1BZGRyZXNzPwopIHsKICAgIC8vIEdldCB0aGUgcHJvamVjdC1kZWZpbmVkIEVSQzcyMSBhZGRyZXNzIGlmIGl0IGV4aXN0cwogICAgaWYgbGV0IGNyb3NzVk1Qb2ludGVyID0gdmlld1Jlc29sdmVyLnJlc29sdmVDb250cmFjdFZpZXcoCiAgICAgICAgICAgIHJlc291cmNlVHlwZTogbmZ0VHlwZSwKICAgICAgICAgICAgdmlld1R5cGU6IFR5cGU8Q3Jvc3NWTU1ldGFkYXRhVmlld3MuRVZNUG9pbnRlcj4oKQogICAgKSBhcyEgQ3Jvc3NWTU1ldGFkYXRhVmlld3MuRVZNUG9pbnRlcj8gewogICAgICAgIC8vIEdldCB0aGUgdW5kZXJseWluZyBFUkM3MjEgYWRkcmVzcyBpZiBpdCBleGlzdHMKICAgICAgICBpZiBsZXQgdW5kZXJseWluZ0FkZHJlc3MgPSBnZXRVbmRlcmx5aW5nRVJDNzIxQWRkcmVzcyhjb2EsIGNyb3NzVk1Qb2ludGVyLmV2bUNvbnRyYWN0QWRkcmVzcykgewogICAgICAgICAgICAvLyBXcmFwIE5GVHMgaWYgdW5kZXJseWluZyBFUkM3MjEgYWRkcmVzcyBtYXRjaGVzIGJyaWRnZSdzIGFzc29jaWF0ZWQgYWRkcmVzcyBmb3IgTkZUIHR5cGUKICAgICAgICAgICAgaWYgdW5kZXJseWluZ0FkZHJlc3MuZXF1YWxzKEZsb3dFVk1CcmlkZ2VDb25maWcuZ2V0RVZNQWRkcmVzc0Fzc29jaWF0ZWQod2l0aDogbmZ0VHlwZSkhKSB7CiAgICAgICAgICAgICAgICAvLyBBcHByb3ZlIGNvbnRyYWN0IHRvIHdpdGhkcmF3IHVuZGVybHlpbmcgTkZUcyBmcm9tIHNpZ25lcidzIGNvYQogICAgICAgICAgICAgICAgbXVzdENhbGwoY29hLCB1bmRlcmx5aW5nQWRkcmVzcywKICAgICAgICAgICAgICAgICAgICBmdW5jdGlvblNpZzogInNldEFwcHJvdmFsRm9yQWxsKGFkZHJlc3MsYm9vbCkiLAogICAgICAgICAgICAgICAgICAgIGFyZ3M6IFtjcm9zc1ZNUG9pbnRlci5ldm1Db250cmFjdEFkZHJlc3MsIHRydWVdCiAgICAgICAgICAgICAgICApCgogICAgICAgICAgICAgICAgLy8gV3JhcCBORlRzIHdpdGggcHJvdmlkZWQgSURzLCBhbmQgY2hlY2sgaWYgdGhlIGNhbGwgd2FzIHN1Y2Nlc3NmdWwKICAgICAgICAgICAgICAgIGxldCByZXMgPSBtdXN0Q2FsbChjb2EsIGNyb3NzVk1Qb2ludGVyLmV2bUNvbnRyYWN0QWRkcmVzcywKICAgICAgICAgICAgICAgICAgICBmdW5jdGlvblNpZzogImRlcG9zaXRGb3IoYWRkcmVzcyx1aW50MjU2W10pIiwKICAgICAgICAgICAgICAgICAgICBhcmdzOiBbY29hLmFkZHJlc3MoKSwgbmZ0SURzXQogICAgICAgICAgICAgICAgKQogICAgICAgICAgICAgICAgbGV0IGRlY29kZWRSZXMgPSBFVk0uZGVjb2RlQUJJKHR5cGVzOiBbVHlwZTxCb29sPigpXSwgZGF0YTogcmVzLmRhdGEpCiAgICAgICAgICAgICAgICBhc3NlcnQoZGVjb2RlZFJlcy5sZW5ndGggPT0gMSwgbWVzc2FnZTogIkludmFsaWQgcmVzcG9uc2UgbGVuZ3RoIikKICAgICAgICAgICAgICAgIGFzc2VydChkZWNvZGVkUmVzWzBdIGFzISBCb29sLCBtZXNzYWdlOiAiRmFpbGVkIHRvIHdyYXAgTkZUcyIpCgogICAgICAgICAgICAgICAgLy8gVHJhbnNmZXIgTkZUcyB0byByZWNpcGllbnQgaWYgcHJvdmlkZWQKICAgICAgICAgICAgICAgIGlmIGxldCB0byA9IHJlY2lwaWVudElmTm90Q29hIHsKICAgICAgICAgICAgICAgICAgICBtdXN0VHJhbnNmZXJORlRzKGNvYSwgY3Jvc3NWTVBvaW50ZXIuZXZtQ29udHJhY3RBZGRyZXNzLCBuZnRJRHM6IG5mdElEcywgdG86IHRvKQogICAgICAgICAgICAgICAgfQoKICAgICAgICAgICAgICAgIC8vIFJldm9rZSBhcHByb3ZhbCBmb3IgY29udHJhY3QgdG8gd2l0aGRyYXcgdW5kZXJseWluZyBORlRzIGZyb20gc2lnbmVyJ3MgY29hCiAgICAgICAgICAgICAgICBtdXN0Q2FsbChjb2EsIHVuZGVybHlpbmdBZGRyZXNzLAogICAgICAgICAgICAgICAgICAgIGZ1bmN0aW9uU2lnOiAic2V0QXBwcm92YWxGb3JBbGwoYWRkcmVzcyxib29sKSIsCiAgICAgICAgICAgICAgICAgICAgYXJnczogW2Nyb3NzVk1Qb2ludGVyLmV2bUNvbnRyYWN0QWRkcmVzcywgZmFsc2VdCiAgICAgICAgICAgICAgICApCiAgICAgICAgICAgIH0KICAgICAgICB9CiAgICB9Cn0KCi8vLyBHZXRzIHRoZSB1bmRlcmx5aW5nIEVSQzcyMSBhZGRyZXNzIGlmIGl0IGV4aXN0cyAoaS5lLiBpZiB0aGUgRVJDNzIxIGlzIGEgd3JhcHBlcikKLy8vCmFjY2VzcyhhbGwpIGZ1biBnZXRVbmRlcmx5aW5nRVJDNzIxQWRkcmVzcygKICAgIF8gY29hOiBhdXRoKEVWTS5DYWxsKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQsCiAgICBfIHdyYXBwZXJBZGRyZXNzOiBFVk0uRVZNQWRkcmVzcwopOiBFVk0uRVZNQWRkcmVzcz8gewogICAgbGV0IHJlcyA9IGNvYS5jYWxsKAogICAgICAgIHRvOiB3cmFwcGVyQWRkcmVzcywKICAgICAgICBkYXRhOiBFVk0uZW5jb2RlQUJJV2l0aFNpZ25hdHVyZSgidW5kZXJseWluZygpIiwgW10pLAogICAgICAgIGdhc0xpbWl0OiAxMDBfMDAwLAogICAgICAgIHZhbHVlOiBFVk0uQmFsYW5jZShhdHRvZmxvdzogMCkKICAgICkKCiAgICAvLyBJZiB0aGUgY2FsbCBmYWlscywgcmV0dXJuIG5pbAogICAgaWYgcmVzLnN0YXR1cyAhPSBFVk0uU3RhdHVzLnN1Y2Nlc3NmdWwgfHwgcmVzLmRhdGEubGVuZ3RoID09IDAgewogICAgICAgIHJldHVybiBuaWwKICAgIH0KCiAgICAvLyBEZWNvZGUgYW5kIHJldHVybiB0aGUgdW5kZXJseWluZyBFUkM3MjEgYWRkcmVzcwogICAgbGV0IGRlY29kZWRSZXN1bHQgPSBFVk0uZGVjb2RlQUJJKAogICAgICAgIHR5cGVzOiBbVHlwZTxFVk0uRVZNQWRkcmVzcz4oKV0sCiAgICAgICAgZGF0YTogcmVzLmRhdGEKICAgICkKICAgIGFzc2VydChkZWNvZGVkUmVzdWx0Lmxlbmd0aCA9PSAxLCBtZXNzYWdlOiAiSW52YWxpZCByZXNwb25zZSBsZW5ndGgiKQogICAgcmV0dXJuIGRlY29kZWRSZXN1bHRbMF0gYXMhIEVWTS5FVk1BZGRyZXNzCn0KCi8vLyBDaGVja3MgaWYgdGhlIHByb3ZpZGVkIE5GVCBpcyBvd25lZCBieSB0aGUgcHJvdmlkZWQgRVZNIGFkZHJlc3MKLy8vCmFjY2VzcyhhbGwpIGZ1biBpc093bmVyKAogICAgXyBjb2E6IGF1dGgoRVZNLkNhbGwpICZFVk0uQ2FkZW5jZU93bmVkQWNjb3VudCwKICAgIF8gZXJjNzIxQWRkcmVzczogRVZNLkVWTUFkZHJlc3MsCiAgICBfIG5mdElEOiBVSW50NjQsCiAgICBfIG93bmVyVG9DaGVjazogRVZNLkVWTUFkZHJlc3MKKTogQm9vbCB7CiAgICBsZXQgcmVzID0gY29hLmNhbGwoCiAgICAgICAgdG86IGVyYzcyMUFkZHJlc3MsCiAgICAgICAgZGF0YTogRVZNLmVuY29kZUFCSVdpdGhTaWduYXR1cmUoIm93bmVyT2YodWludDI1NikiLCBbbmZ0SURdKSwKICAgICAgICBnYXNMaW1pdDogMTAwXzAwMCwKICAgICAgICB2YWx1ZTogRVZNLkJhbGFuY2UoYXR0b2Zsb3c6IDApCiAgICApCiAgICBhc3NlcnQocmVzLnN0YXR1cyA9PSBFVk0uU3RhdHVzLnN1Y2Nlc3NmdWwsIG1lc3NhZ2U6ICJDYWxsIHRvIEVSQzcyMS5vd25lck9mKHVpbnQyNTYpIGZhaWxlZCIpCiAgICBsZXQgZGVjb2RlZFJlcyA9IEVWTS5kZWNvZGVBQkkodHlwZXM6IFtUeXBlPEVWTS5FVk1BZGRyZXNzPigpXSwgZGF0YTogcmVzLmRhdGEpCiAgICBpZiBkZWNvZGVkUmVzLmxlbmd0aCA9PSAxIHsKICAgICAgICBsZXQgYWN0dWFsT3duZXIgPSBkZWNvZGVkUmVzWzBdIGFzISBFVk0uRVZNQWRkcmVzcwogICAgICAgIHJldHVybiBhY3R1YWxPd25lci5lcXVhbHMob3duZXJUb0NoZWNrKQogICAgfQogICAgcmV0dXJuIGZhbHNlCn0KCi8vLyBUcmFuc2ZlcnMgTkZUcyBmcm9tIHRoZSBwcm92aWRlZCBDT0EgdG8gdGhlIHByb3ZpZGVkIEVWTSBhZGRyZXNzCi8vLwphY2Nlc3MoYWxsKSBmdW4gbXVzdFRyYW5zZmVyTkZUcygKICAgIF8gY29hOiBhdXRoKEVWTS5DYWxsKSAmRVZNLkNhZGVuY2VPd25lZEFjY291bnQsCiAgICBfIGVyYzcyMUFkZHJlc3M6IEVWTS5FVk1BZGRyZXNzLAogICAgbmZ0SURzOiBbVUludDY0XSwKICAgIHRvOiBFVk0uRVZNQWRkcmVzcwopIHsKICAgIGZvciBpZCBpbiBuZnRJRHMgewogICAgICAgIGFzc2VydChpc093bmVyKGNvYSwgZXJjNzIxQWRkcmVzcywgaWQsIGNvYS5hZGRyZXNzKCkpLCBtZXNzYWdlOiAiTkZUIG5vdCBvd25lZCBieSBzaWduZXIncyBDT0EiKQogICAgICAgIG11c3RDYWxsKGNvYSwgZXJjNzIxQWRkcmVzcywKICAgICAgICAgICAgZnVuY3Rpb25TaWc6ICJzYWZlVHJhbnNmZXJGcm9tKGFkZHJlc3MsYWRkcmVzcyx1aW50MjU2KSIsCiAgICAgICAgICAgIGFyZ3M6IFtjb2EuYWRkcmVzcygpLCB0bywgaWRdCiAgICAgICAgKQogICAgICAgIGFzc2VydChpc093bmVyKGNvYSwgZXJjNzIxQWRkcmVzcywgaWQsIHRvKSwgbWVzc2FnZTogIk5GVCBub3QgdHJhbnNmZXJyZWQgdG8gcmVjaXBpZW50IikKICAgIH0KfQoKLy8vIENhbGxzIGEgZnVuY3Rpb24gb24gYW4gRVZNIGNvbnRyYWN0IGZyb20gcHJvdmlkZWQgY29hCi8vLwphY2Nlc3MoYWxsKSBmdW4gbXVzdENhbGwoCiAgICBfIGNvYTogYXV0aChFVk0uQ2FsbCkgJkVWTS5DYWRlbmNlT3duZWRBY2NvdW50LAogICAgXyBjb250cmFjdEFkZHI6IEVWTS5FVk1BZGRyZXNzLAogICAgZnVuY3Rpb25TaWc6IFN0cmluZywKICAgIGFyZ3M6IFtBbnlTdHJ1Y3RdCik6IEVWTS5SZXN1bHQgewogICAgbGV0IHJlcyA9IGNvYS5jYWxsKAogICAgICAgIHRvOiBjb250cmFjdEFkZHIsCiAgICAgICAgZGF0YTogRVZNLmVuY29kZUFCSVdpdGhTaWduYXR1cmUoZnVuY3Rpb25TaWcsIGFyZ3MpLAogICAgICAgIGdhc0xpbWl0OiA0XzAwMF8wMDAsCiAgICAgICAgdmFsdWU6IEVWTS5CYWxhbmNlKGF0dG9mbG93OiAwKQogICAgKQoKICAgIGFzc2VydChyZXMuc3RhdHVzID09IEVWTS5TdGF0dXMuc3VjY2Vzc2Z1bCwKICAgICAgICBtZXNzYWdlOiAiRmFpbGVkIHRvIGNhbGwgJyIuY29uY2F0KGZ1bmN0aW9uU2lnKQogICAgICAgICAgICAuY29uY2F0KCJcblx0IGVycm9yIGNvZGU6ICIpLmNvbmNhdChyZXMuZXJyb3JDb2RlLnRvU3RyaW5nKCkpCiAgICAgICAgICAgIC5jb25jYXQoIlxuXHQgZXJyb3IgbWVzc2FnZTogIikuY29uY2F0KHJlcy5lcnJvck1lc3NhZ2UpCiAgICAgICAgICAgIC5jb25jYXQoIlxuXHQgZ2FzIHVzZWQ6ICIpLmNvbmNhdChyZXMuZ2FzVXNlZC50b1N0cmluZygpKQogICAgICAgICAgICAuY29uY2F0KCJcblx0IGNhbGxlciBhZGRyZXNzOiAweCIpLmNvbmNhdChjb2EuYWRkcmVzcygpLnRvU3RyaW5nKCkpCiAgICAgICAgICAgIC5jb25jYXQoIlxuXHQgY29udHJhY3QgYWRkcmVzczogMHgiKS5jb25jYXQoY29udHJhY3RBZGRyLnRvU3RyaW5nKCkpCiAgICApCgogICAgcmV0dXJuIHJlcwp9Cg\u003d\u003d", + "checkChildLinkedCollections": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY2hlY2tDaGlsZExpbmtlZENvbGxlY3Rpb25zIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgSHlicmlkQ3VzdG9keSBmcm9tIDB4Mjk0ZTQ0ZTFlYzY5OTNjNgoKaW1wb3J0IENhcGFiaWxpdHlGaWx0ZXIgZnJvbSAweDI5NGU0NGUxZWM2OTkzYzYKCmltcG9ydCBOb25GdW5naWJsZVRva2VuIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgoKYWNjZXNzKGFsbCkgZnVuIG1haW4ocGFyZW50OiBBZGRyZXNzLCBjaGlsZDogQWRkcmVzcywgaWRlbnRpZmllcjogU3RyaW5nKTogQm9vbCB7CiAgICBsZXQgbWdyID0gZ2V0QXV0aEFjY291bnQocGFyZW50KS5ib3Jyb3c8Jkh5YnJpZEN1c3RvZHkuTWFuYWdlcj4oZnJvbTogSHlicmlkQ3VzdG9keS5NYW5hZ2VyU3RvcmFnZVBhdGgpCiAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgbWFuYWdlciBmcm9tIHBhcmVudCIpCiAgICBsZXQgY2hpbGQgPSBtZ3IuYm9ycm93QWNjb3VudChhZGRyOiBjaGlsZCkgPz8gcGFuaWMoIkNoaWxkIGFjY291bnQgbm90IGZvdW5kIikKCiAgICBsZXQgY2FwID0gY2hpbGQuZ2V0Q2FwYWJpbGl0eSgKICAgICAgICAgICAgcGF0aDogUHJpdmF0ZVBhdGgoaWRlbnRpZmllcjogaWRlbnRpZmllcikhIGFzIENhcGFiaWxpdHlQYXRoLAogICAgICAgICAgICB0eXBlOiBUeXBlPCZ7Tm9uRnVuZ2libGVUb2tlbi5Qcm92aWRlciwgTm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9uUHVibGljfT4oKQogICAgICAgICkgYXMhIENhcGFiaWxpdHk8JntOb25GdW5naWJsZVRva2VuLlByb3ZpZGVyLCBOb25GdW5naWJsZVRva2VuLkNvbGxlY3Rpb25QdWJsaWN9Pj8KCiAgICAKICAgIHJldHVybiBjYXAgIT0gbmlsCn0gICAKICAgIA\u003d\u003d", + "checkChildLinkedVaults": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY2hlY2tDaGlsZExpbmtlZFZhdWx0cyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEh5YnJpZEN1c3RvZHkgZnJvbSAweDI5NGU0NGUxZWM2OTkzYzYKCmltcG9ydCBDYXBhYmlsaXR5RmlsdGVyIGZyb20gMHgyOTRlNDRlMWVjNjk5M2M2CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKHBhcmVudDogQWRkcmVzcywgY2hpbGQ6IEFkZHJlc3MsIHBhdGg6IFN0cmluZyk6IEJvb2wgewogIGxldCBhY2NvdW50ID0gZ2V0QXV0aEFjY291bnQ8YXV0aChTdG9yYWdlKSAmQWNjb3VudD4ocGFyZW50KQogIGxldCBtYW5hZ2VyID0gZ2V0QXV0aEFjY291bnQ8YXV0aChTdG9yYWdlKSAmQWNjb3VudD4ocGFyZW50KS5zdG9yYWdlLmJvcnJvdzxhdXRoKEh5YnJpZEN1c3RvZHkuTWFuYWdlKSAmSHlicmlkQ3VzdG9keS5NYW5hZ2VyPihmcm9tOiBIeWJyaWRDdXN0b2R5Lk1hbmFnZXJTdG9yYWdlUGF0aCkgPz8gcGFuaWMgKCJtYW5hZ2VyIGRvZXMgbm90IGV4aXN0IikKICAKICBsZXQgcHJvdmlkZXJUeXBlID0gVHlwZTxhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+KCkKCiAgbGV0IGFkZHIgPSBnZXRBdXRoQWNjb3VudDxhdXRoKFN0b3JhZ2UsIENhcGFiaWxpdGllcykgJkFjY291bnQ+KGNoaWxkKQogIAogIGxldCBjaGlsZEFjY3QgPSBtYW5hZ2VyLmJvcnJvd0FjY291bnQoYWRkcjogY2hpbGQpID8/IHBhbmljKCJjaGlsZCBhY2NvdW50IG5vdCBmb3VuZCIpCgogIGxldCBjb250cm9sbGVycyA9IGFkZHIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuZ2V0Q29udHJvbGxlcnMoZm9yUGF0aDogU3RvcmFnZVBhdGgoaWRlbnRpZmllcjogcGF0aCkhKQogIHZhciBmbGFnID0gZmFsc2UKCiAgZm9yIGMgaW4gY29udHJvbGxlcnMgewogICAgaWYgIWMuYm9ycm93VHlwZS5pc1N1YnR5cGUob2Y6IHByb3ZpZGVyVHlwZSkgewogICAgICBjb250aW51ZQogICAgfQoKICAgIGlmIGxldCBjYXAgPSBjaGlsZEFjY3QuZ2V0Q2FwYWJpbGl0eShjb250cm9sbGVySUQ6IGMuY2FwYWJpbGl0eUlELCB0eXBlOiBwcm92aWRlclR5cGUpIHsKICAgICAgbGV0IHByb3ZpZGVyQ2FwID0gY2FwIGFzISBDYXBhYmlsaXR5PCZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+IAoKICAgICAgaWYgIXByb3ZpZGVyQ2FwLmNoZWNrKCl7CiAgICAgICAgY29udGludWUKICAgICAgfQoKICAgICAgZmxhZyA9IHRydWUKICAgICAgYnJlYWsKICAgIH0KICB9CgogIHJldHVybiBmbGFnCn0gCiAgICA\u003d", + "checkChildRecieveVaults": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY2hlY2tDaGlsZFJlY2lldmVWYXVsdHMgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBIeWJyaWRDdXN0b2R5IGZyb20gMHgyOTRlNDRlMWVjNjk5M2M2CgppbXBvcnQgQ2FwYWJpbGl0eUZpbHRlciBmcm9tIDB4Mjk0ZTQ0ZTFlYzY5OTNjNgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihwYXJlbnQ6IEFkZHJlc3MsIGNoaWxkOiBBZGRyZXNzLCBwYXRoOiBTdHJpbmcpOiBCb29sIHsKICBsZXQgYWNjb3VudCA9IGdldEF1dGhBY2NvdW50PGF1dGgoU3RvcmFnZSkgJkFjY291bnQ+KHBhcmVudCkKICBsZXQgbWFuYWdlciA9IGdldEF1dGhBY2NvdW50PGF1dGgoU3RvcmFnZSkgJkFjY291bnQ+KHBhcmVudCkuc3RvcmFnZS5ib3Jyb3c8YXV0aChIeWJyaWRDdXN0b2R5Lk1hbmFnZSkgJkh5YnJpZEN1c3RvZHkuTWFuYWdlcj4oZnJvbTogSHlicmlkQ3VzdG9keS5NYW5hZ2VyU3RvcmFnZVBhdGgpID8/IHBhbmljICgibWFuYWdlciBkb2VzIG5vdCBleGlzdCIpCiAgCiAgbGV0IHJlY2VpdmVyVHlwZSA9IFR5cGU8JntGdW5naWJsZVRva2VuLlJlY2VpdmVyfT4oKQoKICBsZXQgYWRkciA9IGdldEF1dGhBY2NvdW50PGF1dGgoU3RvcmFnZSwgQ2FwYWJpbGl0aWVzKSAmQWNjb3VudD4oY2hpbGQpCiAgCiAgbGV0IGNoaWxkQWNjdCA9IG1hbmFnZXIuYm9ycm93QWNjb3VudChhZGRyOiBjaGlsZCkgPz8gcGFuaWMoImNoaWxkIGFjY291bnQgbm90IGZvdW5kIikKCiAgbGV0IGNvbnRyb2xsZXJzID0gYWRkci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5nZXRDb250cm9sbGVycyhmb3JQYXRoOiBTdG9yYWdlUGF0aChpZGVudGlmaWVyOiBwYXRoKSEpCiAgdmFyIGZsYWcgPSBmYWxzZQoKICBmb3IgYyBpbiBjb250cm9sbGVycyB7CiAgICBpZiAhYy5ib3Jyb3dUeXBlLmlzU3VidHlwZShvZjogcmVjZWl2ZXJUeXBlKSB7CiAgICAgIGNvbnRpbnVlCiAgICB9CgogICAgaWYgbGV0IGNhcCA9IGNoaWxkQWNjdC5nZXRDYXBhYmlsaXR5KGNvbnRyb2xsZXJJRDogYy5jYXBhYmlsaXR5SUQsIHR5cGU6IHJlY2VpdmVyVHlwZSkgewogICAgICBsZXQgcHJvdmlkZXJDYXAgPSBjYXAgYXMhIENhcGFiaWxpdHk8JntGdW5naWJsZVRva2VuLlJlY2VpdmVyfT4gCgogICAgICBpZiAhcHJvdmlkZXJDYXAuY2hlY2soKXsKICAgICAgICBjb250aW51ZQogICAgICB9CgogICAgICBmbGFnID0gdHJ1ZQogICAgICBicmVhawogICAgfQogIH0KCiAgcmV0dXJuIGZsYWcKfSAKICAgIA\u003d\u003d", + "editChildAccount": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZWRpdENoaWxkQWNjb3VudCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEh5YnJpZEN1c3RvZHkgZnJvbSAweDI5NGU0NGUxZWM2OTkzYzYKCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgoKdHJhbnNhY3Rpb24oY2hpbGRBZGRyZXNzOiBBZGRyZXNzLCBuYW1lOiBTdHJpbmcsIGRlc2NyaXB0aW9uOiBTdHJpbmcsIHRodW1ibmFpbDogU3RyaW5nKSB7CiAgICBwcmVwYXJlKGFjY3Q6IEF1dGhBY2NvdW50KSB7CiAgICAgICAgbGV0IG0gPSBhY2N0LmJvcnJvdzwmSHlicmlkQ3VzdG9keS5NYW5hZ2VyPihmcm9tOiBIeWJyaWRDdXN0b2R5Lk1hbmFnZXJTdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIm1hbmFnZXIgbm90IGZvdW5kIikKICAgICAgICAKICAgICAgICBsZXQgZCA9IE1ldGFkYXRhVmlld3MuRGlzcGxheSgKICAgICAgICAgICAgbmFtZTogbmFtZSwKICAgICAgICAgICAgZGVzY3JpcHRpb246IGRlc2NyaXB0aW9uLAogICAgICAgICAgICB0aHVtYm5haWw6IE1ldGFkYXRhVmlld3MuSFRUUEZpbGUodXJsOiB0aHVtYm5haWwpCiAgICAgICAgKQoKICAgICAgICBtLnNldENoaWxkQWNjb3VudERpc3BsYXkoYWRkcmVzczogY2hpbGRBZGRyZXNzLCBkKQogICAgfQp9", + "getAccessibleChildAccountNFTs": "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\u003d", + "getAccessibleCoinInfo": "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", + "getAccessibleCollectionAndIdsDisplay": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QWNjZXNzaWJsZUNvbGxlY3Rpb25BbmRJZHNEaXNwbGF5IC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgSHlicmlkQ3VzdG9keSBmcm9tIDB4Mjk0ZTQ0ZTFlYzY5OTNjNgoKaW1wb3J0IE1ldGFkYXRhVmlld3MgZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCmltcG9ydCBWaWV3UmVzb2x2ZXIgZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4NjMxZTg4YWU3ZjFkN2MyMAoKCgphY2Nlc3MoYWxsKSBzdHJ1Y3QgQ29sbGVjdGlvbkRpc3BsYXkgewogIGFjY2VzcyhhbGwpIGxldCBuYW1lOiBTdHJpbmcKICBhY2Nlc3MoYWxsKSBsZXQgc3F1YXJlSW1hZ2U6IE1ldGFkYXRhVmlld3MuTWVkaWEKCiAgaW5pdChuYW1lOiBTdHJpbmcsIHNxdWFyZUltYWdlOiBNZXRhZGF0YVZpZXdzLk1lZGlhKSB7CiAgICBzZWxmLm5hbWUgPSBuYW1lCiAgICBzZWxmLnNxdWFyZUltYWdlID0gc3F1YXJlSW1hZ2UKICB9Cn0KCmFjY2VzcyhhbGwpIHN0cnVjdCBORlRDb2xsZWN0aW9uIHsKICBhY2Nlc3MoYWxsKSBsZXQgaWQ6IFN0cmluZwogIGFjY2VzcyhhbGwpIGxldCBkaXNwbGF5OiBDb2xsZWN0aW9uRGlzcGxheT8KICBhY2Nlc3MoYWxsKSBsZXQgaWRMaXN0OiBbVUludDY0XQoKICBpbml0KGlkOlN0cmluZywgZGlzcGxheTogQ29sbGVjdGlvbkRpc3BsYXk/LCBpZExpc3Q6IFtVSW50NjRdKSB7CiAgICBzZWxmLmlkID0gaWQKICAgIHNlbGYuZGlzcGxheSA9IGRpc3BsYXkKICAgIHNlbGYuaWRMaXN0ID0gaWRMaXN0CiAgfQp9CgoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKHBhcmVudDogQWRkcmVzcywgY2hpbGRBY2NvdW50OiBBZGRyZXNzKTogW05GVENvbGxlY3Rpb25dIHsKICAgIGxldCBtYW5hZ2VyID0gZ2V0QXV0aEFjY291bnQ8YXV0aChTdG9yYWdlKSAmQWNjb3VudD4ocGFyZW50KS5zdG9yYWdlLmJvcnJvdzxhdXRoKEh5YnJpZEN1c3RvZHkuTWFuYWdlKSAmSHlicmlkQ3VzdG9keS5NYW5hZ2VyPihmcm9tOiBIeWJyaWRDdXN0b2R5Lk1hbmFnZXJTdG9yYWdlUGF0aCkgPz8gcGFuaWMgKCJtYW5hZ2VyIGRvZXMgbm90IGV4aXN0IikKCiAgICAvLyBBZGRyZXNzIC0+IENvbGxlY3Rpb24gVHlwZSAtPiBvd25lZE5GVHMKCiAgICBsZXQgcHJvdmlkZXJUeXBlID0gVHlwZTxhdXRoKE5vbkZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7Tm9uRnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+KCkKICAgIGxldCBjb2xsZWN0aW9uVHlwZTogVHlwZSA9IFR5cGU8QHtOb25GdW5naWJsZVRva2VuLkNvbGxlY3Rpb25QdWJsaWN9PigpCgogICAgLy8gSXRlcmF0ZSB0aHJvdWdoIGNoaWxkIGFjY291bnRzCgogICAgbGV0IGFjY3QgPSBnZXRBdXRoQWNjb3VudDxhdXRoKFN0b3JhZ2UsIENhcGFiaWxpdGllcykgJkFjY291bnQ+KGNoaWxkQWNjb3VudCkKICAgIGxldCBmb3VuZFR5cGVzOiBbVHlwZV0gPSBbXQogICAgLy8gbGV0IG5mdHM6IHtTdHJpbmc6IFtVSW50NjRdfSA9IHt9CiAgICBsZXQgY29sbGVjdGlvbkxpc3Q6IFtORlRDb2xsZWN0aW9uXSA9IFtdCiAgICBsZXQgY2hpbGRBY2N0ID0gbWFuYWdlci5ib3Jyb3dBY2NvdW50KGFkZHI6IGNoaWxkQWNjb3VudCkgPz8gcGFuaWMoImNoaWxkIGFjY291bnQgbm90IGZvdW5kIikKICAgIAogICAgLy8gZ2V0IGFsbCBwcml2YXRlIHBhdGhzCiAgICBhY2N0LnN0b3JhZ2UuZm9yRWFjaFN0b3JlZChmdW4gKHBhdGg6IFN0b3JhZ2VQYXRoLCB0eXBlOiBUeXBlKTogQm9vbCB7CgogICAgICAgIGxldCBjb250cm9sbGVycyA9IGFjY3QuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuZ2V0Q29udHJvbGxlcnMoZm9yUGF0aDogcGF0aCEpCiAgICAgICAgZm9yIGMgaW4gY29udHJvbGxlcnMgewogICAgICAgICAgaWYgIWMuYm9ycm93VHlwZS5pc1N1YnR5cGUob2Y6IHByb3ZpZGVyVHlwZSkgewogICAgICAgICAgICBjb250aW51ZQogICAgICAgICAgfQoKICAgICAgICAgIGlmIGxldCBjYXAgPSBjaGlsZEFjY3QuZ2V0Q2FwYWJpbGl0eShjb250cm9sbGVySUQ6IGMuY2FwYWJpbGl0eUlELCB0eXBlOiBwcm92aWRlclR5cGUpIHsKICAgICAgICAgICAgbGV0IHByb3ZpZGVyQ2FwID0gY2FwIGFzISBDYXBhYmlsaXR5PCZ7Tm9uRnVuZ2libGVUb2tlbi5Qcm92aWRlcn0+IAoKICAgICAgICAgICAgaWYgIXByb3ZpZGVyQ2FwLmNoZWNrKCl7CiAgICAgICAgICAgICAgY29udGludWUKICAgICAgICAgICAgfQogICAgICAgICAgICBmb3VuZFR5cGVzLmFwcGVuZChjYXAuYm9ycm93PCZBbnlSZXNvdXJjZT4oKSEuZ2V0VHlwZSgpKQogICAgICAgICAgfQogICAgICAgIH0KICAgICAgICByZXR1cm4gdHJ1ZQogICAgfSkKCiAgICAvLyBpdGVyYXRlIHN0b3JhZ2UsIGNoZWNrIGlmIHR5cGVJZHNXaXRoUHJvdmlkZXIgY29udGFpbnMgdGhlIHR5cGVJZCwgaWYgc28sIGFkZCB0byBuZnRzCiAgICBhY2N0LnN0b3JhZ2UuZm9yRWFjaFN0b3JlZChmdW4gKHBhdGg6IFN0b3JhZ2VQYXRoLCB0eXBlOiBUeXBlKTogQm9vbCB7CgogICAgICAgIGlmIGZvdW5kVHlwZXMgPT0gbmlsIHsKICAgICAgICAgICAgcmV0dXJuIHRydWUKICAgICAgICB9CgogICAgICAgIGZvciBpZHgsIHZhbHVlIGluIGZvdW5kVHlwZXMgewogICAgICAgICAgICBsZXQgdmFsdWUgPSBmb3VuZFR5cGVzIQoKICAgICAgICAgICAgaWYgdmFsdWVbaWR4XSAhPSB0eXBlIHsKICAgICAgICAgICAgICAgIGNvbnRpbnVlCiAgICAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAgICBpZiB0eXBlLmlzSW5zdGFuY2UoY29sbGVjdGlvblR5cGUpIHsKICAgICAgICAgICAgICAgICAgICBjb250aW51ZQogICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgaWYgbGV0IGNvbGxlY3Rpb24gPSBhY2N0LnN0b3JhZ2UuYm9ycm93PCZ7Tm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9uUHVibGljLCBWaWV3UmVzb2x2ZXIuUmVzb2x2ZXJDb2xsZWN0aW9ufT4oZnJvbTogcGF0aCkgeyAKICAgICAgICAgICAgICAgICAgICAvLyBuZnRzLmluc2VydChrZXk6IHR5cGUuaWRlbnRpZmllciwgY29sbGVjdGlvbi5nZXRJRHMoKSkKICAgICAgICAgICAgICAgICAgICBsZXQgaWRzID0gY29sbGVjdGlvbi5nZXRJRHMoKQogICAgICAgICAgICAgICAgICAgIGlmIGlkcy5sZW5ndGggPiAwIHsKICAgICAgICAgICAgICAgICAgICAgIHZhciBkaXNwbGF5IDogQ29sbGVjdGlvbkRpc3BsYXk/ID0gbmlsCiAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgIGxldCByZXNvbHZlciA9IGNvbGxlY3Rpb24uYm9ycm93Vmlld1Jlc29sdmVyKGlkOiBpZHNbMF0pCiAgICAgICAgICAgICAgICAgICAgICBpZiByZXNvbHZlciAhPSBuaWwgewogICAgICAgICAgICAgICAgICAgICAgICBsZXQgZGlzID0gTWV0YWRhdGFWaWV3cy5nZXRORlRDb2xsZWN0aW9uRGlzcGxheShyZXNvbHZlciEpIQogICAgICAgICAgICAgICAgICAgICAgICBkaXNwbGF5ID0gQ29sbGVjdGlvbkRpc3BsYXkobmFtZTogZGlzLm5hbWUsc3F1YXJlSW1hZ2U6IGRpcy5zcXVhcmVJbWFnZSApCiAgICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgICBjb2xsZWN0aW9uTGlzdC5hcHBlbmQoCiAgICAgICAgICAgICAgICAgICAgICAgIE5GVENvbGxlY3Rpb24oCiAgICAgICAgICAgICAgICAgICAgICAgICAgaWQ6IHR5cGUuaWRlbnRpZmllciwKICAgICAgICAgICAgICAgICAgICAgICAgICBkaXNwbGF5OiBkaXNwbGF5LAogICAgICAgICAgICAgICAgICAgICAgICAgIGlkTGlzdDogY29sbGVjdGlvbi5nZXRJRHMoKQogICAgICAgICAgICAgICAgICAgICAgICApCiAgICAgICAgICAgICAgICAgICAgICApCiAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgY29udGludWUKICAgICAgICAgICAgfQogICAgICAgIH0KICAgICAgICByZXR1cm4gdHJ1ZQogICAgfSkKCiAgICByZXR1cm4gY29sbGVjdGlvbkxpc3QKfQ\u003d\u003d", + "getChildAccountAllowTypes": "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\u003d\u003d", + "getChildAccountFTCapabilities": "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\u003d\u003d", + "getChildAccountMeta": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0Q2hpbGRBY2NvdW50TWV0YSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEh5YnJpZEN1c3RvZHkgZnJvbSAweDI5NGU0NGUxZWM2OTkzYzYKCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgoKYWNjZXNzKGFsbCkgZnVuIG1haW4ocGFyZW50OiBBZGRyZXNzKToge0FkZHJlc3M6IEFueVN0cnVjdH0gewogICAgbGV0IGFjY3QgPSBnZXRBdXRoQWNjb3VudDxhdXRoKFN0b3JhZ2UpICZBY2NvdW50PihwYXJlbnQpCiAgICBsZXQgbSA9IGFjY3Quc3RvcmFnZS5ib3Jyb3c8Jkh5YnJpZEN1c3RvZHkuTWFuYWdlcj4oZnJvbTogSHlicmlkQ3VzdG9keS5NYW5hZ2VyU3RvcmFnZVBhdGgpCgogICAgaWYgbSA9PSBuaWwgewogICAgICAgIHJldHVybiB7fQogICAgfSBlbHNlIHsKICAgICAgICB2YXIgZGF0YToge0FkZHJlc3M6IEFueVN0cnVjdH0gPSB7fQogICAgICAgIGZvciBhZGRyZXNzIGluIG0/LmdldENoaWxkQWRkcmVzc2VzKCkhIHsKICAgICAgICAgICAgbGV0IGMgPSBtPy5nZXRDaGlsZEFjY291bnREaXNwbGF5KGFkZHJlc3M6IGFkZHJlc3MpIAogICAgICAgICAgICBkYXRhLmluc2VydChrZXk6IGFkZHJlc3MsIGMpCiAgICAgICAgfQogICAgICAgIHJldHVybiBkYXRhCiAgICB9Cn0\u003d", + "getChildAddresses": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0Q2hpbGRBZGRyZXNzZXMgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBIeWJyaWRDdXN0b2R5IGZyb20gMHgyOTRlNDRlMWVjNjk5M2M2CgoKYWNjZXNzKGFsbCkgZnVuIG1haW4ocGFyZW50OiBBZGRyZXNzKTogW0FkZHJlc3NdIHsKICAgIGxldCBhY2N0ID0gZ2V0QXV0aEFjY291bnQ8YXV0aChTdG9yYWdlKSAmQWNjb3VudD4ocGFyZW50KQogICAgbGV0IG1hbmFnZXIgPSBhY2N0LnN0b3JhZ2UuYm9ycm93PCZIeWJyaWRDdXN0b2R5Lk1hbmFnZXI+KGZyb206IEh5YnJpZEN1c3RvZHkuTWFuYWdlclN0b3JhZ2VQYXRoKQogICAgICAgID8/IHBhbmljKCJtYW5hZ2VyIG5vdCBmb3VuZCIpCiAgICByZXR1cm4gIG1hbmFnZXIuZ2V0Q2hpbGRBZGRyZXNzZXMoKQp9", + "getExamplenftCollectionFromDelegator": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0RXhhbXBsZW5mdENvbGxlY3Rpb25Gcm9tRGVsZWdhdG9yIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgSHlicmlkQ3VzdG9keSBmcm9tIDB4Mjk0ZTQ0ZTFlYzY5OTNjNgoKCmltcG9ydCBOb25GdW5naWJsZVRva2VuIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgppbXBvcnQgPFRva2VuPiBmcm9tIDxUb2tlbkFkZHJlc3M+CgphY2Nlc3MoYWxsKSBmdW4gbWFpbihwYXJlbnQ6IEFkZHJlc3MsIGNoaWxkOiBBZGRyZXNzLCBpc1B1YmxpYzogQm9vbCkgewogICAgbGV0IG0gPSBnZXRBdXRoQWNjb3VudDxhdXRoKFN0b3JhZ2UpICZBY2NvdW50PihwYXJlbnQpLnN0b3JhZ2UuYm9ycm93PGF1dGgoSHlicmlkQ3VzdG9keS5NYW5hZ2UpICZIeWJyaWRDdXN0b2R5Lk1hbmFnZXI+KGZyb206IEh5YnJpZEN1c3RvZHkuTWFuYWdlclN0b3JhZ2VQYXRoKQogICAgICAgID8/IHBhbmljKCJtYW5hZ2VyIG5vdCBmb3VuZCIpCiAgICBsZXQgYWNjdCA9IG0uYm9ycm93QWNjb3VudChhZGRyOiBjaGlsZCkKICAgICAgICA/PyBwYW5pYygiY2hpbGQgYWNjb3VudCBub3QgZm91bmQgaW4gbWFuYWdlciIpCgogICAgbGV0IHQgPSBUeXBlPENhcGFiaWxpdHk8JkV4YW1wbGVORlQuQ29sbGVjdGlvbj4+KCkKCiAgICBsZXQgY2FwID0gKGlzUHVibGljID8gYWNjdC5nZXRQdWJsaWNDYXBGcm9tRGVsZWdhdG9yKHR5cGU6IHQpIDogYWNjdC5nZXRQcml2YXRlQ2FwRnJvbURlbGVnYXRvcih0eXBlOiB0KSkKICAgICAgICA/PyBwYW5pYygiY2FwYWJpbGl0eSBub3QgZm91bmQiKQogICAgCiAgICBhc3NlcnQoY2FwLmdldFR5cGUoKSA9PSB0LCBtZXNzYWdlOiAibWlzbWF0Y2hlZCBjYXBhYmlsaXR5IHR5cGVzIikKfQ\u003d\u003d", + "publishToParent": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcHVibGlzaFRvUGFyZW50IC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgojYWxsb3dBY2NvdW50TGlua2luZwoKaW1wb3J0IEh5YnJpZEN1c3RvZHkgZnJvbSAweDI5NGU0NGUxZWM2OTkzYzYKCmltcG9ydCBDYXBhYmlsaXR5RmFjdG9yeSBmcm9tIDB4Mjk0ZTQ0ZTFlYzY5OTNjNgoKaW1wb3J0IENhcGFiaWxpdHlGaWx0ZXIgZnJvbSAweDI5NGU0NGUxZWM2OTkzYzYKCmltcG9ydCBDYXBhYmlsaXR5RGVsZWdhdG9yIGZyb20gMHgyOTRlNDRlMWVjNjk5M2M2CgoKdHJhbnNhY3Rpb24ocGFyZW50OiBBZGRyZXNzLCBmYWN0b3J5QWRkcmVzczogQWRkcmVzcywgZmlsdGVyQWRkcmVzczogQWRkcmVzcykgewogICAgcHJlcGFyZShhY2N0OiBhdXRoKFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IG93bmVkID0gYWNjdC5zdG9yYWdlLmJvcnJvdzxhdXRoKEh5YnJpZEN1c3RvZHkuT3duZXIpICZIeWJyaWRDdXN0b2R5Lk93bmVkQWNjb3VudD4oZnJvbTogSHlicmlkQ3VzdG9keS5Pd25lZEFjY291bnRTdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIm93bmVkIGFjY291bnQgbm90IGZvdW5kIikKCiAgICAgICAgbGV0IGZhY3RvcnkgPSBnZXRBY2NvdW50KGZhY3RvcnlBZGRyZXNzKS5jYXBhYmlsaXRpZXMuZ2V0PCZDYXBhYmlsaXR5RmFjdG9yeS5NYW5hZ2VyPihDYXBhYmlsaXR5RmFjdG9yeS5QdWJsaWNQYXRoKQogICAgICAgIGFzc2VydChmYWN0b3J5LmNoZWNrKCksIG1lc3NhZ2U6ICJmYWN0b3J5IGFkZHJlc3MgaXMgbm90IGNvbmZpZ3VyZWQgcHJvcGVybHkiKQoKICAgICAgICBsZXQgZmlsdGVyID0gZ2V0QWNjb3VudChmaWx0ZXJBZGRyZXNzKS5jYXBhYmlsaXRpZXMuZ2V0PCZ7Q2FwYWJpbGl0eUZpbHRlci5GaWx0ZXJ9PihDYXBhYmlsaXR5RmlsdGVyLlB1YmxpY1BhdGgpCiAgICAgICAgYXNzZXJ0KGZpbHRlci5jaGVjaygpLCBtZXNzYWdlOiAiY2FwYWJpbGl0eSBmaWx0ZXIgaXMgbm90IGNvbmZpZ3VyZWQgcHJvcGVybHkiKQoKICAgICAgICBvd25lZC5wdWJsaXNoVG9QYXJlbnQocGFyZW50QWRkcmVzczogcGFyZW50LCBmYWN0b3J5OiBmYWN0b3J5LCBmaWx0ZXI6IGZpbHRlcikKICAgIH0KfQ\u003d\u003d", + "redeemAccount": "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\u003d\u003d", + "sendChildFT": "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\u003d", + "sendChildFTToChild": "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", + "sendChildFTWithParent": "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\u003d", + "sendChildNFT": "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", + "sendChildNFTToChild": "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", + "setupOwnedAccount": "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", + "setupOwnedAccountAndPublishToParent": "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", + "transferChildFT": "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\u003d\u003d", + "transferChildNFT": "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\u003d\u003d", + "transferNFTToChild": "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", + "unlinkChildAccount": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdW5saW5rQ2hpbGRBY2NvdW50IC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgSHlicmlkQ3VzdG9keSBmcm9tIDB4Mjk0ZTQ0ZTFlYzY5OTNjNgoKCnRyYW5zYWN0aW9uKGNoaWxkOiBBZGRyZXNzKSB7CiAgICBwcmVwYXJlIChhY2N0OiBhdXRoKFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IG1hbmFnZXIgPSBhY2N0LnN0b3JhZ2UuYm9ycm93PGF1dGgoSHlicmlkQ3VzdG9keS5NYW5hZ2UpICZIeWJyaWRDdXN0b2R5Lk1hbmFnZXI+KGZyb206IEh5YnJpZEN1c3RvZHkuTWFuYWdlclN0b3JhZ2VQYXRoKQogICAgICAgICAgICA/PyBwYW5pYygibWFuYWdlciBub3QgZm91bmQiKQogICAgICAgIG1hbmFnZXIucmVtb3ZlQ2hpbGQoYWRkcjogY2hpbGQpCiAgICB9Cn0\u003d" }, "lostAndFound": { - "claimFT": "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\u003d\u003d", - "claimNFT": "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\u003d", - "queryUnclaimedFTs": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcXVlcnlVbmNsYWltZWRGVHMgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBMb3N0QW5kRm91bmQgZnJvbSAweGJlNDYzNTM1M2Y1NWJiZDQKCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHI6IEFkZHJlc3MpOiBbQW55U3RydWN0P10gewogICAgbGV0IHRpY2tldHMgPSBMb3N0QW5kRm91bmQuYm9ycm93QWxsVGlja2V0cyhhZGRyOiBhZGRyKQogICAgCiAgICBsZXQgZGlzcGxheUFycjogW0FueVN0cnVjdD9dICA9IFtdCiAgICBmb3IgdGlja2V0IGluIHRpY2tldHMgewogICAgICAgIGlmIHRpY2tldC50eXBlLmlzU3VidHlwZShvZjogVHlwZTxAe0Z1bmdpYmxlVG9rZW4uVmF1bHR9PigpKSB7IAogICAgICAgICAgICBkaXNwbGF5QXJyLmFwcGVuZCh7ImRpc3BsYXkiOiB0aWNrZXQuZGlzcGxheSwgImJhbGFuY2UiOiB0aWNrZXQuZ2V0RnVuZ2libGVUb2tlbkJhbGFuY2UoKX0pCiAgICAgICAgfQogICAgfQogICAgcmV0dXJuIGRpc3BsYXlBcnIKfQ\u003d\u003d", - "queryUnclaimedNFTs": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcXVlcnlVbmNsYWltZWRORlRzIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTG9zdEFuZEZvdW5kIGZyb20gMHhiZTQ2MzUzNTNmNTViYmQ0CgppbXBvcnQgTWV0YWRhdGFWaWV3cyBmcm9tIDB4NjMxZTg4YWU3ZjFkN2MyMAoKaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyOiBBZGRyZXNzKTogWyZNZXRhZGF0YVZpZXdzLkRpc3BsYXk/XSB7CiAgICBsZXQgdGlja2V0cyA9IExvc3RBbmRGb3VuZC5ib3Jyb3dBbGxUaWNrZXRzKGFkZHI6IGFkZHIpCiAgICAKICAgIGxldCBkaXNwbGF5QXJyOiBbJk1ldGFkYXRhVmlld3MuRGlzcGxheT9dICA9IFtdCiAgICBmb3IgdGlja2V0IGluIHRpY2tldHMgewogICAgICAgIGlmIHRpY2tldC50eXBlLmlzU3VidHlwZShvZjogVHlwZTxAe05vbkZ1bmdpYmxlVG9rZW4uTkZUfT4oKSkgeyAKICAgICAgICAgICAgZGlzcGxheUFyci5hcHBlbmQodGlja2V0LmRpc3BsYXkpCiAgICAgICAgfQogICAgfQogICAgCiAgICByZXR1cm4gZGlzcGxheUFycgp9", - "queryUnclaimedNumber": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcXVlcnlVbmNsYWltZWROdW1iZXIgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBMb3N0QW5kRm91bmQgZnJvbSAweGJlNDYzNTM1M2Y1NWJiZDQKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyOiBBZGRyZXNzKTogSW50IHsKICAgIGxldCBzaGVsZk1hbmFnZXIgPSBMb3N0QW5kRm91bmQuYm9ycm93U2hlbGZNYW5hZ2VyKCkKICAgIGxldCBzaGVsZiA9IHNoZWxmTWFuYWdlci5ib3Jyb3dTaGVsZihyZWRlZW1lcjogYWRkcikKICAgIGlmIHNoZWxmID09IG5pbCB7CiAgICAgICAgcmV0dXJuIDAKICAgIH0KICAgIAogICAgcmV0dXJuIHNoZWxmIS5nZXRSZWRlZW1hYmxlVHlwZXMoKS5sZW5ndGgKfQ\u003d\u003d", - "sendFT": "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\u003d\u003d", - "sendNFT": "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\u003d" + "batchQueryUnclaimedNumber": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYmF0Y2hRdWVyeVVuY2xhaW1lZE51bWJlciAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IExvc3RBbmRGb3VuZCBmcm9tIDB4YmU0NjM1MzUzZjU1YmJkNAoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJzOiBbQWRkcmVzc10pOiBJbnQgewogICAgbGV0IHNoZWxmTWFuYWdlciA9IExvc3RBbmRGb3VuZC5ib3Jyb3dTaGVsZk1hbmFnZXIoKQogICAgdmFyIHVuY2xhaW1lZE51bWJlciA9IDAKICAgIGZvciBhZGRyIGluIGFkZHJzIHsKICAgICAgICBsZXQgc2hlbGYgPSBzaGVsZk1hbmFnZXIuYm9ycm93U2hlbGYocmVkZWVtZXI6IGFkZHIpCiAgICAgICAgaWYgc2hlbGYgPT0gbmlsIHsKICAgICAgICAgICAgY29udGludWUKICAgICAgICB9IGVsc2UgewogICAgICAgICAgICB1bmNsYWltZWROdW1iZXIgPSB1bmNsYWltZWROdW1iZXIgKyBzaGVsZiEuZ2V0UmVkZWVtYWJsZVR5cGVzKCkubGVuZ3RoCiAgICAgICAgfQogICAgfQogICAgcmV0dXJuIHVuY2xhaW1lZE51bWJlcgp9", + "claimFT": "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\u003d\u003d", + "claimNFT": "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\u003d", + "queryUnclaimedFTs": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcXVlcnlVbmNsYWltZWRGVHMgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBMb3N0QW5kRm91bmQgZnJvbSAweGJlNDYzNTM1M2Y1NWJiZDQKCmltcG9ydCBNZXRhZGF0YVZpZXdzIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHI6IEFkZHJlc3MpOiBbQW55U3RydWN0P10gewogICAgbGV0IHRpY2tldHMgPSBMb3N0QW5kRm91bmQuYm9ycm93QWxsVGlja2V0cyhhZGRyOiBhZGRyKQogICAgCiAgICBsZXQgZGlzcGxheUFycjogW0FueVN0cnVjdD9dICA9IFtdCiAgICBmb3IgdGlja2V0IGluIHRpY2tldHMgewogICAgICAgIGlmIHRpY2tldC50eXBlLmlzU3VidHlwZShvZjogVHlwZTxAe0Z1bmdpYmxlVG9rZW4uVmF1bHR9PigpKSB7IAogICAgICAgICAgICBkaXNwbGF5QXJyLmFwcGVuZCh7ImRpc3BsYXkiOiB0aWNrZXQuZGlzcGxheSwgImJhbGFuY2UiOiB0aWNrZXQuZ2V0RnVuZ2libGVUb2tlbkJhbGFuY2UoKX0pCiAgICAgICAgfQogICAgfQogICAgcmV0dXJuIGRpc3BsYXlBcnIKfQ\u003d\u003d", + "queryUnclaimedNFTs": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcXVlcnlVbmNsYWltZWRORlRzIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTG9zdEFuZEZvdW5kIGZyb20gMHhiZTQ2MzUzNTNmNTViYmQ0CgppbXBvcnQgTWV0YWRhdGFWaWV3cyBmcm9tIDB4NjMxZTg4YWU3ZjFkN2MyMAoKaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyOiBBZGRyZXNzKTogWyZNZXRhZGF0YVZpZXdzLkRpc3BsYXk/XSB7CiAgICBsZXQgdGlja2V0cyA9IExvc3RBbmRGb3VuZC5ib3Jyb3dBbGxUaWNrZXRzKGFkZHI6IGFkZHIpCiAgICAKICAgIGxldCBkaXNwbGF5QXJyOiBbJk1ldGFkYXRhVmlld3MuRGlzcGxheT9dICA9IFtdCiAgICBmb3IgdGlja2V0IGluIHRpY2tldHMgewogICAgICAgIGlmIHRpY2tldC50eXBlLmlzU3VidHlwZShvZjogVHlwZTxAe05vbkZ1bmdpYmxlVG9rZW4uTkZUfT4oKSkgeyAKICAgICAgICAgICAgZGlzcGxheUFyci5hcHBlbmQodGlja2V0LmRpc3BsYXkpCiAgICAgICAgfQogICAgfQogICAgCiAgICByZXR1cm4gZGlzcGxheUFycgp9", + "queryUnclaimedNumber": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcXVlcnlVbmNsYWltZWROdW1iZXIgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBMb3N0QW5kRm91bmQgZnJvbSAweGJlNDYzNTM1M2Y1NWJiZDQKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyOiBBZGRyZXNzKTogSW50IHsKICAgIGxldCBzaGVsZk1hbmFnZXIgPSBMb3N0QW5kRm91bmQuYm9ycm93U2hlbGZNYW5hZ2VyKCkKICAgIGxldCBzaGVsZiA9IHNoZWxmTWFuYWdlci5ib3Jyb3dTaGVsZihyZWRlZW1lcjogYWRkcikKICAgIGlmIHNoZWxmID09IG5pbCB7CiAgICAgICAgcmV0dXJuIDAKICAgIH0KICAgIAogICAgcmV0dXJuIHNoZWxmIS5nZXRSZWRlZW1hYmxlVHlwZXMoKS5sZW5ndGgKfQ\u003d\u003d", + "sendFT": "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\u003d\u003d", + "sendNFT": "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\u003d" + }, + "nft": { + "checkNFTListEnabledNew": "
    // Flow Wallet - testnet Script  checkNFTListEnabled - v2.78
// <platform_info>


    import NonFungibleToken from 0x631e88ae7f1d7c20


    
    access(all) fun checkAllDay0x4dfd62c88d1b6462Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/AllDayNFTCollection)
      return vaultRef
    }
    

    access(all) fun checkDimensionX0x46664e2033f9853dVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/dmxCollection)
      return vaultRef
    }
    

    access(all) fun checkDimensionXComics0x46664e2033f9853dVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/dmxComicsCollection)
      return vaultRef
    }
    

    access(all) fun checkDoodles0x1c5033ad60821c97Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/doodles)
      return vaultRef
    }
    

    access(all) fun checkFlovatarComponent0x9392a4a7c3f49a0bVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlovatarComponentCollection)
      return vaultRef
    }
    

    access(all) fun checkFlowRewards0x2e7cfb413f04382fVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/flowRewardsCollectionPublic)
      return vaultRef
    }
    

    access(all) fun checkFlowtyTestNFT0xd9c02cdacccb25abVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlowtyTestNFTCollection)
      return vaultRef
    }
    

    access(all) fun checkFlowversePass0xc7c122b5b811de8eVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlowversePassCollection)
      return vaultRef
    }
    

    access(all) fun checkFlowverseShirt0xc7c122b5b811de8eVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlowverseShirtCollection)
      return vaultRef
    }
    

    access(all) fun checkFlowverseTreasures0xc7c122b5b811de8eVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlowverseTreasuresCollection)
      return vaultRef
    }
    

    access(all) fun checkFRC20SemiNFT0xb7248baa24a95c3fVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FRC20SemiNFT_0xb7248baa24a95c3fcollection)
      return vaultRef
    }
    

    access(all) fun checkGolazos0x1271da8a94edb0ffVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/GolazosNFTCollection)
      return vaultRef
    }
    

    access(all) fun checkHeroesOfTheFlow0x2d59ec5158e3adaeVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/HeroesOfTheFlowCollection)
      return vaultRef
    }
    

    access(all) fun checkIconoGraphika0x08b1f9c0bc04f36fVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/IconoGraphikaNFT)
      return vaultRef
    }
    

    access(all) fun checkJollyJokers0xe9760069d688ef5eVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/JollyJokersCollection)
      return vaultRef
    }
    

    access(all) fun checkMFLPack0x683564e46977788aVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/MFLPackCollection)
      return vaultRef
    }
    

    access(all) fun checkMFLPlayer0x683564e46977788aVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/MFLPlayerCollection)
      return vaultRef
    }
    

    access(all) fun checknba_NFT0x04625c28593d9408Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/nba_NFTCollection)
      return vaultRef
    }
    

    access(all) fun checkOrdinal0xc7c122b5b811de8eVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/OrdinalCollection)
      return vaultRef
    }
    

    access(all) fun checkPackNFT0x4dfd62c88d1b6462Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/PackNFTCollectionPub)
      return vaultRef
    }
    

    access(all) fun checkTicalUniverse0x58b60c5240d3f39bVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/TicalUniverseCollection)
      return vaultRef
    }
    

    access(all) fun checktoddnewstaging2_NFT0x2dcd833119c0570cVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/toddnewstaging2_NFTCollection)
      return vaultRef
    }
    

    access(all) fun checkTopShot0x877931736ee77cffVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/MomentCollection)
      return vaultRef
    }
    

    access(all) fun checkTuneGO0x58b60c5240d3f39bVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/TuneGOCollection)
      return vaultRef
    }
    

    access(all) fun checkTuneGONFTV50x58b60c5240d3f39bVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/tunegoNFTCollection013)
      return vaultRef
    }
    

    access(all) fun checkufcInt_NFT0x04625c28593d9408Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/ufcInt_NFTCollection)
      return vaultRef
    }
    

    access(all) fun checkWearables0x1c5033ad60821c97Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/wearables)
      return vaultRef
    }
    

    access(all) fun checkZeedzINO0x7dc7430a06f38af3Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/ZeedzINOCollection)
      return vaultRef
    }
    

    access(all) fun checkEVMVMBridgedNFT_c2a60e868fb75b7ea2e24de2e07ea9e552b5ab610xdfc20aee650fcbdfVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/EVMVMBridgedNFT_c2a60e868fb75b7ea2e24de2e07ea9e552b5ab61Collection)
      return vaultRef
    }
    

    access(all) fun checkEVMVMBridgedNFT_3fe47f54dbb0c9e2c98c3ac1b327720e18c067460xdfc20aee650fcbdfVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/EVMVMBridgedNFT_3fe47f54dbb0c9e2c98c3ac1b327720e18c06746Collection)
      return vaultRef
    }
    

    access(all) fun checkEVMVMBridgedNFT_9204ea1f54212963f210ec89c712594ff52912230xdfc20aee650fcbdfVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/EVMVMBridgedNFT_9204ea1f54212963f210ec89c712594ff5291223Collection)
      return vaultRef
    }
    
    access(all) fun main(address: Address) : {String: Bool} {
      return {
    "A.4dfd62c88d1b6462.AllDay" :
    checkAllDay0x4dfd62c88d1b6462Vault(address: address)
    ,
    "A.46664e2033f9853d.DimensionX" :
    checkDimensionX0x46664e2033f9853dVault(address: address)
    ,
    "A.46664e2033f9853d.DimensionXComics" :
    checkDimensionXComics0x46664e2033f9853dVault(address: address)
    ,
    "A.1c5033ad60821c97.Doodles" :
    checkDoodles0x1c5033ad60821c97Vault(address: address)
    ,
    "A.9392a4a7c3f49a0b.FlovatarComponent" :
    checkFlovatarComponent0x9392a4a7c3f49a0bVault(address: address)
    ,
    "A.2e7cfb413f04382f.FlowRewards" :
    checkFlowRewards0x2e7cfb413f04382fVault(address: address)
    ,
    "A.d9c02cdacccb25ab.FlowtyTestNFT" :
    checkFlowtyTestNFT0xd9c02cdacccb25abVault(address: address)
    ,
    "A.c7c122b5b811de8e.FlowversePass" :
    checkFlowversePass0xc7c122b5b811de8eVault(address: address)
    ,
    "A.c7c122b5b811de8e.FlowverseShirt" :
    checkFlowverseShirt0xc7c122b5b811de8eVault(address: address)
    ,
    "A.c7c122b5b811de8e.FlowverseTreasures" :
    checkFlowverseTreasures0xc7c122b5b811de8eVault(address: address)
    ,
    "A.b7248baa24a95c3f.FRC20SemiNFT" :
    checkFRC20SemiNFT0xb7248baa24a95c3fVault(address: address)
    ,
    "A.1271da8a94edb0ff.Golazos" :
    checkGolazos0x1271da8a94edb0ffVault(address: address)
    ,
    "A.2d59ec5158e3adae.HeroesOfTheFlow" :
    checkHeroesOfTheFlow0x2d59ec5158e3adaeVault(address: address)
    ,
    "A.08b1f9c0bc04f36f.IconoGraphika" :
    checkIconoGraphika0x08b1f9c0bc04f36fVault(address: address)
    ,
    "A.e9760069d688ef5e.JollyJokers" :
    checkJollyJokers0xe9760069d688ef5eVault(address: address)
    ,
    "A.683564e46977788a.MFLPack" :
    checkMFLPack0x683564e46977788aVault(address: address)
    ,
    "A.683564e46977788a.MFLPlayer" :
    checkMFLPlayer0x683564e46977788aVault(address: address)
    ,
    "A.04625c28593d9408.nba_NFT" :
    checknba_NFT0x04625c28593d9408Vault(address: address)
    ,
    "A.c7c122b5b811de8e.Ordinal" :
    checkOrdinal0xc7c122b5b811de8eVault(address: address)
    ,
    "A.4dfd62c88d1b6462.PackNFT" :
    checkPackNFT0x4dfd62c88d1b6462Vault(address: address)
    ,
    "A.58b60c5240d3f39b.TicalUniverse" :
    checkTicalUniverse0x58b60c5240d3f39bVault(address: address)
    ,
    "A.2dcd833119c0570c.toddnewstaging2_NFT" :
    checktoddnewstaging2_NFT0x2dcd833119c0570cVault(address: address)
    ,
    "A.877931736ee77cff.TopShot" :
    checkTopShot0x877931736ee77cffVault(address: address)
    ,
    "A.58b60c5240d3f39b.TuneGO" :
    checkTuneGO0x58b60c5240d3f39bVault(address: address)
    ,
    "A.58b60c5240d3f39b.TuneGONFTV5" :
    checkTuneGONFTV50x58b60c5240d3f39bVault(address: address)
    ,
    "A.04625c28593d9408.ufcInt_NFT" :
    checkufcInt_NFT0x04625c28593d9408Vault(address: address)
    ,
    "A.1c5033ad60821c97.Wearables" :
    checkWearables0x1c5033ad60821c97Vault(address: address)
    ,
    "A.7dc7430a06f38af3.ZeedzINO" :
    checkZeedzINO0x7dc7430a06f38af3Vault(address: address)
    ,
    "A.dfc20aee650fcbdf.EVMVMBridgedNFT_c2a60e868fb75b7ea2e24de2e07ea9e552b5ab61" :
    checkEVMVMBridgedNFT_c2a60e868fb75b7ea2e24de2e07ea9e552b5ab610xdfc20aee650fcbdfVault(address: address)
    ,
    "A.dfc20aee650fcbdf.EVMVMBridgedNFT_3fe47f54dbb0c9e2c98c3ac1b327720e18c06746" :
    checkEVMVMBridgedNFT_3fe47f54dbb0c9e2c98c3ac1b327720e18c067460xdfc20aee650fcbdfVault(address: address)
    ,
    "A.dfc20aee650fcbdf.EVMVMBridgedNFT_9204ea1f54212963f210ec89c712594ff5291223" :
    checkEVMVMBridgedNFT_9204ea1f54212963f210ec89c712594ff52912230xdfc20aee650fcbdfVault(address: address)
    }
    }
  ", + "checkNFTListEnabled": "
    // Flow Wallet - testnet Script  checkNFTListEnabled - v2.78
// <platform_info>


    import NonFungibleToken from 0x631e88ae7f1d7c20


    
    access(all) fun checkAllDay0x4dfd62c88d1b6462Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/AllDayNFTCollection)
      return vaultRef
    }
    

    access(all) fun checkDimensionX0x46664e2033f9853dVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/dmxCollection)
      return vaultRef
    }
    

    access(all) fun checkDimensionXComics0x46664e2033f9853dVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/dmxComicsCollection)
      return vaultRef
    }
    

    access(all) fun checkDoodles0x1c5033ad60821c97Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/doodles)
      return vaultRef
    }
    

    access(all) fun checkFlovatarComponent0x9392a4a7c3f49a0bVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlovatarComponentCollection)
      return vaultRef
    }
    

    access(all) fun checkFlowRewards0x2e7cfb413f04382fVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/flowRewardsCollectionPublic)
      return vaultRef
    }
    

    access(all) fun checkFlowtyTestNFT0xd9c02cdacccb25abVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlowtyTestNFTCollection)
      return vaultRef
    }
    

    access(all) fun checkFlowversePass0xc7c122b5b811de8eVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlowversePassCollection)
      return vaultRef
    }
    

    access(all) fun checkFlowverseShirt0xc7c122b5b811de8eVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlowverseShirtCollection)
      return vaultRef
    }
    

    access(all) fun checkFlowverseTreasures0xc7c122b5b811de8eVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FlowverseTreasuresCollection)
      return vaultRef
    }
    

    access(all) fun checkFRC20SemiNFT0xb7248baa24a95c3fVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/FRC20SemiNFT_0xb7248baa24a95c3fcollection)
      return vaultRef
    }
    

    access(all) fun checkGolazos0x1271da8a94edb0ffVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/GolazosNFTCollection)
      return vaultRef
    }
    

    access(all) fun checkHeroesOfTheFlow0x2d59ec5158e3adaeVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/HeroesOfTheFlowCollection)
      return vaultRef
    }
    

    access(all) fun checkIconoGraphika0x08b1f9c0bc04f36fVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/IconoGraphikaNFT)
      return vaultRef
    }
    

    access(all) fun checkJollyJokers0xe9760069d688ef5eVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/JollyJokersCollection)
      return vaultRef
    }
    

    access(all) fun checkMFLPack0x683564e46977788aVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/MFLPackCollection)
      return vaultRef
    }
    

    access(all) fun checkMFLPlayer0x683564e46977788aVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/MFLPlayerCollection)
      return vaultRef
    }
    

    access(all) fun checknba_NFT0x04625c28593d9408Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/nba_NFTCollection)
      return vaultRef
    }
    

    access(all) fun checkOrdinal0xc7c122b5b811de8eVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/OrdinalCollection)
      return vaultRef
    }
    

    access(all) fun checkPackNFT0x4dfd62c88d1b6462Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/PackNFTCollectionPub)
      return vaultRef
    }
    

    access(all) fun checkTicalUniverse0x58b60c5240d3f39bVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/TicalUniverseCollection)
      return vaultRef
    }
    

    access(all) fun checktoddnewstaging2_NFT0x2dcd833119c0570cVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/toddnewstaging2_NFTCollection)
      return vaultRef
    }
    

    access(all) fun checkTopShot0x877931736ee77cffVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/MomentCollection)
      return vaultRef
    }
    

    access(all) fun checkTuneGO0x58b60c5240d3f39bVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/TuneGOCollection)
      return vaultRef
    }
    

    access(all) fun checkTuneGONFTV50x58b60c5240d3f39bVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/tunegoNFTCollection013)
      return vaultRef
    }
    

    access(all) fun checkufcInt_NFT0x04625c28593d9408Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/ufcInt_NFTCollection)
      return vaultRef
    }
    

    access(all) fun checkWearables0x1c5033ad60821c97Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/wearables)
      return vaultRef
    }
    

    access(all) fun checkZeedzINO0x7dc7430a06f38af3Vault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/ZeedzINOCollection)
      return vaultRef
    }
    

    access(all) fun checkEVMVMBridgedNFT_c2a60e868fb75b7ea2e24de2e07ea9e552b5ab610xdfc20aee650fcbdfVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/EVMVMBridgedNFT_c2a60e868fb75b7ea2e24de2e07ea9e552b5ab61Collection)
      return vaultRef
    }
    

    access(all) fun checkEVMVMBridgedNFT_3fe47f54dbb0c9e2c98c3ac1b327720e18c067460xdfc20aee650fcbdfVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/EVMVMBridgedNFT_3fe47f54dbb0c9e2c98c3ac1b327720e18c06746Collection)
      return vaultRef
    }
    

    access(all) fun checkEVMVMBridgedNFT_9204ea1f54212963f210ec89c712594ff52912230xdfc20aee650fcbdfVault(address: Address) : Bool {
      let account = getAccount(address)
      let vaultRef = account
      .capabilities.exists(/public/EVMVMBridgedNFT_9204ea1f54212963f210ec89c712594ff5291223Collection)
      return vaultRef
    }
    
    access(all) fun main(address: Address) : {String: Bool} {
      return {
    "A.4dfd62c88d1b6462.AllDay" :
    checkAllDay0x4dfd62c88d1b6462Vault(address: address)
    ,
    "A.46664e2033f9853d.DimensionX" :
    checkDimensionX0x46664e2033f9853dVault(address: address)
    ,
    "A.46664e2033f9853d.DimensionXComics" :
    checkDimensionXComics0x46664e2033f9853dVault(address: address)
    ,
    "A.1c5033ad60821c97.Doodles" :
    checkDoodles0x1c5033ad60821c97Vault(address: address)
    ,
    "A.9392a4a7c3f49a0b.FlovatarComponent" :
    checkFlovatarComponent0x9392a4a7c3f49a0bVault(address: address)
    ,
    "A.2e7cfb413f04382f.FlowRewards" :
    checkFlowRewards0x2e7cfb413f04382fVault(address: address)
    ,
    "A.d9c02cdacccb25ab.FlowtyTestNFT" :
    checkFlowtyTestNFT0xd9c02cdacccb25abVault(address: address)
    ,
    "A.c7c122b5b811de8e.FlowversePass" :
    checkFlowversePass0xc7c122b5b811de8eVault(address: address)
    ,
    "A.c7c122b5b811de8e.FlowverseShirt" :
    checkFlowverseShirt0xc7c122b5b811de8eVault(address: address)
    ,
    "A.c7c122b5b811de8e.FlowverseTreasures" :
    checkFlowverseTreasures0xc7c122b5b811de8eVault(address: address)
    ,
    "A.b7248baa24a95c3f.FRC20SemiNFT" :
    checkFRC20SemiNFT0xb7248baa24a95c3fVault(address: address)
    ,
    "A.1271da8a94edb0ff.Golazos" :
    checkGolazos0x1271da8a94edb0ffVault(address: address)
    ,
    "A.2d59ec5158e3adae.HeroesOfTheFlow" :
    checkHeroesOfTheFlow0x2d59ec5158e3adaeVault(address: address)
    ,
    "A.08b1f9c0bc04f36f.IconoGraphika" :
    checkIconoGraphika0x08b1f9c0bc04f36fVault(address: address)
    ,
    "A.e9760069d688ef5e.JollyJokers" :
    checkJollyJokers0xe9760069d688ef5eVault(address: address)
    ,
    "A.683564e46977788a.MFLPack" :
    checkMFLPack0x683564e46977788aVault(address: address)
    ,
    "A.683564e46977788a.MFLPlayer" :
    checkMFLPlayer0x683564e46977788aVault(address: address)
    ,
    "A.04625c28593d9408.nba_NFT" :
    checknba_NFT0x04625c28593d9408Vault(address: address)
    ,
    "A.c7c122b5b811de8e.Ordinal" :
    checkOrdinal0xc7c122b5b811de8eVault(address: address)
    ,
    "A.4dfd62c88d1b6462.PackNFT" :
    checkPackNFT0x4dfd62c88d1b6462Vault(address: address)
    ,
    "A.58b60c5240d3f39b.TicalUniverse" :
    checkTicalUniverse0x58b60c5240d3f39bVault(address: address)
    ,
    "A.2dcd833119c0570c.toddnewstaging2_NFT" :
    checktoddnewstaging2_NFT0x2dcd833119c0570cVault(address: address)
    ,
    "A.877931736ee77cff.TopShot" :
    checkTopShot0x877931736ee77cffVault(address: address)
    ,
    "A.58b60c5240d3f39b.TuneGO" :
    checkTuneGO0x58b60c5240d3f39bVault(address: address)
    ,
    "A.58b60c5240d3f39b.TuneGONFTV5" :
    checkTuneGONFTV50x58b60c5240d3f39bVault(address: address)
    ,
    "A.04625c28593d9408.ufcInt_NFT" :
    checkufcInt_NFT0x04625c28593d9408Vault(address: address)
    ,
    "A.1c5033ad60821c97.Wearables" :
    checkWearables0x1c5033ad60821c97Vault(address: address)
    ,
    "A.7dc7430a06f38af3.ZeedzINO" :
    checkZeedzINO0x7dc7430a06f38af3Vault(address: address)
    ,
    "A.dfc20aee650fcbdf.EVMVMBridgedNFT_c2a60e868fb75b7ea2e24de2e07ea9e552b5ab61" :
    checkEVMVMBridgedNFT_c2a60e868fb75b7ea2e24de2e07ea9e552b5ab610xdfc20aee650fcbdfVault(address: address)
    ,
    "A.dfc20aee650fcbdf.EVMVMBridgedNFT_3fe47f54dbb0c9e2c98c3ac1b327720e18c06746" :
    checkEVMVMBridgedNFT_3fe47f54dbb0c9e2c98c3ac1b327720e18c067460xdfc20aee650fcbdfVault(address: address)
    ,
    "A.dfc20aee650fcbdf.EVMVMBridgedNFT_9204ea1f54212963f210ec89c712594ff5291223" :
    checkEVMVMBridgedNFT_9204ea1f54212963f210ec89c712594ff52912230xdfc20aee650fcbdfVault(address: address)
    }
    }
  " }, "staking": { - "checkSetup": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY2hlY2tTZXR1cCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dTdGFraW5nQ29sbGVjdGlvbiBmcm9tIDB4OTVlMDE5YTE3ZDBlMjNkNwoKCi8vLyBEZXRlcm1pbmVzIGlmIGFuIGFjY291bnQgaXMgc2V0IHVwIHdpdGggYSBTdGFraW5nIENvbGxlY3Rpb24KCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBCb29sIHsKICAgIHJldHVybiBGbG93U3Rha2luZ0NvbGxlY3Rpb24uZG9lc0FjY291bnRIYXZlU3Rha2luZ0NvbGxlY3Rpb24oYWRkcmVzczogYWRkcmVzcykKfQ\u003d\u003d", - "checkStakingEnabled": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY2hlY2tTdGFraW5nRW5hYmxlZCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dJRFRhYmxlU3Rha2luZyBmcm9tIDB4OWVjYTJiMzhiMThiNWRmZQoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKCk6Qm9vbCB7CiAgICByZXR1cm4gRmxvd0lEVGFibGVTdGFraW5nLnN0YWtpbmdFbmFibGVkKCkKfQ\u003d\u003d", - "closeStake": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY2xvc2VTdGFrZSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dTdGFraW5nQ29sbGVjdGlvbiBmcm9tIDB4OTVlMDE5YTE3ZDBlMjNkNwoKCi8vIENsb3NlcyBvdXQgYSBzdGFraW5nIG9iamVjdCBpbiB0aGUgc3Rha2luZyBjb2xsZWN0aW9uCi8vIFRoaXMgZG9lcyBub3QgcmVtb3ZlIHRoZSByZWNvcmQgZnJvbSB0aGUgaWRlbnRpdHkgdGFibGUsCi8vIGJ1dCBpdCBkb2VzIG1lYW4gdGhhdCB0aGUgYWNjb3VudCB0aGF0IGNsb3NlcyBpdCBjYW5ub3QgZXZlciBhY2Nlc3MgaXQgYWdhaW4KCnRyYW5zYWN0aW9uKG5vZGVJRDogU3RyaW5nLCBkZWxlZ2F0b3JJRDogVUludDMyPykgewogICAgCiAgICBsZXQgc3Rha2luZ0NvbGxlY3Rpb25SZWY6IGF1dGgoRmxvd1N0YWtpbmdDb2xsZWN0aW9uLkNvbGxlY3Rpb25Pd25lcikgJkZsb3dTdGFraW5nQ29sbGVjdGlvbi5TdGFraW5nQ29sbGVjdGlvbgoKICAgIHByZXBhcmUoYWNjb3VudDogYXV0aChCb3Jyb3dWYWx1ZSkgJkFjY291bnQpIHsKICAgICAgICBzZWxmLnN0YWtpbmdDb2xsZWN0aW9uUmVmID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzxhdXRoKEZsb3dTdGFraW5nQ29sbGVjdGlvbi5Db2xsZWN0aW9uT3duZXIpICZGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb24+KGZyb206IEZsb3dTdGFraW5nQ29sbGVjdGlvbi5TdGFraW5nQ29sbGVjdGlvblN0b3JhZ2VQYXRoKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBhIHJlZmVyZW5jZSB0byBhIFN0YWtpbmdDb2xsZWN0aW9uIGluIHRoZSBwcmltYXJ5IHVzZXIncyBhY2NvdW50IikKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBzZWxmLnN0YWtpbmdDb2xsZWN0aW9uUmVmLmNsb3NlU3Rha2Uobm9kZUlEOiBub2RlSUQsIGRlbGVnYXRvcklEOiBkZWxlZ2F0b3JJRCkKICAgIH0KfQ\u003d\u003d", - "createDelegator": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY3JlYXRlRGVsZWdhdG9yIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd1N0YWtpbmdDb2xsZWN0aW9uIGZyb20gMHg5NWUwMTlhMTdkMGUyM2Q3CgoKLy8vIFJlZ2lzdGVycyBhIGRlbGVnYXRvciBpbiB0aGUgc3Rha2luZyBjb2xsZWN0aW9uIHJlc291cmNlCi8vLyBmb3IgdGhlIHNwZWNpZmllZCBub2RlSUQgYW5kIHRoZSBhbW91bnQgb2YgdG9rZW5zIHRvIGNvbW1pdAoKdHJhbnNhY3Rpb24oaWQ6IFN0cmluZywgYW1vdW50OiBVRml4NjQpIHsKICAgIAogICAgbGV0IHN0YWtpbmdDb2xsZWN0aW9uUmVmOiBhdXRoKEZsb3dTdGFraW5nQ29sbGVjdGlvbi5Db2xsZWN0aW9uT3duZXIpICZGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb24KCiAgICBwcmVwYXJlKGFjY291bnQ6IGF1dGgoQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZiA9IGFjY291bnQuc3RvcmFnZS5ib3Jyb3c8YXV0aChGbG93U3Rha2luZ0NvbGxlY3Rpb24uQ29sbGVjdGlvbk93bmVyKSAmRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uPihmcm9tOiBGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb25TdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgYSByZWZlcmVuY2UgdG8gYSBTdGFraW5nQ29sbGVjdGlvbiBpbiB0aGUgcHJpbWFyeSB1c2VyJ3MgYWNjb3VudCIpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZi5yZWdpc3RlckRlbGVnYXRvcihub2RlSUQ6IGlkLCBhbW91bnQ6IGFtb3VudCkgICAgICAKICAgIH0KfQ\u003d\u003d", - "createStake": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY3JlYXRlU3Rha2UgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGbG93U3Rha2luZ0NvbGxlY3Rpb24gZnJvbSAweDk1ZTAxOWExN2QwZTIzZDcKCgovLy8gQ29tbWl0cyBuZXcgdG9rZW5zIHRvIHN0YWtlIGZvciB0aGUgc3BlY2lmaWVkIG5vZGUgb3IgZGVsZWdhdG9yIGluIHRoZSBzdGFraW5nIGNvbGxlY3Rpb24KLy8vIFRoZSB0b2tlbnMgZnJvbSB0aGUgbG9ja2VkIHZhdWx0IGFyZSB1c2VkIGZpcnN0LCBpZiBpdCBleGlzdHMKLy8vIGZvbGxvd2VkIGJ5IHRoZSB0b2tlbnMgZnJvbSB0aGUgdW5sb2NrZWQgdmF1bHQKCnRyYW5zYWN0aW9uKG5vZGVJRDogU3RyaW5nLCBkZWxlZ2F0b3JJRDogVUludDMyPywgYW1vdW50OiBVRml4NjQpIHsKICAgIAogICAgbGV0IHN0YWtpbmdDb2xsZWN0aW9uUmVmOiBhdXRoKEZsb3dTdGFraW5nQ29sbGVjdGlvbi5Db2xsZWN0aW9uT3duZXIpICZGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb24KCiAgICBwcmVwYXJlKGFjY291bnQ6IGF1dGgoQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZiA9IGFjY291bnQuc3RvcmFnZS5ib3Jyb3c8YXV0aChGbG93U3Rha2luZ0NvbGxlY3Rpb24uQ29sbGVjdGlvbk93bmVyKSAmRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uPihmcm9tOiBGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb25TdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgYSByZWZlcmVuY2UgdG8gYSBTdGFraW5nQ29sbGVjdGlvbiBpbiB0aGUgcHJpbWFyeSB1c2VyJ3MgYWNjb3VudCIpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZi5zdGFrZU5ld1Rva2Vucyhub2RlSUQ6IG5vZGVJRCwgZGVsZWdhdG9ySUQ6IGRlbGVnYXRvcklELCBhbW91bnQ6IGFtb3VudCkKICAgIH0KfQ\u003d\u003d", - "getApr": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QXByIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd0lEVGFibGVTdGFraW5nIGZyb20gMHg5ZWNhMmIzOGIxOGI1ZGZlCgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oKTogVUZpeDY0IHsKICAgIGxldCBhcHIgPSBGbG93SURUYWJsZVN0YWtpbmcuZ2V0RXBvY2hUb2tlblBheW91dCgpIC8gRmxvd0lEVGFibGVTdGFraW5nLmdldFRvdGFsU3Rha2VkKCkgLyA3LjAgKiAzNjUuMCAqICgxLjAgLSBGbG93SURUYWJsZVN0YWtpbmcuZ2V0UmV3YXJkQ3V0UGVyY2VudGFnZSgpKQogICAgcmV0dXJuIGFwcgp9", - "getApyWeekly": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QXB5V2Vla2x5IC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd0lEVGFibGVTdGFraW5nIGZyb20gMHg5ZWNhMmIzOGIxOGI1ZGZlCgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oKTogVUZpeDY0IHsKICAgIGxldCBhcHIgPSBGbG93SURUYWJsZVN0YWtpbmcuZ2V0RXBvY2hUb2tlblBheW91dCgpIC8gRmxvd0lEVGFibGVTdGFraW5nLmdldFRvdGFsU3Rha2VkKCkgKiA1NC4wICogKDEuMCAtIEZsb3dJRFRhYmxlU3Rha2luZy5nZXRSZXdhcmRDdXRQZXJjZW50YWdlKCkpCiAgICByZXR1cm4gYXByCn0\u003d", - "getDelegatesIndo": "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\u003d\u003d", - "getDelegatesInfo": "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", - "getDelegatesInfoArray": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0RGVsZWdhdGVzSW5mb0FycmF5IC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgoKaW1wb3J0IEZsb3dTdGFraW5nQ29sbGVjdGlvbiBmcm9tIDB4OTVlMDE5YTE3ZDBlMjNkNwoKaW1wb3J0IEZsb3dJRFRhYmxlU3Rha2luZyBmcm9tIDB4OWVjYTJiMzhiMThiNWRmZQoKaW1wb3J0IExvY2tlZFRva2VucyBmcm9tIDB4OTVlMDE5YTE3ZDBlMjNkNwoKICAgICAgICAKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IFtGbG93SURUYWJsZVN0YWtpbmcuRGVsZWdhdG9ySW5mb10gewogICAgcmV0dXJuIEZsb3dTdGFraW5nQ29sbGVjdGlvbi5nZXRBbGxEZWxlZ2F0b3JJbmZvKGFkZHJlc3M6IGFkZHJlc3MpCn0\u003d", - "getDelegatesInfoArrayV2": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0RGVsZWdhdGVzSW5mb0FycmF5VjIgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCgppbXBvcnQgRmxvd1N0YWtpbmdDb2xsZWN0aW9uIGZyb20gMHg5NWUwMTlhMTdkMGUyM2Q3CgppbXBvcnQgRmxvd0lEVGFibGVTdGFraW5nIGZyb20gMHg5ZWNhMmIzOGIxOGI1ZGZlCgppbXBvcnQgTG9ja2VkVG9rZW5zIGZyb20gMHg5NWUwMTlhMTdkMGUyM2Q3CgogICAgICAgIAphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzKTogW0Zsb3dJRFRhYmxlU3Rha2luZy5EZWxlZ2F0b3JJbmZvXT8gewogICAgdmFyIHJlczogW0Zsb3dJRFRhYmxlU3Rha2luZy5EZWxlZ2F0b3JJbmZvXT8gPSBuaWwKCiAgICBsZXQgaW5pdGVkID0gRmxvd1N0YWtpbmdDb2xsZWN0aW9uLmRvZXNBY2NvdW50SGF2ZVN0YWtpbmdDb2xsZWN0aW9uKGFkZHJlc3M6IGFkZHJlc3MpCgogICAgaWYgaW5pdGVkIHsKICAgICAgICByZXMgPSBGbG93U3Rha2luZ0NvbGxlY3Rpb24uZ2V0QWxsRGVsZWdhdG9ySW5mbyhhZGRyZXNzOiBhZGRyZXNzKQogICAgfQogICAgcmV0dXJuIHJlcwp9", - "getDelegatesInfoV2": "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\u003d", - "getDelegatorInfo": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0RGVsZWdhdG9ySW5mbyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dJRFRhYmxlU3Rha2luZyBmcm9tIDB4OWVjYTJiMzhiMThiNWRmZQoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKG5vZGVJRDogU3RyaW5nLCBkZWxlZ2F0b3JJRDogVUludDMyKTogRmxvd0lEVGFibGVTdGFraW5nLkRlbGVnYXRvckluZm8gewogIHJldHVybiBGbG93SURUYWJsZVN0YWtpbmcuRGVsZWdhdG9ySW5mbyhub2RlSUQ6IG5vZGVJRCwgZGVsZWdhdG9ySUQ6IGRlbGVnYXRvcklEKQp9", - "getEpochMetadata": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0RXBvY2hNZXRhZGF0YSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dFcG9jaCBmcm9tIDB4OWVjYTJiMzhiMThiNWRmZQoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGVwb2NoQ291bnRlcjogVUludDY0KTogRmxvd0Vwb2NoLkVwb2NoTWV0YWRhdGEgewogICAgcmV0dXJuIEZsb3dFcG9jaC5nZXRFcG9jaE1ldGFkYXRhKGVwb2NoQ291bnRlcikhCn0\u003d", - "getNodeInfo": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0Tm9kZUluZm8gLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGbG93SURUYWJsZVN0YWtpbmcgZnJvbSAweDllY2EyYjM4YjE4YjVkZmUKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihub2RlSUQ6IFN0cmluZyk6IEZsb3dJRFRhYmxlU3Rha2luZy5Ob2RlSW5mbyB7CiAgcmV0dXJuIEZsb3dJRFRhYmxlU3Rha2luZy5Ob2RlSW5mbyhub2RlSUQ6IG5vZGVJRCkKfQ\u003d\u003d", - "getNodesInfo": "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", - "getStakeInfo": "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", - "getStakingInfo": "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", - "restakeReward": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcmVzdGFrZVJld2FyZCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKIGltcG9ydCBGbG93U3Rha2luZ0NvbGxlY3Rpb24gZnJvbSAweDk1ZTAxOWExN2QwZTIzZDcKCgovLy8gQ29tbWl0cyByZXdhcmRlZCB0b2tlbnMgdG8gc3Rha2UgZm9yIHRoZSBzcGVjaWZpZWQgbm9kZSBvciBkZWxlZ2F0b3IgaW4gdGhlIHN0YWtpbmcgY29sbGVjdGlvbgoKdHJhbnNhY3Rpb24obm9kZUlEOiBTdHJpbmcsIGRlbGVnYXRvcklEOiBVSW50MzI/LCBhbW91bnQ6IFVGaXg2NCkgewogICAgCiAgICBsZXQgc3Rha2luZ0NvbGxlY3Rpb25SZWY6IGF1dGgoRmxvd1N0YWtpbmdDb2xsZWN0aW9uLkNvbGxlY3Rpb25Pd25lcikgJkZsb3dTdGFraW5nQ29sbGVjdGlvbi5TdGFraW5nQ29sbGVjdGlvbgoKICAgIHByZXBhcmUoYWNjb3VudDogYXV0aChCb3Jyb3dWYWx1ZSkgJkFjY291bnQpIHsKICAgICAgICBzZWxmLnN0YWtpbmdDb2xsZWN0aW9uUmVmID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzxhdXRoKEZsb3dTdGFraW5nQ29sbGVjdGlvbi5Db2xsZWN0aW9uT3duZXIpICZGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb24+KGZyb206IEZsb3dTdGFraW5nQ29sbGVjdGlvbi5TdGFraW5nQ29sbGVjdGlvblN0b3JhZ2VQYXRoKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBhIHJlZmVyZW5jZSB0byBhIFN0YWtpbmdDb2xsZWN0aW9uIGluIHRoZSBwcmltYXJ5IHVzZXIncyBhY2NvdW50IikKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBzZWxmLnN0YWtpbmdDb2xsZWN0aW9uUmVmLnN0YWtlUmV3YXJkZWRUb2tlbnMobm9kZUlEOiBub2RlSUQsIGRlbGVnYXRvcklEOiBkZWxlZ2F0b3JJRCwgYW1vdW50OiBhbW91bnQpCiAgICB9Cn0\u003d", - "restakeUnstaked": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcmVzdGFrZVVuc3Rha2VkIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd1N0YWtpbmdDb2xsZWN0aW9uIGZyb20gMHg5NWUwMTlhMTdkMGUyM2Q3CgoKLy8vIENvbW1pdHMgdW5zdGFrZWQgdG9rZW5zIHRvIHN0YWtlIGZvciB0aGUgc3BlY2lmaWVkIG5vZGUgb3IgZGVsZWdhdG9yIGluIHRoZSBzdGFraW5nIGNvbGxlY3Rpb24KCnRyYW5zYWN0aW9uKG5vZGVJRDogU3RyaW5nLCBkZWxlZ2F0b3JJRDogVUludDMyPywgYW1vdW50OiBVRml4NjQpIHsKICAgIAogICAgbGV0IHN0YWtpbmdDb2xsZWN0aW9uUmVmOiBhdXRoKEZsb3dTdGFraW5nQ29sbGVjdGlvbi5Db2xsZWN0aW9uT3duZXIpICZGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb24KCiAgICBwcmVwYXJlKGFjY291bnQ6IGF1dGgoQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZiA9IGFjY291bnQuc3RvcmFnZS5ib3Jyb3c8YXV0aChGbG93U3Rha2luZ0NvbGxlY3Rpb24uQ29sbGVjdGlvbk93bmVyKSAmRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uPihmcm9tOiBGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb25TdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgYSByZWZlcmVuY2UgdG8gYSBTdGFraW5nQ29sbGVjdGlvbiBpbiB0aGUgcHJpbWFyeSB1c2VyJ3MgYWNjb3VudCIpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZi5zdGFrZVVuc3Rha2VkVG9rZW5zKG5vZGVJRDogbm9kZUlELCBkZWxlZ2F0b3JJRDogZGVsZWdhdG9ySUQsIGFtb3VudDogYW1vdW50KQogICAgfQp9", - "setup": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgc2V0dXAgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHg3ZTYwZGYwNDJhOWMwODY4CgppbXBvcnQgTG9ja2VkVG9rZW5zIGZyb20gMHg5NWUwMTlhMTdkMGUyM2Q3CgppbXBvcnQgRmxvd0lEVGFibGVTdGFraW5nIGZyb20gMHg5ZWNhMmIzOGIxOGI1ZGZlCgppbXBvcnQgRmxvd1N0YWtpbmdDb2xsZWN0aW9uIGZyb20gMHg5NWUwMTlhMTdkMGUyM2Q3CgoKLy8vIFRoaXMgdHJhbnNhY3Rpb24gc2V0cyB1cCBhbiBhY2NvdW50IHRvIHVzZSBhIHN0YWtpbmcgY29sbGVjdGlvbgovLy8gSXQgd2lsbCB3b3JrIHJlZ2FyZGxlc3Mgb2Ygd2hldGhlciB0aGV5IGhhdmUgYSByZWd1bGFyIGFjY291bnQsIGEgdHdvLWFjY291bnQgbG9ja2VkIHRva2VucyBzZXR1cCwKLy8vIG9yIHN0YWtpbmcgb2JqZWN0cyBzdG9yZWQgaW4gdGhlIHVubG9ja2VkIGFjY291bnQKCnRyYW5zYWN0aW9uIHsKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKEJvcnJvd1ZhbHVlLCBTdG9yYWdlLCBDYXBhYmlsaXRpZXMpICZBY2NvdW50KSB7CgogICAgICAgIC8vIElmIHRoZXJlIGlzbid0IGFscmVhZHkgYSBzdGFraW5nIGNvbGxlY3Rpb24KICAgICAgICBpZiBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8JkZsb3dTdGFraW5nQ29sbGVjdGlvbi5TdGFraW5nQ29sbGVjdGlvbj4oZnJvbTogRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uU3RvcmFnZVBhdGgpID09IG5pbCB7CgogICAgICAgICAgICAvLyBDcmVhdGUgcHJpdmF0ZSBjYXBhYmlsaXRpZXMgZm9yIHRoZSB0b2tlbiBob2xkZXIgYW5kIHVubG9ja2VkIHZhdWx0CiAgICAgICAgICAgIGxldCBsb2NrZWRIb2xkZXIgPSBzaWduZXIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8YXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3LCBMb2NrZWRUb2tlbnMuVG9rZW5PcGVyYXRpb25zKSAmTG9ja2VkVG9rZW5zLlRva2VuSG9sZGVyPihMb2NrZWRUb2tlbnMuVG9rZW5Ib2xkZXJTdG9yYWdlUGF0aCkhCiAgICAgICAgICAgIGxldCBmbG93VG9rZW4gPSBzaWduZXIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8YXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAmRmxvd1Rva2VuLlZhdWx0Pigvc3RvcmFnZS9mbG93VG9rZW5WYXVsdCkhCgogICAgICAgICAgICAvLyBDcmVhdGUgYSBuZXcgU3Rha2luZyBDb2xsZWN0aW9uIGFuZCBwdXQgaXQgaW4gc3RvcmFnZQogICAgICAgICAgICBpZiBsb2NrZWRIb2xkZXIuY2hlY2soKSB7CiAgICAgICAgICAgICAgICBzaWduZXIuc3RvcmFnZS5zYXZlKAogICAgICAgICAgICAgICAgICAgIDwtIEZsb3dTdGFraW5nQ29sbGVjdGlvbi5jcmVhdGVTdGFraW5nQ29sbGVjdGlvbigKICAgICAgICAgICAgICAgICAgICAgICAgdW5sb2NrZWRWYXVsdDogZmxvd1Rva2VuLAogICAgICAgICAgICAgICAgICAgICAgICB0b2tlbkhvbGRlcjogbG9ja2VkSG9sZGVyCiAgICAgICAgICAgICAgICAgICAgKSwKICAgICAgICAgICAgICAgICAgICB0bzogRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uU3RvcmFnZVBhdGgKICAgICAgICAgICAgICAgICkKICAgICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgICAgIHNpZ25lci5zdG9yYWdlLnNhdmUoCiAgICAgICAgICAgICAgICAgICAgPC0gRmxvd1N0YWtpbmdDb2xsZWN0aW9uLmNyZWF0ZVN0YWtpbmdDb2xsZWN0aW9uKAogICAgICAgICAgICAgICAgICAgICAgICB1bmxvY2tlZFZhdWx0OiBmbG93VG9rZW4sCiAgICAgICAgICAgICAgICAgICAgICAgIHRva2VuSG9sZGVyOiBuaWwKICAgICAgICAgICAgICAgICAgICApLAogICAgICAgICAgICAgICAgICAgIHRvOiBGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb25TdG9yYWdlUGF0aAogICAgICAgICAgICAgICAgKQogICAgICAgICAgICB9CgogICAgICAgICAgICAvLyBQdWJsaXNoIGEgY2FwYWJpbGl0eSB0byB0aGUgY3JlYXRlZCBzdGFraW5nIGNvbGxlY3Rpb24uCiAgICAgICAgICAgIGxldCBzdGFraW5nQ29sbGVjdGlvbkNhcCA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTwmRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uPigKICAgICAgICAgICAgICAgIEZsb3dTdGFraW5nQ29sbGVjdGlvbi5TdGFraW5nQ29sbGVjdGlvblN0b3JhZ2VQYXRoCiAgICAgICAgICAgICkKCiAgICAgICAgICAgIHNpZ25lci5jYXBhYmlsaXRpZXMucHVibGlzaCgKICAgICAgICAgICAgICAgIHN0YWtpbmdDb2xsZWN0aW9uQ2FwLAogICAgICAgICAgICAgICAgYXQ6IEZsb3dTdGFraW5nQ29sbGVjdGlvbi5TdGFraW5nQ29sbGVjdGlvblB1YmxpY1BhdGgKICAgICAgICAgICAgKQogICAgICAgIH0KCiAgICAgICAgLy8gYm9ycm93IGEgcmVmZXJlbmNlIHRvIHRoZSBzdGFraW5nIGNvbGxlY3Rpb24KICAgICAgICBsZXQgY29sbGVjdGlvblJlZiA9IHNpZ25lci5zdG9yYWdlLmJvcnJvdzwmRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uPihmcm9tOiBGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb25TdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgc3Rha2luZyBjb2xsZWN0aW9uIHJlZmVyZW5jZSIpCgogICAgICAgIC8vIElmIHRoZXJlIGlzIGEgbm9kZSBzdGFrZXIgb2JqZWN0IGluIHRoZSBhY2NvdW50LCBwdXQgaXQgaW4gdGhlIHN0YWtpbmcgY29sbGVjdGlvbgogICAgICAgIGlmIHNpZ25lci5zdG9yYWdlLmJvcnJvdzwmRmxvd0lEVGFibGVTdGFraW5nLk5vZGVTdGFrZXI+KGZyb206IEZsb3dJRFRhYmxlU3Rha2luZy5Ob2RlU3Rha2VyU3RvcmFnZVBhdGgpICE9IG5pbCB7CiAgICAgICAgICAgIGxldCBub2RlIDwtIHNpZ25lci5zdG9yYWdlLmxvYWQ8QEZsb3dJRFRhYmxlU3Rha2luZy5Ob2RlU3Rha2VyPihmcm9tOiBGbG93SURUYWJsZVN0YWtpbmcuTm9kZVN0YWtlclN0b3JhZ2VQYXRoKSEKICAgICAgICAgICAgY29sbGVjdGlvblJlZi5hZGROb2RlT2JqZWN0KDwtbm9kZSwgbWFjaGluZUFjY291bnRJbmZvOiBuaWwpCiAgICAgICAgfQoKICAgICAgICAvLyBJZiB0aGVyZSBpcyBhIGRlbGVnYXRvciBvYmplY3QgaW4gdGhlIGFjY291bnQsIHB1dCBpdCBpbiB0aGUgc3Rha2luZyBjb2xsZWN0aW9uCiAgICAgICAgaWYgc2lnbmVyLnN0b3JhZ2UuYm9ycm93PCZGbG93SURUYWJsZVN0YWtpbmcuTm9kZURlbGVnYXRvcj4oZnJvbTogRmxvd0lEVGFibGVTdGFraW5nLkRlbGVnYXRvclN0b3JhZ2VQYXRoKSAhPSBuaWwgewogICAgICAgICAgICBsZXQgZGVsZWdhdG9yIDwtIHNpZ25lci5zdG9yYWdlLmxvYWQ8QEZsb3dJRFRhYmxlU3Rha2luZy5Ob2RlRGVsZWdhdG9yPihmcm9tOiBGbG93SURUYWJsZVN0YWtpbmcuRGVsZWdhdG9yU3RvcmFnZVBhdGgpIQogICAgICAgICAgICBjb2xsZWN0aW9uUmVmLmFkZERlbGVnYXRvck9iamVjdCg8LWRlbGVnYXRvcikKICAgICAgICB9CiAgICB9Cn0\u003d", - "unstake": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdW5zdGFrZSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKIGltcG9ydCBGbG93U3Rha2luZ0NvbGxlY3Rpb24gZnJvbSAweDk1ZTAxOWExN2QwZTIzZDcKCgovLy8gUmVxdWVzdHMgdW5zdGFraW5nIGZvciB0aGUgc3BlY2lmaWVkIG5vZGUgb3IgZGVsZWdhdG9yIGluIHRoZSBzdGFraW5nIGNvbGxlY3Rpb24KCnRyYW5zYWN0aW9uKG5vZGVJRDogU3RyaW5nLCBkZWxlZ2F0b3JJRDogVUludDMyPywgYW1vdW50OiBVRml4NjQpIHsKICAgIAogICAgbGV0IHN0YWtpbmdDb2xsZWN0aW9uUmVmOiBhdXRoKEZsb3dTdGFraW5nQ29sbGVjdGlvbi5Db2xsZWN0aW9uT3duZXIpICZGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb24KCiAgICBwcmVwYXJlKGFjY291bnQ6IGF1dGgoQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZiA9IGFjY291bnQuc3RvcmFnZS5ib3Jyb3c8YXV0aChGbG93U3Rha2luZ0NvbGxlY3Rpb24uQ29sbGVjdGlvbk93bmVyKSAmRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uPihmcm9tOiBGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb25TdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgYSByZWZlcmVuY2UgdG8gYSBTdGFraW5nQ29sbGVjdGlvbiBpbiB0aGUgcHJpbWFyeSB1c2VyJ3MgYWNjb3VudCIpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZi5yZXF1ZXN0VW5zdGFraW5nKG5vZGVJRDogbm9kZUlELCBkZWxlZ2F0b3JJRDogZGVsZWdhdG9ySUQsIGFtb3VudDogYW1vdW50KQogICAgfQp9", - "withdrawLocked": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgd2l0aGRyYXdMb2NrZWQgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhGVU5HSUJMRVRPS0VOQUREUkVTUwppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHhGTE9XVE9LRU5BRERSRVNTCmltcG9ydCBMb2NrZWRUb2tlbnMgZnJvbSAweExPQ0tFRFRPS0VOQUREUkVTUwoKdHJhbnNhY3Rpb24oYW1vdW50OiBVRml4NjQpIHsKCiAgICBsZXQgaG9sZGVyUmVmOiBhdXRoKExvY2tlZFRva2Vucy5Ub2tlbk9wZXJhdGlvbnMsIEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZMb2NrZWRUb2tlbnMuVG9rZW5Ib2xkZXIKICAgIGxldCB2YXVsdFJlZjogYXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAmRmxvd1Rva2VuLlZhdWx0CgogICAgcHJlcGFyZShhY2N0OiBhdXRoKEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgIHNlbGYuaG9sZGVyUmVmID0gYWNjdC5zdG9yYWdlLmJvcnJvdzxhdXRoKExvY2tlZFRva2Vucy5Ub2tlbk9wZXJhdGlvbnMsIEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZMb2NrZWRUb2tlbnMuVG9rZW5Ib2xkZXI+KGZyb206IExvY2tlZFRva2Vucy5Ub2tlbkhvbGRlclN0b3JhZ2VQYXRoKQogICAgICAgICAgICA/PyBwYW5pYygiVGhlIHByaW1hcnkgdXNlciBhY2NvdW50IGRvZXMgbm90IGhhdmUgYW4gYXNzb2NpYXRlZCBsb2NrZWQgYWNjb3VudCIpCgogICAgICAgIHNlbGYudmF1bHRSZWYgPSBhY2N0LnN0b3JhZ2UuYm9ycm93PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJkZsb3dUb2tlbi5WYXVsdD4oZnJvbTogL3N0b3JhZ2UvZmxvd1Rva2VuVmF1bHQpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IGZsb3cgdG9rZW4gdmF1bHQgcmVmIikKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBzZWxmLnZhdWx0UmVmLmRlcG9zaXQoZnJvbTogPC1zZWxmLmhvbGRlclJlZi53aXRoZHJhdyhhbW91bnQ6IGFtb3VudCkpCiAgICB9Cn0\u003d", - "withdrawReward": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgd2l0aGRyYXdSZXdhcmQgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGbG93U3Rha2luZ0NvbGxlY3Rpb24gZnJvbSAweDk1ZTAxOWExN2QwZTIzZDcKCgovLy8gUmVxdWVzdCB0byB3aXRoZHJhdyByZXdhcmRlZCB0b2tlbnMgZm9yIHRoZSBzcGVjaWZpZWQgbm9kZSBvciBkZWxlZ2F0b3IgaW4gdGhlIHN0YWtpbmcgY29sbGVjdGlvbgovLy8gVGhlIHRva2VucyBhcmUgYXV0b21hdGljYWxseSBkZXBvc2l0ZWQgdG8gdGhlIHVubG9ja2VkIGFjY291bnQgdmF1bHQgZmlyc3QsCi8vLyBBbmQgdGhlbiBhbnkgbG9ja2VkIHRva2VucyBhcmUgZGVwb3NpdGVkIGludG8gdGhlIGxvY2tlZCBhY2NvdW50IHZhdWx0Cgp0cmFuc2FjdGlvbihub2RlSUQ6IFN0cmluZywgZGVsZWdhdG9ySUQ6IFVJbnQzMj8sIGFtb3VudDogVUZpeDY0KSB7CiAgICAKICAgIGxldCBzdGFraW5nQ29sbGVjdGlvblJlZjogYXV0aChGbG93U3Rha2luZ0NvbGxlY3Rpb24uQ29sbGVjdGlvbk93bmVyKSAmRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uCgogICAgcHJlcGFyZShhY2NvdW50OiBhdXRoKEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgIHNlbGYuc3Rha2luZ0NvbGxlY3Rpb25SZWYgPSBhY2NvdW50LnN0b3JhZ2UuYm9ycm93PGF1dGgoRmxvd1N0YWtpbmdDb2xsZWN0aW9uLkNvbGxlY3Rpb25Pd25lcikgJkZsb3dTdGFraW5nQ29sbGVjdGlvbi5TdGFraW5nQ29sbGVjdGlvbj4oZnJvbTogRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uU3RvcmFnZVBhdGgpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IGEgcmVmZXJlbmNlIHRvIGEgU3Rha2luZ0NvbGxlY3Rpb24gaW4gdGhlIHByaW1hcnkgdXNlcidzIGFjY291bnQiKQogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIHNlbGYuc3Rha2luZ0NvbGxlY3Rpb25SZWYud2l0aGRyYXdSZXdhcmRlZFRva2Vucyhub2RlSUQ6IG5vZGVJRCwgZGVsZWdhdG9ySUQ6IGRlbGVnYXRvcklELCBhbW91bnQ6IGFtb3VudCkKICAgIH0KfQ\u003d\u003d", - "withdrawUnstaked": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgd2l0aGRyYXdVbnN0YWtlZCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKIGltcG9ydCBGbG93U3Rha2luZ0NvbGxlY3Rpb24gZnJvbSAweDk1ZTAxOWExN2QwZTIzZDcKCgovLy8gUmVxdWVzdCB0byB3aXRoZHJhdyB1bnN0YWtlZCB0b2tlbnMgZm9yIHRoZSBzcGVjaWZpZWQgbm9kZSBvciBkZWxlZ2F0b3IgaW4gdGhlIHN0YWtpbmcgY29sbGVjdGlvbgovLy8gVGhlIHRva2VucyBhcmUgYXV0b21hdGljYWxseSBkZXBvc2l0ZWQgdG8gdGhlIHVubG9ja2VkIGFjY291bnQgdmF1bHQgZmlyc3QsCi8vLyBBbmQgdGhlbiBhbnkgbG9ja2VkIHRva2VucyBhcmUgZGVwb3NpdGVkIGludG8gdGhlIGxvY2tlZCBhY2NvdW50IHZhdWx0IGlmIGl0IGlzIHRoZXJlCgp0cmFuc2FjdGlvbihub2RlSUQ6IFN0cmluZywgZGVsZWdhdG9ySUQ6IFVJbnQzMj8sIGFtb3VudDogVUZpeDY0KSB7CiAgICAKICAgIGxldCBzdGFraW5nQ29sbGVjdGlvblJlZjogYXV0aChGbG93U3Rha2luZ0NvbGxlY3Rpb24uQ29sbGVjdGlvbk93bmVyKSAmRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uCgogICAgcHJlcGFyZShhY2NvdW50OiBhdXRoKEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgIHNlbGYuc3Rha2luZ0NvbGxlY3Rpb25SZWYgPSBhY2NvdW50LnN0b3JhZ2UuYm9ycm93PGF1dGgoRmxvd1N0YWtpbmdDb2xsZWN0aW9uLkNvbGxlY3Rpb25Pd25lcikgJkZsb3dTdGFraW5nQ29sbGVjdGlvbi5TdGFraW5nQ29sbGVjdGlvbj4oZnJvbTogRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uU3RvcmFnZVBhdGgpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IGEgcmVmZXJlbmNlIHRvIGEgU3Rha2luZ0NvbGxlY3Rpb24gaW4gdGhlIHByaW1hcnkgdXNlcidzIGFjY291bnQiKQogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIHNlbGYuc3Rha2luZ0NvbGxlY3Rpb25SZWYud2l0aGRyYXdVbnN0YWtlZFRva2Vucyhub2RlSUQ6IG5vZGVJRCwgZGVsZWdhdG9ySUQ6IGRlbGVnYXRvcklELCBhbW91bnQ6IGFtb3VudCkKICAgIH0KfQ\u003d\u003d" + "checkSetup": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY2hlY2tTZXR1cCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dTdGFraW5nQ29sbGVjdGlvbiBmcm9tIDB4OTVlMDE5YTE3ZDBlMjNkNwoKCi8vLyBEZXRlcm1pbmVzIGlmIGFuIGFjY291bnQgaXMgc2V0IHVwIHdpdGggYSBTdGFraW5nIENvbGxlY3Rpb24KCmFjY2VzcyhhbGwpIGZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBCb29sIHsKICAgIHJldHVybiBGbG93U3Rha2luZ0NvbGxlY3Rpb24uZG9lc0FjY291bnRIYXZlU3Rha2luZ0NvbGxlY3Rpb24oYWRkcmVzczogYWRkcmVzcykKfQ\u003d\u003d", + "checkStakingEnabled": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY2hlY2tTdGFraW5nRW5hYmxlZCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dJRFRhYmxlU3Rha2luZyBmcm9tIDB4OWVjYTJiMzhiMThiNWRmZQoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKCk6Qm9vbCB7CiAgICByZXR1cm4gRmxvd0lEVGFibGVTdGFraW5nLnN0YWtpbmdFbmFibGVkKCkKfQ\u003d\u003d", + "closeStake": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY2xvc2VTdGFrZSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dTdGFraW5nQ29sbGVjdGlvbiBmcm9tIDB4OTVlMDE5YTE3ZDBlMjNkNwoKCi8vIENsb3NlcyBvdXQgYSBzdGFraW5nIG9iamVjdCBpbiB0aGUgc3Rha2luZyBjb2xsZWN0aW9uCi8vIFRoaXMgZG9lcyBub3QgcmVtb3ZlIHRoZSByZWNvcmQgZnJvbSB0aGUgaWRlbnRpdHkgdGFibGUsCi8vIGJ1dCBpdCBkb2VzIG1lYW4gdGhhdCB0aGUgYWNjb3VudCB0aGF0IGNsb3NlcyBpdCBjYW5ub3QgZXZlciBhY2Nlc3MgaXQgYWdhaW4KCnRyYW5zYWN0aW9uKG5vZGVJRDogU3RyaW5nLCBkZWxlZ2F0b3JJRDogVUludDMyPykgewogICAgCiAgICBsZXQgc3Rha2luZ0NvbGxlY3Rpb25SZWY6IGF1dGgoRmxvd1N0YWtpbmdDb2xsZWN0aW9uLkNvbGxlY3Rpb25Pd25lcikgJkZsb3dTdGFraW5nQ29sbGVjdGlvbi5TdGFraW5nQ29sbGVjdGlvbgoKICAgIHByZXBhcmUoYWNjb3VudDogYXV0aChCb3Jyb3dWYWx1ZSkgJkFjY291bnQpIHsKICAgICAgICBzZWxmLnN0YWtpbmdDb2xsZWN0aW9uUmVmID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzxhdXRoKEZsb3dTdGFraW5nQ29sbGVjdGlvbi5Db2xsZWN0aW9uT3duZXIpICZGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb24+KGZyb206IEZsb3dTdGFraW5nQ29sbGVjdGlvbi5TdGFraW5nQ29sbGVjdGlvblN0b3JhZ2VQYXRoKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBhIHJlZmVyZW5jZSB0byBhIFN0YWtpbmdDb2xsZWN0aW9uIGluIHRoZSBwcmltYXJ5IHVzZXIncyBhY2NvdW50IikKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBzZWxmLnN0YWtpbmdDb2xsZWN0aW9uUmVmLmNsb3NlU3Rha2Uobm9kZUlEOiBub2RlSUQsIGRlbGVnYXRvcklEOiBkZWxlZ2F0b3JJRCkKICAgIH0KfQ\u003d\u003d", + "createDelegator": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY3JlYXRlRGVsZWdhdG9yIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd1N0YWtpbmdDb2xsZWN0aW9uIGZyb20gMHg5NWUwMTlhMTdkMGUyM2Q3CgoKLy8vIFJlZ2lzdGVycyBhIGRlbGVnYXRvciBpbiB0aGUgc3Rha2luZyBjb2xsZWN0aW9uIHJlc291cmNlCi8vLyBmb3IgdGhlIHNwZWNpZmllZCBub2RlSUQgYW5kIHRoZSBhbW91bnQgb2YgdG9rZW5zIHRvIGNvbW1pdAoKdHJhbnNhY3Rpb24oaWQ6IFN0cmluZywgYW1vdW50OiBVRml4NjQpIHsKICAgIAogICAgbGV0IHN0YWtpbmdDb2xsZWN0aW9uUmVmOiBhdXRoKEZsb3dTdGFraW5nQ29sbGVjdGlvbi5Db2xsZWN0aW9uT3duZXIpICZGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb24KCiAgICBwcmVwYXJlKGFjY291bnQ6IGF1dGgoQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZiA9IGFjY291bnQuc3RvcmFnZS5ib3Jyb3c8YXV0aChGbG93U3Rha2luZ0NvbGxlY3Rpb24uQ29sbGVjdGlvbk93bmVyKSAmRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uPihmcm9tOiBGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb25TdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgYSByZWZlcmVuY2UgdG8gYSBTdGFraW5nQ29sbGVjdGlvbiBpbiB0aGUgcHJpbWFyeSB1c2VyJ3MgYWNjb3VudCIpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZi5yZWdpc3RlckRlbGVnYXRvcihub2RlSUQ6IGlkLCBhbW91bnQ6IGFtb3VudCkgICAgICAKICAgIH0KfQ\u003d\u003d", + "createStake": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY3JlYXRlU3Rha2UgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGbG93U3Rha2luZ0NvbGxlY3Rpb24gZnJvbSAweDk1ZTAxOWExN2QwZTIzZDcKCgovLy8gQ29tbWl0cyBuZXcgdG9rZW5zIHRvIHN0YWtlIGZvciB0aGUgc3BlY2lmaWVkIG5vZGUgb3IgZGVsZWdhdG9yIGluIHRoZSBzdGFraW5nIGNvbGxlY3Rpb24KLy8vIFRoZSB0b2tlbnMgZnJvbSB0aGUgbG9ja2VkIHZhdWx0IGFyZSB1c2VkIGZpcnN0LCBpZiBpdCBleGlzdHMKLy8vIGZvbGxvd2VkIGJ5IHRoZSB0b2tlbnMgZnJvbSB0aGUgdW5sb2NrZWQgdmF1bHQKCnRyYW5zYWN0aW9uKG5vZGVJRDogU3RyaW5nLCBkZWxlZ2F0b3JJRDogVUludDMyPywgYW1vdW50OiBVRml4NjQpIHsKICAgIAogICAgbGV0IHN0YWtpbmdDb2xsZWN0aW9uUmVmOiBhdXRoKEZsb3dTdGFraW5nQ29sbGVjdGlvbi5Db2xsZWN0aW9uT3duZXIpICZGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb24KCiAgICBwcmVwYXJlKGFjY291bnQ6IGF1dGgoQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZiA9IGFjY291bnQuc3RvcmFnZS5ib3Jyb3c8YXV0aChGbG93U3Rha2luZ0NvbGxlY3Rpb24uQ29sbGVjdGlvbk93bmVyKSAmRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uPihmcm9tOiBGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb25TdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgYSByZWZlcmVuY2UgdG8gYSBTdGFraW5nQ29sbGVjdGlvbiBpbiB0aGUgcHJpbWFyeSB1c2VyJ3MgYWNjb3VudCIpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZi5zdGFrZU5ld1Rva2Vucyhub2RlSUQ6IG5vZGVJRCwgZGVsZWdhdG9ySUQ6IGRlbGVnYXRvcklELCBhbW91bnQ6IGFtb3VudCkKICAgIH0KfQ\u003d\u003d", + "getApr": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QXByIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd0lEVGFibGVTdGFraW5nIGZyb20gMHg5ZWNhMmIzOGIxOGI1ZGZlCgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oKTogVUZpeDY0IHsKICAgIGxldCBhcHIgPSBGbG93SURUYWJsZVN0YWtpbmcuZ2V0RXBvY2hUb2tlblBheW91dCgpIC8gRmxvd0lEVGFibGVTdGFraW5nLmdldFRvdGFsU3Rha2VkKCkgLyA3LjAgKiAzNjUuMCAqICgxLjAgLSBGbG93SURUYWJsZVN0YWtpbmcuZ2V0UmV3YXJkQ3V0UGVyY2VudGFnZSgpKQogICAgcmV0dXJuIGFwcgp9", + "getApyWeekly": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QXB5V2Vla2x5IC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd0lEVGFibGVTdGFraW5nIGZyb20gMHg5ZWNhMmIzOGIxOGI1ZGZlCgoKYWNjZXNzKGFsbCkgZnVuIG1haW4oKTogVUZpeDY0IHsKICAgIGxldCBhcHIgPSBGbG93SURUYWJsZVN0YWtpbmcuZ2V0RXBvY2hUb2tlblBheW91dCgpIC8gRmxvd0lEVGFibGVTdGFraW5nLmdldFRvdGFsU3Rha2VkKCkgKiA1NC4wICogKDEuMCAtIEZsb3dJRFRhYmxlU3Rha2luZy5nZXRSZXdhcmRDdXRQZXJjZW50YWdlKCkpCiAgICByZXR1cm4gYXByCn0\u003d", + "getDelegatesIndo": "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\u003d\u003d", + "getDelegatesInfo": "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", + "getDelegatesInfoArray": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0RGVsZWdhdGVzSW5mb0FycmF5IC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgoKaW1wb3J0IEZsb3dTdGFraW5nQ29sbGVjdGlvbiBmcm9tIDB4OTVlMDE5YTE3ZDBlMjNkNwoKaW1wb3J0IEZsb3dJRFRhYmxlU3Rha2luZyBmcm9tIDB4OWVjYTJiMzhiMThiNWRmZQoKaW1wb3J0IExvY2tlZFRva2VucyBmcm9tIDB4OTVlMDE5YTE3ZDBlMjNkNwoKICAgICAgICAKYWNjZXNzKGFsbCkgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IFtGbG93SURUYWJsZVN0YWtpbmcuRGVsZWdhdG9ySW5mb10gewogICAgcmV0dXJuIEZsb3dTdGFraW5nQ29sbGVjdGlvbi5nZXRBbGxEZWxlZ2F0b3JJbmZvKGFkZHJlc3M6IGFkZHJlc3MpCn0\u003d", + "getDelegatesInfoArrayV2": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0RGVsZWdhdGVzSW5mb0FycmF5VjIgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCgppbXBvcnQgRmxvd1N0YWtpbmdDb2xsZWN0aW9uIGZyb20gMHg5NWUwMTlhMTdkMGUyM2Q3CgppbXBvcnQgRmxvd0lEVGFibGVTdGFraW5nIGZyb20gMHg5ZWNhMmIzOGIxOGI1ZGZlCgppbXBvcnQgTG9ja2VkVG9rZW5zIGZyb20gMHg5NWUwMTlhMTdkMGUyM2Q3CgogICAgICAgIAphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzKTogW0Zsb3dJRFRhYmxlU3Rha2luZy5EZWxlZ2F0b3JJbmZvXT8gewogICAgdmFyIHJlczogW0Zsb3dJRFRhYmxlU3Rha2luZy5EZWxlZ2F0b3JJbmZvXT8gPSBuaWwKCiAgICBsZXQgaW5pdGVkID0gRmxvd1N0YWtpbmdDb2xsZWN0aW9uLmRvZXNBY2NvdW50SGF2ZVN0YWtpbmdDb2xsZWN0aW9uKGFkZHJlc3M6IGFkZHJlc3MpCgogICAgaWYgaW5pdGVkIHsKICAgICAgICByZXMgPSBGbG93U3Rha2luZ0NvbGxlY3Rpb24uZ2V0QWxsRGVsZWdhdG9ySW5mbyhhZGRyZXNzOiBhZGRyZXNzKQogICAgfQogICAgcmV0dXJuIHJlcwp9", + "getDelegatesInfoV2": "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\u003d", + "getDelegatorInfo": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0RGVsZWdhdG9ySW5mbyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dJRFRhYmxlU3Rha2luZyBmcm9tIDB4OWVjYTJiMzhiMThiNWRmZQoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKG5vZGVJRDogU3RyaW5nLCBkZWxlZ2F0b3JJRDogVUludDMyKTogRmxvd0lEVGFibGVTdGFraW5nLkRlbGVnYXRvckluZm8gewogIHJldHVybiBGbG93SURUYWJsZVN0YWtpbmcuRGVsZWdhdG9ySW5mbyhub2RlSUQ6IG5vZGVJRCwgZGVsZWdhdG9ySUQ6IGRlbGVnYXRvcklEKQp9", + "getEpochMetadata": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0RXBvY2hNZXRhZGF0YSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZsb3dFcG9jaCBmcm9tIDB4OWVjYTJiMzhiMThiNWRmZQoKCmFjY2VzcyhhbGwpIGZ1biBtYWluKGVwb2NoQ291bnRlcjogVUludDY0KTogRmxvd0Vwb2NoLkVwb2NoTWV0YWRhdGEgewogICAgcmV0dXJuIEZsb3dFcG9jaC5nZXRFcG9jaE1ldGFkYXRhKGVwb2NoQ291bnRlcikhCn0\u003d", + "getNodeInfo": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0Tm9kZUluZm8gLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGbG93SURUYWJsZVN0YWtpbmcgZnJvbSAweDllY2EyYjM4YjE4YjVkZmUKCgphY2Nlc3MoYWxsKSBmdW4gbWFpbihub2RlSUQ6IFN0cmluZyk6IEZsb3dJRFRhYmxlU3Rha2luZy5Ob2RlSW5mbyB7CiAgcmV0dXJuIEZsb3dJRFRhYmxlU3Rha2luZy5Ob2RlSW5mbyhub2RlSUQ6IG5vZGVJRCkKfQ\u003d\u003d", + "getNodesInfo": "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", + "getStakeInfo": "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", + "getStakingInfo": "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", + "restakeReward": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcmVzdGFrZVJld2FyZCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKIGltcG9ydCBGbG93U3Rha2luZ0NvbGxlY3Rpb24gZnJvbSAweDk1ZTAxOWExN2QwZTIzZDcKCgovLy8gQ29tbWl0cyByZXdhcmRlZCB0b2tlbnMgdG8gc3Rha2UgZm9yIHRoZSBzcGVjaWZpZWQgbm9kZSBvciBkZWxlZ2F0b3IgaW4gdGhlIHN0YWtpbmcgY29sbGVjdGlvbgoKdHJhbnNhY3Rpb24obm9kZUlEOiBTdHJpbmcsIGRlbGVnYXRvcklEOiBVSW50MzI/LCBhbW91bnQ6IFVGaXg2NCkgewogICAgCiAgICBsZXQgc3Rha2luZ0NvbGxlY3Rpb25SZWY6IGF1dGgoRmxvd1N0YWtpbmdDb2xsZWN0aW9uLkNvbGxlY3Rpb25Pd25lcikgJkZsb3dTdGFraW5nQ29sbGVjdGlvbi5TdGFraW5nQ29sbGVjdGlvbgoKICAgIHByZXBhcmUoYWNjb3VudDogYXV0aChCb3Jyb3dWYWx1ZSkgJkFjY291bnQpIHsKICAgICAgICBzZWxmLnN0YWtpbmdDb2xsZWN0aW9uUmVmID0gYWNjb3VudC5zdG9yYWdlLmJvcnJvdzxhdXRoKEZsb3dTdGFraW5nQ29sbGVjdGlvbi5Db2xsZWN0aW9uT3duZXIpICZGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb24+KGZyb206IEZsb3dTdGFraW5nQ29sbGVjdGlvbi5TdGFraW5nQ29sbGVjdGlvblN0b3JhZ2VQYXRoKQogICAgICAgICAgICA/PyBwYW5pYygiQ291bGQgbm90IGJvcnJvdyBhIHJlZmVyZW5jZSB0byBhIFN0YWtpbmdDb2xsZWN0aW9uIGluIHRoZSBwcmltYXJ5IHVzZXIncyBhY2NvdW50IikKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBzZWxmLnN0YWtpbmdDb2xsZWN0aW9uUmVmLnN0YWtlUmV3YXJkZWRUb2tlbnMobm9kZUlEOiBub2RlSUQsIGRlbGVnYXRvcklEOiBkZWxlZ2F0b3JJRCwgYW1vdW50OiBhbW91bnQpCiAgICB9Cn0\u003d", + "restakeUnstaked": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcmVzdGFrZVVuc3Rha2VkIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRmxvd1N0YWtpbmdDb2xsZWN0aW9uIGZyb20gMHg5NWUwMTlhMTdkMGUyM2Q3CgoKLy8vIENvbW1pdHMgdW5zdGFrZWQgdG9rZW5zIHRvIHN0YWtlIGZvciB0aGUgc3BlY2lmaWVkIG5vZGUgb3IgZGVsZWdhdG9yIGluIHRoZSBzdGFraW5nIGNvbGxlY3Rpb24KCnRyYW5zYWN0aW9uKG5vZGVJRDogU3RyaW5nLCBkZWxlZ2F0b3JJRDogVUludDMyPywgYW1vdW50OiBVRml4NjQpIHsKICAgIAogICAgbGV0IHN0YWtpbmdDb2xsZWN0aW9uUmVmOiBhdXRoKEZsb3dTdGFraW5nQ29sbGVjdGlvbi5Db2xsZWN0aW9uT3duZXIpICZGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb24KCiAgICBwcmVwYXJlKGFjY291bnQ6IGF1dGgoQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZiA9IGFjY291bnQuc3RvcmFnZS5ib3Jyb3c8YXV0aChGbG93U3Rha2luZ0NvbGxlY3Rpb24uQ29sbGVjdGlvbk93bmVyKSAmRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uPihmcm9tOiBGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb25TdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgYSByZWZlcmVuY2UgdG8gYSBTdGFraW5nQ29sbGVjdGlvbiBpbiB0aGUgcHJpbWFyeSB1c2VyJ3MgYWNjb3VudCIpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZi5zdGFrZVVuc3Rha2VkVG9rZW5zKG5vZGVJRDogbm9kZUlELCBkZWxlZ2F0b3JJRDogZGVsZWdhdG9ySUQsIGFtb3VudDogYW1vdW50KQogICAgfQp9", + "setup": "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\u003d", + "unstake": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdW5zdGFrZSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKIGltcG9ydCBGbG93U3Rha2luZ0NvbGxlY3Rpb24gZnJvbSAweDk1ZTAxOWExN2QwZTIzZDcKCgovLy8gUmVxdWVzdHMgdW5zdGFraW5nIGZvciB0aGUgc3BlY2lmaWVkIG5vZGUgb3IgZGVsZWdhdG9yIGluIHRoZSBzdGFraW5nIGNvbGxlY3Rpb24KCnRyYW5zYWN0aW9uKG5vZGVJRDogU3RyaW5nLCBkZWxlZ2F0b3JJRDogVUludDMyPywgYW1vdW50OiBVRml4NjQpIHsKICAgIAogICAgbGV0IHN0YWtpbmdDb2xsZWN0aW9uUmVmOiBhdXRoKEZsb3dTdGFraW5nQ29sbGVjdGlvbi5Db2xsZWN0aW9uT3duZXIpICZGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb24KCiAgICBwcmVwYXJlKGFjY291bnQ6IGF1dGgoQm9ycm93VmFsdWUpICZBY2NvdW50KSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZiA9IGFjY291bnQuc3RvcmFnZS5ib3Jyb3c8YXV0aChGbG93U3Rha2luZ0NvbGxlY3Rpb24uQ29sbGVjdGlvbk93bmVyKSAmRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uPihmcm9tOiBGbG93U3Rha2luZ0NvbGxlY3Rpb24uU3Rha2luZ0NvbGxlY3Rpb25TdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgYSByZWZlcmVuY2UgdG8gYSBTdGFraW5nQ29sbGVjdGlvbiBpbiB0aGUgcHJpbWFyeSB1c2VyJ3MgYWNjb3VudCIpCiAgICB9CgogICAgZXhlY3V0ZSB7CiAgICAgICAgc2VsZi5zdGFraW5nQ29sbGVjdGlvblJlZi5yZXF1ZXN0VW5zdGFraW5nKG5vZGVJRDogbm9kZUlELCBkZWxlZ2F0b3JJRDogZGVsZWdhdG9ySUQsIGFtb3VudDogYW1vdW50KQogICAgfQp9", + "withdrawLocked": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgd2l0aGRyYXdMb2NrZWQgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhGVU5HSUJMRVRPS0VOQUREUkVTUwppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHhGTE9XVE9LRU5BRERSRVNTCmltcG9ydCBMb2NrZWRUb2tlbnMgZnJvbSAweExPQ0tFRFRPS0VOQUREUkVTUwoKdHJhbnNhY3Rpb24oYW1vdW50OiBVRml4NjQpIHsKCiAgICBsZXQgaG9sZGVyUmVmOiBhdXRoKExvY2tlZFRva2Vucy5Ub2tlbk9wZXJhdGlvbnMsIEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZMb2NrZWRUb2tlbnMuVG9rZW5Ib2xkZXIKICAgIGxldCB2YXVsdFJlZjogYXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAmRmxvd1Rva2VuLlZhdWx0CgogICAgcHJlcGFyZShhY2N0OiBhdXRoKEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgIHNlbGYuaG9sZGVyUmVmID0gYWNjdC5zdG9yYWdlLmJvcnJvdzxhdXRoKExvY2tlZFRva2Vucy5Ub2tlbk9wZXJhdGlvbnMsIEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZMb2NrZWRUb2tlbnMuVG9rZW5Ib2xkZXI+KGZyb206IExvY2tlZFRva2Vucy5Ub2tlbkhvbGRlclN0b3JhZ2VQYXRoKQogICAgICAgICAgICA/PyBwYW5pYygiVGhlIHByaW1hcnkgdXNlciBhY2NvdW50IGRvZXMgbm90IGhhdmUgYW4gYXNzb2NpYXRlZCBsb2NrZWQgYWNjb3VudCIpCgogICAgICAgIHNlbGYudmF1bHRSZWYgPSBhY2N0LnN0b3JhZ2UuYm9ycm93PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJkZsb3dUb2tlbi5WYXVsdD4oZnJvbTogL3N0b3JhZ2UvZmxvd1Rva2VuVmF1bHQpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IGZsb3cgdG9rZW4gdmF1bHQgcmVmIikKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICBzZWxmLnZhdWx0UmVmLmRlcG9zaXQoZnJvbTogPC1zZWxmLmhvbGRlclJlZi53aXRoZHJhdyhhbW91bnQ6IGFtb3VudCkpCiAgICB9Cn0\u003d", + "withdrawReward": "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\u003d\u003d", + "withdrawUnstaked": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgd2l0aGRyYXdVbnN0YWtlZCAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKIGltcG9ydCBGbG93U3Rha2luZ0NvbGxlY3Rpb24gZnJvbSAweDk1ZTAxOWExN2QwZTIzZDcKCgovLy8gUmVxdWVzdCB0byB3aXRoZHJhdyB1bnN0YWtlZCB0b2tlbnMgZm9yIHRoZSBzcGVjaWZpZWQgbm9kZSBvciBkZWxlZ2F0b3IgaW4gdGhlIHN0YWtpbmcgY29sbGVjdGlvbgovLy8gVGhlIHRva2VucyBhcmUgYXV0b21hdGljYWxseSBkZXBvc2l0ZWQgdG8gdGhlIHVubG9ja2VkIGFjY291bnQgdmF1bHQgZmlyc3QsCi8vLyBBbmQgdGhlbiBhbnkgbG9ja2VkIHRva2VucyBhcmUgZGVwb3NpdGVkIGludG8gdGhlIGxvY2tlZCBhY2NvdW50IHZhdWx0IGlmIGl0IGlzIHRoZXJlCgp0cmFuc2FjdGlvbihub2RlSUQ6IFN0cmluZywgZGVsZWdhdG9ySUQ6IFVJbnQzMj8sIGFtb3VudDogVUZpeDY0KSB7CiAgICAKICAgIGxldCBzdGFraW5nQ29sbGVjdGlvblJlZjogYXV0aChGbG93U3Rha2luZ0NvbGxlY3Rpb24uQ29sbGVjdGlvbk93bmVyKSAmRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uCgogICAgcHJlcGFyZShhY2NvdW50OiBhdXRoKEJvcnJvd1ZhbHVlKSAmQWNjb3VudCkgewogICAgICAgIHNlbGYuc3Rha2luZ0NvbGxlY3Rpb25SZWYgPSBhY2NvdW50LnN0b3JhZ2UuYm9ycm93PGF1dGgoRmxvd1N0YWtpbmdDb2xsZWN0aW9uLkNvbGxlY3Rpb25Pd25lcikgJkZsb3dTdGFraW5nQ29sbGVjdGlvbi5TdGFraW5nQ29sbGVjdGlvbj4oZnJvbTogRmxvd1N0YWtpbmdDb2xsZWN0aW9uLlN0YWtpbmdDb2xsZWN0aW9uU3RvcmFnZVBhdGgpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IGEgcmVmZXJlbmNlIHRvIGEgU3Rha2luZ0NvbGxlY3Rpb24gaW4gdGhlIHByaW1hcnkgdXNlcidzIGFjY291bnQiKQogICAgfQoKICAgIGV4ZWN1dGUgewogICAgICAgIHNlbGYuc3Rha2luZ0NvbGxlY3Rpb25SZWYud2l0aGRyYXdVbnN0YWtlZFRva2Vucyhub2RlSUQ6IG5vZGVJRCwgZGVsZWdhdG9ySUQ6IGRlbGVnYXRvcklELCBhbW91bnQ6IGFtb3VudCkKICAgIH0KfQ\u003d\u003d" }, "storage": { - "enableTokenStorage": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZW5hYmxlVG9rZW5TdG9yYWdlIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKaW1wb3J0IDxUb2tlbj4gZnJvbSA8VG9rZW5BZGRyZXNzPgoKdHJhbnNhY3Rpb24gewoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIENhcGFiaWxpdGllcykgJkFjY291bnQpIHsKCiAgICAgICAgaWYgc2lnbmVyLnN0b3JhZ2UuYm9ycm93PCY8VG9rZW4+LlZhdWx0Pihmcm9tOiA8VG9rZW5TdG9yYWdlUGF0aD4gKSA9PSBuaWwgewogICAgICAgICAgICBzaWduZXIuc3RvcmFnZS5zYXZlKDwtIDxUb2tlbj4uY3JlYXRlRW1wdHlWYXVsdCh2YXVsdFR5cGU6IFR5cGU8QDxUb2tlbj4uVmF1bHQ+KCkpLCB0bzogPFRva2VuU3RvcmFnZVBhdGg+KQogICAgICAgIH0KCiAgICAgICAgaWYgc2lnbmVyLmNhcGFiaWxpdGllcy5leGlzdHMoPFRva2VuUmVjZWl2ZXJQYXRoPikgPT0gZmFsc2UgewogICAgICAgICAgICBsZXQgcmVjZWl2ZXJDYXBhYmlsaXR5ID0gc2lnbmVyLmNhcGFiaWxpdGllcy5zdG9yYWdlLmlzc3VlPCY8VG9rZW4+LlZhdWx0Pig8VG9rZW5TdG9yYWdlUGF0aD4pCiAgICAgICAgICAgIHNpZ25lci5jYXBhYmlsaXRpZXMucHVibGlzaChyZWNlaXZlckNhcGFiaWxpdHksIGF0OiA8VG9rZW5SZWNlaXZlclBhdGg+KQogICAgICAgIAogICAgICAgIH0KICAgICAgIAogICAgICAgIGlmIHNpZ25lci5jYXBhYmlsaXRpZXMuZXhpc3RzKDxUb2tlbkJhbGFuY2VQYXRoPikgPT0gZmFsc2UgewogICAgICAgICAgICBsZXQgYmFsYW5jZUNhcGFiaWxpdHkgPSBzaWduZXIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8JjxUb2tlbj4uVmF1bHQ+KDxUb2tlblN0b3JhZ2VQYXRoPikKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5wdWJsaXNoKGJhbGFuY2VDYXBhYmlsaXR5LCBhdDogPFRva2VuQmFsYW5jZVBhdGg+KQogICAgICAgIH0KICAgIAogICAgfQp9", - "enableTokenStorageV2": "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\u003d\u003d", - "getBasicPublicItems": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QmFzaWNQdWJsaWNJdGVtcyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKYWNjZXNzKGFsbClzdHJ1Y3QgSXRlbSB7CiAgYWNjZXNzKGFsbClsZXQgYWRkcmVzczogQWRkcmVzcwogIGFjY2VzcyhhbGwpbGV0IHBhdGg6IFN0cmluZwogIGFjY2VzcyhhbGwpbGV0IHRhcmdldFBhdGg6IFN0cmluZz8KCiAgaW5pdChhZGRyZXNzOiBBZGRyZXNzLCBwYXRoOiBTdHJpbmcsIHRhcmdldFBhdGg6IFN0cmluZz8pIHsKICAgIHNlbGYuYWRkcmVzcyA9IGFkZHJlc3MKICAgIHNlbGYucGF0aCA9IHBhdGgKICAgIHNlbGYudGFyZ2V0UGF0aCA9IHRhcmdldFBhdGgKICB9Cn0KCmFjY2VzcyhhbGwpZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IFtJdGVtXSB7CiAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgbGV0IGl0ZW1zOiBbSXRlbV0gPSBbXQoKCiAgZnVuIGVhY2hQYXRoKHBhdGg6IFB1YmxpY1BhdGgsIGNhcFR5cGU6IFR5cGUpOiBCb29sIHsKICAgIC8vIHRvZG8KICAgIGxldCBjYXAgPSBhY2NvdW50LmNhcGFiaWxpdGllcy5nZXQ8JkFueVN0cnVjdD4ocGF0aCkKICAgIHZhciB0YXJnZXRQYXRoID0gIiIKCiAgICBpZiBjYXAgIT0gbmlsIHsKICAgICAgdGFyZ2V0UGF0aCA9ICIxMiIgCiAgICB9CiAgICBsZXQgaXRlbSA9IEl0ZW0oYWRkcmVzczogYWRkcmVzcywgcGF0aDogcGF0aC50b1N0cmluZygpLCB0YXJnZXRQYXRoOiB0YXJnZXRQYXRoKQogICAgaXRlbXMuYXBwZW5kKGl0ZW0pCiAgICByZXR1cm4gdHJ1ZQogIH0KICBhY2NvdW50LnN0b3JhZ2UuZm9yRWFjaFB1YmxpYyhlYWNoUGF0aCkKCiAgcmV0dXJuIGl0ZW1zCn0\u003d", - "getPrivateItems": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0UHJpdmF0ZUl0ZW1zIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgphY2Nlc3MoYWxsKXN0cnVjdCBJdGVtIHsKICBhY2Nlc3MoYWxsKWxldCBhZGRyZXNzOiBBZGRyZXNzCiAgYWNjZXNzKGFsbClsZXQgcGF0aDogU3RyaW5nCiAgYWNjZXNzKGFsbClsZXQgdHlwZTogVHlwZQogIGFjY2VzcyhhbGwpbGV0IHRhcmdldFBhdGg6IFN0cmluZz8KCiAgaW5pdCgKICAgIGFkZHJlc3M6IEFkZHJlc3MsIAogICAgcGF0aDogU3RyaW5nLCAKICAgIHR5cGU6IFR5cGUsIAogICAgdGFyZ2V0UGF0aDogU3RyaW5nPwogICkgewogICAgc2VsZi5hZGRyZXNzID0gYWRkcmVzcwogICAgc2VsZi5wYXRoID0gcGF0aAogICAgc2VsZi50eXBlID0gdHlwZQogICAgc2VsZi50YXJnZXRQYXRoID0gdGFyZ2V0UGF0aAogIH0KfQoKYWNjZXNzKGFsbClmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzLCBwYXRoTWFwOiB7U3RyaW5nOiBCb29sfSk6IFtJdGVtXSB7CiAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCgogIGxldCBpdGVtczogW0l0ZW1dID0gW10KCiAgYWNjb3VudC5zdG9yYWdlLmZvckVhY2hQcml2YXRlKGZ1biAocGF0aDogUHJpdmF0ZVBhdGgsIHR5cGU6IFR5cGUpOiBCb29sIHsKICAgIGlmICFwYXRoTWFwLmNvbnRhaW5zS2V5KHBhdGgudG9TdHJpbmcoKSkgewogICAgICByZXR1cm4gdHJ1ZQogICAgfQoKICAgIHZhciB0YXJnZXRQYXRoOiBTdHJpbmc/ID0gbmlsCiAgICBpZiBsZXQgdGFyZ2V0ID0gYWNjb3VudC5nZXRMaW5rVGFyZ2V0KHBhdGgpIHsKICAgICAgdGFyZ2V0UGF0aCA9IHRhcmdldC50b1N0cmluZygpCiAgICB9CgogICAgbGV0IGl0ZW0gPSBJdGVtKAogICAgICBhZGRyZXNzOiBhZGRyZXNzLAogICAgICBwYXRoOiBwYXRoLnRvU3RyaW5nKCksCiAgICAgIHR5cGU6IHR5cGUsCiAgICAgIHRhcmdldFBhdGg6IHRhcmdldFBhdGgKICAgICkKCiAgICBpdGVtcy5hcHBlbmQoaXRlbSkKICAgIHJldHVybiB0cnVlCiAgfSkKCiAgcmV0dXJuIGl0ZW1zCn0\u003d", - "getPrivatePaths": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0UHJpdmF0ZVBhdGhzIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgphY2Nlc3MoYWxsKWZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBbUHJpdmF0ZVBhdGhdIHsKICBsZXQgYWNjb3VudCA9IGdldEF1dGhBY2NvdW50KGFkZHJlc3MpCiAgbGV0IGNsZWFuZFBhdGhzOiBbUHJpdmF0ZVBhdGhdID0gW10KICBmb3IgcGF0aCBpbiBhY2NvdW50LnByaXZhdGVQYXRocyB7CiAgICBjbGVhbmRQYXRocy5hcHBlbmQocGF0aCkKICB9CiAgcmV0dXJuIGNsZWFuZFBhdGhzCn0\u003d", - "getPublicItem": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0UHVibGljSXRlbSAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKLy8gQSB3b3JrYXJvdW5kIG1ldGhvZAppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCiAgCmFjY2VzcyhhbGwpIHN0cnVjdCBJdGVtIHsKICBhY2Nlc3MoYWxsKSBsZXQgYWRkcmVzczogQWRkcmVzcwogIGFjY2VzcyhhbGwpIGxldCBwYXRoOiBTdHJpbmcKICBhY2Nlc3MoYWxsKSBsZXQgdHlwZTogVHlwZQoKICBhY2Nlc3MoYWxsKSBsZXQgdGFyZ2V0UGF0aDogU3RyaW5nPwoKICBpbml0KAogICAgYWRkcmVzczogQWRkcmVzcywgCiAgICBwYXRoOiBTdHJpbmcsIAogICAgdHlwZTogVHlwZSwgCiAgICB0YXJnZXRQYXRoOiBTdHJpbmc/CiAgKSB7CiAgICBzZWxmLmFkZHJlc3MgPSBhZGRyZXNzCiAgICBzZWxmLnBhdGggPSBwYXRoCiAgICBzZWxmLnR5cGUgPSB0eXBlCiAgICBzZWxmLnRhcmdldFBhdGggPSB0YXJnZXRQYXRoCiAgfQp9CgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzLCBwYXRoTWFwOiB7U3RyaW5nOiBCb29sfSk6IFtJdGVtXSB7CiAgbGV0IGFjY291bnQgPSBnZXRBdXRoQWNjb3VudChhZGRyZXNzKQoKICBsZXQgaXRlbXM6IFtJdGVtXSA9IFtdCiAgYWNjb3VudC5mb3JFYWNoUHVibGljKGZ1biAocGF0aDogUHVibGljUGF0aCwgdHlwZTogVHlwZSk6IEJvb2wgewogICAgaWYgIXBhdGhNYXAuY29udGFpbnNLZXkocGF0aC50b1N0cmluZygpKSB7CiAgICAgIHJldHVybiB0cnVlCiAgICB9CgogICAgdmFyIHRhcmdldFBhdGg6IFN0cmluZz8gPSBuaWwKCiAgICBpZiBsZXQgdGFyZ2V0ID0gYWNjb3VudC5nZXRMaW5rVGFyZ2V0KHBhdGgpIHsKICAgICAgdGFyZ2V0UGF0aCA9IHRhcmdldC50b1N0cmluZygpCiAgICB9CgogICAgbGV0IGl0ZW0gPSBJdGVtKAogICAgICBhZGRyZXNzOiBhZGRyZXNzLAogICAgICBwYXRoOiBwYXRoLnRvU3RyaW5nKCksCiAgICAgIHR5cGU6IHR5cGUsCiAgICAgIHRhcmdldFBhdGg6IHRhcmdldFBhdGgKICAgICkKCiAgICBpdGVtcy5hcHBlbmQoaXRlbSkKICAgIHJldHVybiBmYWxzZQogIH0pCgogIHJldHVybiBpdGVtcwp9", - "getPublicItems": "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\u003d\u003d", - "getPublicPaths": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0UHVibGljUGF0aHMgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCnB1YiBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzKTogW1B1YmxpY1BhdGhdIHsKICBsZXQgYWNjb3VudCA9IGdldEF1dGhBY2NvdW50KGFkZHJlc3MpCiAgbGV0IGNsZWFuZFBhdGhzOiBbUHVibGljUGF0aF0gPSBbXQogIGZvciBwYXRoIGluIGFjY291bnQucHVibGljUGF0aHMgewogICAgY2xlYW5kUGF0aHMuYXBwZW5kKHBhdGgpCiAgfQogIHJldHVybiBjbGVhbmRQYXRocwp9", - "getStoragePaths": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0U3RvcmFnZVBhdGhzIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgpwdWIgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IFtTdG9yYWdlUGF0aF0gewogIGxldCBhY2NvdW50ID0gZ2V0QXV0aEFjY291bnQoYWRkcmVzcykKICBsZXQgY2xlYW5kUGF0aHM6IFtTdG9yYWdlUGF0aF0gPSBbXQogIGZvciBwYXRoIGluIGFjY291bnQuc3RvcmFnZVBhdGhzIHsKICAgIGNsZWFuZFBhdGhzLmFwcGVuZChwYXRoKQogIH0KICByZXR1cm4gY2xlYW5kUGF0aHMKfQ\u003d\u003d", - "getStoredItems": "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", - "getStoredResource": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0U3RvcmVkUmVzb3VyY2UgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCnB1YiBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzLCBwYXRoU3RyOiBTdHJpbmcpOiAmQW55UmVzb3VyY2U/IHsKICBsZXQgYWNjb3VudCA9IGdldEF1dGhBY2NvdW50KGFkZHJlc3MpCiAgbGV0IHBhdGggPSBTdG9yYWdlUGF0aChpZGVudGlmaWVyOiBwYXRoU3RyKSEKICByZXR1cm4gYWNjb3VudC5ib3Jyb3c8JkFueVJlc291cmNlPihmcm9tOiBwYXRoKQp9", - "getStoredStruct": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0U3RvcmVkU3RydWN0IC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgpwdWIgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcywgcGF0aFN0cjogU3RyaW5nKTogJkFueVN0cnVjdD8gewogIGxldCBhY2NvdW50ID0gZ2V0QXV0aEFjY291bnQoYWRkcmVzcykKICBsZXQgcGF0aCA9IFN0b3JhZ2VQYXRoKGlkZW50aWZpZXI6IHBhdGhTdHIpIQogIHJldHVybiBhY2NvdW50LmJvcnJvdzwmQW55U3RydWN0Pihmcm9tOiBwYXRoKQp9" + "enableTokenStorage": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZW5hYmxlVG9rZW5TdG9yYWdlIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKaW1wb3J0IDxUb2tlbj4gZnJvbSA8VG9rZW5BZGRyZXNzPgoKdHJhbnNhY3Rpb24gewoKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKFN0b3JhZ2UsIENhcGFiaWxpdGllcykgJkFjY291bnQpIHsKCiAgICAgICAgaWYgc2lnbmVyLnN0b3JhZ2UuYm9ycm93PCY8VG9rZW4+LlZhdWx0Pihmcm9tOiA8VG9rZW5TdG9yYWdlUGF0aD4gKSA9PSBuaWwgewogICAgICAgICAgICBzaWduZXIuc3RvcmFnZS5zYXZlKDwtIDxUb2tlbj4uY3JlYXRlRW1wdHlWYXVsdCh2YXVsdFR5cGU6IFR5cGU8QDxUb2tlbj4uVmF1bHQ+KCkpLCB0bzogPFRva2VuU3RvcmFnZVBhdGg+KQogICAgICAgIH0KCiAgICAgICAgaWYgc2lnbmVyLmNhcGFiaWxpdGllcy5leGlzdHMoPFRva2VuUmVjZWl2ZXJQYXRoPikgPT0gZmFsc2UgewogICAgICAgICAgICBsZXQgcmVjZWl2ZXJDYXBhYmlsaXR5ID0gc2lnbmVyLmNhcGFiaWxpdGllcy5zdG9yYWdlLmlzc3VlPCY8VG9rZW4+LlZhdWx0Pig8VG9rZW5TdG9yYWdlUGF0aD4pCiAgICAgICAgICAgIHNpZ25lci5jYXBhYmlsaXRpZXMucHVibGlzaChyZWNlaXZlckNhcGFiaWxpdHksIGF0OiA8VG9rZW5SZWNlaXZlclBhdGg+KQogICAgICAgIAogICAgICAgIH0KICAgICAgIAogICAgICAgIGlmIHNpZ25lci5jYXBhYmlsaXRpZXMuZXhpc3RzKDxUb2tlbkJhbGFuY2VQYXRoPikgPT0gZmFsc2UgewogICAgICAgICAgICBsZXQgYmFsYW5jZUNhcGFiaWxpdHkgPSBzaWduZXIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8JjxUb2tlbj4uVmF1bHQ+KDxUb2tlblN0b3JhZ2VQYXRoPikKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5wdWJsaXNoKGJhbGFuY2VDYXBhYmlsaXR5LCBhdDogPFRva2VuQmFsYW5jZVBhdGg+KQogICAgICAgIH0KICAgIAogICAgfQp9", + "enableTokenStorageV2": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZW5hYmxlVG9rZW5TdG9yYWdlVjIgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgppbXBvcnQgRnVuZ2libGVUb2tlbk1ldGFkYXRhVmlld3MgZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCmltcG9ydCBWaWV3UmVzb2x2ZXIgZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCgoKdHJhbnNhY3Rpb24odmF1bHRJZGVudGlmaWVyOiBTdHJpbmcpIHsKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChTdG9yYWdlLCBDYXBhYmlsaXRpZXMpICZBY2NvdW50KSB7CgogICAgICAgIGxldCB0eXBlID0gQ29tcG9zaXRlVHlwZSh2YXVsdElkZW50aWZpZXIpCiAgICAgICAgbGV0IGlkZW50aWZpZXJTcGxpdCA9IHZhdWx0SWRlbnRpZmllci5zcGxpdChzZXBhcmF0b3I6ICIuIikKICAgICAgICBsZXQgYWRkcmVzcyA9IEFkZHJlc3MuZnJvbVN0cmluZygiMHgiLmNvbmNhdChpZGVudGlmaWVyU3BsaXRbMV0pKSEKICAgICAgICBsZXQgbmFtZSA9IGlkZW50aWZpZXJTcGxpdFsyXSEKCiAgICAgICAgbGV0IHZpZXdSZXNvbHZlciA9IGdldEFjY291bnQoYWRkcmVzcykuY29udHJhY3RzLmJvcnJvdzwme1ZpZXdSZXNvbHZlcn0+KG5hbWU6IG5hbWUpCiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgYm9ycm93IFZpZXdSZXNvbHZlciBmcm9tIEZ1bmdpYmxlVG9rZW4gY29udHJhY3QiKQogICAgICAgIGxldCB2YXVsdERhdGEgPSB2aWV3UmVzb2x2ZXIucmVzb2x2ZUNvbnRyYWN0VmlldygKICAgICAgICAgICAgICAgIHJlc291cmNlVHlwZTogdHlwZSwKICAgICAgICAgICAgICAgIHZpZXdUeXBlOiBUeXBlPEZ1bmdpYmxlVG9rZW5NZXRhZGF0YVZpZXdzLkZUVmF1bHREYXRhPigpCiAgICAgICAgICAgICkgYXMhIEZ1bmdpYmxlVG9rZW5NZXRhZGF0YVZpZXdzLkZUVmF1bHREYXRhPyA/PyBwYW5pYygiQ291bGQgbm90IHJlc29sdmUgRlRWYXVsdERhdGEgdmlldyIpCgogICAgICAgIGlmIHNpZ25lci5zdG9yYWdlLmJvcnJvdzwme0Z1bmdpYmxlVG9rZW4uVmF1bHR9Pihmcm9tOiB2YXVsdERhdGEuc3RvcmFnZVBhdGggKSA9PSBuaWwgewogICAgICAgICAgICBzaWduZXIuc3RvcmFnZS5zYXZlKDwtIHZhdWx0RGF0YS5jcmVhdGVFbXB0eVZhdWx0KCksIHRvOnZhdWx0RGF0YS5zdG9yYWdlUGF0aCkKICAgICAgICB9CgogICAgICAgIGlmIHNpZ25lci5jYXBhYmlsaXRpZXMuZXhpc3RzKHZhdWx0RGF0YS5yZWNlaXZlclBhdGgpID09IGZhbHNlIHsKICAgICAgICAgICAgbGV0IHJlY2VpdmVyQ2FwYWJpbGl0eSA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTwme0Z1bmdpYmxlVG9rZW4uVmF1bHR9Pih2YXVsdERhdGEuc3RvcmFnZVBhdGgpCiAgICAgICAgICAgIHNpZ25lci5jYXBhYmlsaXRpZXMucHVibGlzaChyZWNlaXZlckNhcGFiaWxpdHksIGF0OiB2YXVsdERhdGEucmVjZWl2ZXJQYXRoKQogICAgICAgIH0KICAgICAgIAogICAgICAgIGlmIHNpZ25lci5jYXBhYmlsaXRpZXMuZXhpc3RzKHZhdWx0RGF0YS5tZXRhZGF0YVBhdGgpID09IGZhbHNlIHsKICAgICAgICAgICAgbGV0IGJhbGFuY2VDYXBhYmlsaXR5ID0gc2lnbmVyLmNhcGFiaWxpdGllcy5zdG9yYWdlLmlzc3VlPCZ7RnVuZ2libGVUb2tlbi5WYXVsdH0+KHZhdWx0RGF0YS5zdG9yYWdlUGF0aCkKICAgICAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5wdWJsaXNoKGJhbGFuY2VDYXBhYmlsaXR5LCBhdDogdmF1bHREYXRhLm1ldGFkYXRhUGF0aCkKICAgICAgICB9CiAgICAKICAgIH0KfQ\u003d\u003d", + "getBasicPublicItems": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0QmFzaWNQdWJsaWNJdGVtcyAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKYWNjZXNzKGFsbClzdHJ1Y3QgSXRlbSB7CiAgYWNjZXNzKGFsbClsZXQgYWRkcmVzczogQWRkcmVzcwogIGFjY2VzcyhhbGwpbGV0IHBhdGg6IFN0cmluZwogIGFjY2VzcyhhbGwpbGV0IHRhcmdldFBhdGg6IFN0cmluZz8KCiAgaW5pdChhZGRyZXNzOiBBZGRyZXNzLCBwYXRoOiBTdHJpbmcsIHRhcmdldFBhdGg6IFN0cmluZz8pIHsKICAgIHNlbGYuYWRkcmVzcyA9IGFkZHJlc3MKICAgIHNlbGYucGF0aCA9IHBhdGgKICAgIHNlbGYudGFyZ2V0UGF0aCA9IHRhcmdldFBhdGgKICB9Cn0KCmFjY2VzcyhhbGwpZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IFtJdGVtXSB7CiAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCiAgbGV0IGl0ZW1zOiBbSXRlbV0gPSBbXQoKCiAgZnVuIGVhY2hQYXRoKHBhdGg6IFB1YmxpY1BhdGgsIGNhcFR5cGU6IFR5cGUpOiBCb29sIHsKICAgIC8vIHRvZG8KICAgIGxldCBjYXAgPSBhY2NvdW50LmNhcGFiaWxpdGllcy5nZXQ8JkFueVN0cnVjdD4ocGF0aCkKICAgIHZhciB0YXJnZXRQYXRoID0gIiIKCiAgICBpZiBjYXAgIT0gbmlsIHsKICAgICAgdGFyZ2V0UGF0aCA9ICIxMiIgCiAgICB9CiAgICBsZXQgaXRlbSA9IEl0ZW0oYWRkcmVzczogYWRkcmVzcywgcGF0aDogcGF0aC50b1N0cmluZygpLCB0YXJnZXRQYXRoOiB0YXJnZXRQYXRoKQogICAgaXRlbXMuYXBwZW5kKGl0ZW0pCiAgICByZXR1cm4gdHJ1ZQogIH0KICBhY2NvdW50LnN0b3JhZ2UuZm9yRWFjaFB1YmxpYyhlYWNoUGF0aCkKCiAgcmV0dXJuIGl0ZW1zCn0\u003d", + "getPrivateItems": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0UHJpdmF0ZUl0ZW1zIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgphY2Nlc3MoYWxsKXN0cnVjdCBJdGVtIHsKICBhY2Nlc3MoYWxsKWxldCBhZGRyZXNzOiBBZGRyZXNzCiAgYWNjZXNzKGFsbClsZXQgcGF0aDogU3RyaW5nCiAgYWNjZXNzKGFsbClsZXQgdHlwZTogVHlwZQogIGFjY2VzcyhhbGwpbGV0IHRhcmdldFBhdGg6IFN0cmluZz8KCiAgaW5pdCgKICAgIGFkZHJlc3M6IEFkZHJlc3MsIAogICAgcGF0aDogU3RyaW5nLCAKICAgIHR5cGU6IFR5cGUsIAogICAgdGFyZ2V0UGF0aDogU3RyaW5nPwogICkgewogICAgc2VsZi5hZGRyZXNzID0gYWRkcmVzcwogICAgc2VsZi5wYXRoID0gcGF0aAogICAgc2VsZi50eXBlID0gdHlwZQogICAgc2VsZi50YXJnZXRQYXRoID0gdGFyZ2V0UGF0aAogIH0KfQoKYWNjZXNzKGFsbClmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzLCBwYXRoTWFwOiB7U3RyaW5nOiBCb29sfSk6IFtJdGVtXSB7CiAgbGV0IGFjY291bnQgPSBnZXRBY2NvdW50KGFkZHJlc3MpCgogIGxldCBpdGVtczogW0l0ZW1dID0gW10KCiAgYWNjb3VudC5zdG9yYWdlLmZvckVhY2hQcml2YXRlKGZ1biAocGF0aDogUHJpdmF0ZVBhdGgsIHR5cGU6IFR5cGUpOiBCb29sIHsKICAgIGlmICFwYXRoTWFwLmNvbnRhaW5zS2V5KHBhdGgudG9TdHJpbmcoKSkgewogICAgICByZXR1cm4gdHJ1ZQogICAgfQoKICAgIHZhciB0YXJnZXRQYXRoOiBTdHJpbmc/ID0gbmlsCiAgICBpZiBsZXQgdGFyZ2V0ID0gYWNjb3VudC5nZXRMaW5rVGFyZ2V0KHBhdGgpIHsKICAgICAgdGFyZ2V0UGF0aCA9IHRhcmdldC50b1N0cmluZygpCiAgICB9CgogICAgbGV0IGl0ZW0gPSBJdGVtKAogICAgICBhZGRyZXNzOiBhZGRyZXNzLAogICAgICBwYXRoOiBwYXRoLnRvU3RyaW5nKCksCiAgICAgIHR5cGU6IHR5cGUsCiAgICAgIHRhcmdldFBhdGg6IHRhcmdldFBhdGgKICAgICkKCiAgICBpdGVtcy5hcHBlbmQoaXRlbSkKICAgIHJldHVybiB0cnVlCiAgfSkKCiAgcmV0dXJuIGl0ZW1zCn0\u003d", + "getPrivatePaths": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0UHJpdmF0ZVBhdGhzIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgphY2Nlc3MoYWxsKWZ1biBtYWluKGFkZHJlc3M6IEFkZHJlc3MpOiBbUHJpdmF0ZVBhdGhdIHsKICBsZXQgYWNjb3VudCA9IGdldEF1dGhBY2NvdW50KGFkZHJlc3MpCiAgbGV0IGNsZWFuZFBhdGhzOiBbUHJpdmF0ZVBhdGhdID0gW10KICBmb3IgcGF0aCBpbiBhY2NvdW50LnByaXZhdGVQYXRocyB7CiAgICBjbGVhbmRQYXRocy5hcHBlbmQocGF0aCkKICB9CiAgcmV0dXJuIGNsZWFuZFBhdGhzCn0\u003d", + "getPublicItem": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0UHVibGljSXRlbSAtIHYyLjc4Ci8vIDxwbGF0Zm9ybV9pbmZvPgoKLy8gQSB3b3JrYXJvdW5kIG1ldGhvZAppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKaW1wb3J0IE5vbkZ1bmdpYmxlVG9rZW4gZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCiAgCmFjY2VzcyhhbGwpIHN0cnVjdCBJdGVtIHsKICBhY2Nlc3MoYWxsKSBsZXQgYWRkcmVzczogQWRkcmVzcwogIGFjY2VzcyhhbGwpIGxldCBwYXRoOiBTdHJpbmcKICBhY2Nlc3MoYWxsKSBsZXQgdHlwZTogVHlwZQoKICBhY2Nlc3MoYWxsKSBsZXQgdGFyZ2V0UGF0aDogU3RyaW5nPwoKICBpbml0KAogICAgYWRkcmVzczogQWRkcmVzcywgCiAgICBwYXRoOiBTdHJpbmcsIAogICAgdHlwZTogVHlwZSwgCiAgICB0YXJnZXRQYXRoOiBTdHJpbmc/CiAgKSB7CiAgICBzZWxmLmFkZHJlc3MgPSBhZGRyZXNzCiAgICBzZWxmLnBhdGggPSBwYXRoCiAgICBzZWxmLnR5cGUgPSB0eXBlCiAgICBzZWxmLnRhcmdldFBhdGggPSB0YXJnZXRQYXRoCiAgfQp9CgphY2Nlc3MoYWxsKSBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzLCBwYXRoTWFwOiB7U3RyaW5nOiBCb29sfSk6IFtJdGVtXSB7CiAgbGV0IGFjY291bnQgPSBnZXRBdXRoQWNjb3VudChhZGRyZXNzKQoKICBsZXQgaXRlbXM6IFtJdGVtXSA9IFtdCiAgYWNjb3VudC5mb3JFYWNoUHVibGljKGZ1biAocGF0aDogUHVibGljUGF0aCwgdHlwZTogVHlwZSk6IEJvb2wgewogICAgaWYgIXBhdGhNYXAuY29udGFpbnNLZXkocGF0aC50b1N0cmluZygpKSB7CiAgICAgIHJldHVybiB0cnVlCiAgICB9CgogICAgdmFyIHRhcmdldFBhdGg6IFN0cmluZz8gPSBuaWwKCiAgICBpZiBsZXQgdGFyZ2V0ID0gYWNjb3VudC5nZXRMaW5rVGFyZ2V0KHBhdGgpIHsKICAgICAgdGFyZ2V0UGF0aCA9IHRhcmdldC50b1N0cmluZygpCiAgICB9CgogICAgbGV0IGl0ZW0gPSBJdGVtKAogICAgICBhZGRyZXNzOiBhZGRyZXNzLAogICAgICBwYXRoOiBwYXRoLnRvU3RyaW5nKCksCiAgICAgIHR5cGU6IHR5cGUsCiAgICAgIHRhcmdldFBhdGg6IHRhcmdldFBhdGgKICAgICkKCiAgICBpdGVtcy5hcHBlbmQoaXRlbSkKICAgIHJldHVybiBmYWxzZQogIH0pCgogIHJldHVybiBpdGVtcwp9", + "getPublicItems": "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\u003d\u003d", + "getPublicPaths": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0UHVibGljUGF0aHMgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCnB1YiBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzKTogW1B1YmxpY1BhdGhdIHsKICBsZXQgYWNjb3VudCA9IGdldEF1dGhBY2NvdW50KGFkZHJlc3MpCiAgbGV0IGNsZWFuZFBhdGhzOiBbUHVibGljUGF0aF0gPSBbXQogIGZvciBwYXRoIGluIGFjY291bnQucHVibGljUGF0aHMgewogICAgY2xlYW5kUGF0aHMuYXBwZW5kKHBhdGgpCiAgfQogIHJldHVybiBjbGVhbmRQYXRocwp9", + "getStoragePaths": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0U3RvcmFnZVBhdGhzIC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgpwdWIgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcyk6IFtTdG9yYWdlUGF0aF0gewogIGxldCBhY2NvdW50ID0gZ2V0QXV0aEFjY291bnQoYWRkcmVzcykKICBsZXQgY2xlYW5kUGF0aHM6IFtTdG9yYWdlUGF0aF0gPSBbXQogIGZvciBwYXRoIGluIGFjY291bnQuc3RvcmFnZVBhdGhzIHsKICAgIGNsZWFuZFBhdGhzLmFwcGVuZChwYXRoKQogIH0KICByZXR1cm4gY2xlYW5kUGF0aHMKfQ\u003d\u003d", + "getStoredItems": "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", + "getStoredResource": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0U3RvcmVkUmVzb3VyY2UgLSB2Mi43OAovLyA8cGxhdGZvcm1faW5mbz4KCnB1YiBmdW4gbWFpbihhZGRyZXNzOiBBZGRyZXNzLCBwYXRoU3RyOiBTdHJpbmcpOiAmQW55UmVzb3VyY2U/IHsKICBsZXQgYWNjb3VudCA9IGdldEF1dGhBY2NvdW50KGFkZHJlc3MpCiAgbGV0IHBhdGggPSBTdG9yYWdlUGF0aChpZGVudGlmaWVyOiBwYXRoU3RyKSEKICByZXR1cm4gYWNjb3VudC5ib3Jyb3c8JkFueVJlc291cmNlPihmcm9tOiBwYXRoKQp9", + "getStoredStruct": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgZ2V0U3RvcmVkU3RydWN0IC0gdjIuNzgKLy8gPHBsYXRmb3JtX2luZm8+CgpwdWIgZnVuIG1haW4oYWRkcmVzczogQWRkcmVzcywgcGF0aFN0cjogU3RyaW5nKTogJkFueVN0cnVjdD8gewogIGxldCBhY2NvdW50ID0gZ2V0QXV0aEFjY291bnQoYWRkcmVzcykKICBsZXQgcGF0aCA9IFN0b3JhZ2VQYXRoKGlkZW50aWZpZXI6IHBhdGhTdHIpIQogIHJldHVybiBhY2NvdW50LmJvcnJvdzwmQW55U3RydWN0Pihmcm9tOiBwYXRoKQp9" }, - "temp": { - "addKeys": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgYWRkS2V5cyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IENyeXB0bwoKdHJhbnNhY3Rpb24ocHVibGljS2V5OiBTdHJpbmcpIHsKICAgIHByZXBhcmUoc2lnbmVyOiBhdXRoKEtleXMpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IGtleSA9IFB1YmxpY0tleSgKICAgICAgICAgICAgcHVibGljS2V5OiBwdWJsaWNLZXkuZGVjb2RlSGV4KCksCiAgICAgICAgICAgIHNpZ25hdHVyZUFsZ29yaXRobTogU2lnbmF0dXJlQWxnb3JpdGhtKHJhd1ZhbHVlOiAxKSEKICAgICAgICApCiAgICAgICAgdmFyIGlkeCA9IDAKICAgICAgICB3aGlsZSBpZHggPCA5OSB7CiAgICAgICAgICAgIHNpZ25lci5rZXlzLmFkZCgKICAgICAgICAgICAgICAgIHB1YmxpY0tleToga2V5LAogICAgICAgICAgICAgICAgaGFzaEFsZ29yaXRobTogSGFzaEFsZ29yaXRobShyYXdWYWx1ZTogMSkhLAogICAgICAgICAgICAgICAgd2VpZ2h0OiAxMDAwLjAKICAgICAgICAgICAgKQogICAgICAgICAgICBpZHggPSBpZHggKyAxCiAgICAgICAgfQogICAgICAgCiAgICB9Cn0\u003d", - "claim": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgY2xhaW0gLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCgppbXBvcnQgVmlld1Jlc29sdmVyIGZyb20gMHg2MzFlODhhZTdmMWQ3YzIwCgppbXBvcnQgTWV0YWRhdGFWaWV3cyBmcm9tIDB4NjMxZTg4YWU3ZjFkN2MyMAoKCgppbXBvcnQgSHlicmlkQ3VzdG9keSBmcm9tIDB4Mjk0ZTQ0ZTFlYzY5OTNjNgoKaW1wb3J0IENhcGFiaWxpdHlGaWx0ZXIgZnJvbSAweDI5NGU0NGUxZWM2OTkzYzYKCgoKdHJhbnNhY3Rpb24oY2hpbGRBZGRyZXNzOiBBZGRyZXNzLCBmaWx0ZXJBZGRyZXNzOiBBZGRyZXNzPywgZmlsdGVyUGF0aDogUHVibGljUGF0aD8pIHsKICAgIHByZXBhcmUoYWNjdDogYXV0aChTdG9yYWdlLCBDYXBhYmlsaXRpZXMsIEluYm94KSAmQWNjb3VudCkgewogICAgICAgIHZhciBmaWx0ZXI6IENhcGFiaWxpdHk8JntDYXBhYmlsaXR5RmlsdGVyLkZpbHRlcn0+PyA9IG5pbAogICAgICAgIGlmIGZpbHRlckFkZHJlc3MgIT0gbmlsICYmIGZpbHRlclBhdGggIT0gbmlsIHsKICAgICAgICAgICAgZmlsdGVyID0gZ2V0QWNjb3VudChmaWx0ZXJBZGRyZXNzISkuY2FwYWJpbGl0aWVzLmdldDwme0NhcGFiaWxpdHlGaWx0ZXIuRmlsdGVyfT4oZmlsdGVyUGF0aCEpCiAgICAgICAgfQoKICAgICAgICBpZiBhY2N0LnN0b3JhZ2UuYm9ycm93PCZIeWJyaWRDdXN0b2R5Lk1hbmFnZXI+KGZyb206IEh5YnJpZEN1c3RvZHkuTWFuYWdlclN0b3JhZ2VQYXRoKSA9PSBuaWwgewogICAgICAgICAgICBsZXQgbSA8LSBIeWJyaWRDdXN0b2R5LmNyZWF0ZU1hbmFnZXIoZmlsdGVyOiBmaWx0ZXIpCiAgICAgICAgICAgIGFjY3Quc3RvcmFnZS5zYXZlKDwtIG0sIHRvOiBIeWJyaWRDdXN0b2R5Lk1hbmFnZXJTdG9yYWdlUGF0aCkKCiAgICAgICAgICAgIGZvciBjIGluIGFjY3QuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuZ2V0Q29udHJvbGxlcnMoZm9yUGF0aDogSHlicmlkQ3VzdG9keS5NYW5hZ2VyU3RvcmFnZVBhdGgpIHsKICAgICAgICAgICAgICAgIGMuZGVsZXRlKCkKICAgICAgICAgICAgfQoKICAgICAgICAgICAgYWNjdC5jYXBhYmlsaXRpZXMudW5wdWJsaXNoKEh5YnJpZEN1c3RvZHkuTWFuYWdlclB1YmxpY1BhdGgpCgogICAgICAgICAgICBhY2N0LmNhcGFiaWxpdGllcy5wdWJsaXNoKAogICAgICAgICAgICAgICAgYWNjdC5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTwme0h5YnJpZEN1c3RvZHkuTWFuYWdlclB1YmxpY30+KEh5YnJpZEN1c3RvZHkuTWFuYWdlclN0b3JhZ2VQYXRoKSwKICAgICAgICAgICAgICAgIGF0OiBIeWJyaWRDdXN0b2R5Lk1hbmFnZXJQdWJsaWNQYXRoCiAgICAgICAgICAgICkKCiAgICAgICAgICAgIGFjY3QuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8YXV0aChIeWJyaWRDdXN0b2R5Lk1hbmFnZSkgJntIeWJyaWRDdXN0b2R5Lk1hbmFnZXJQcml2YXRlLCBIeWJyaWRDdXN0b2R5Lk1hbmFnZXJQdWJsaWN9PihIeWJyaWRDdXN0b2R5Lk1hbmFnZXJTdG9yYWdlUGF0aCkKICAgICAgICB9CgogICAgICAgIGxldCBpbmJveE5hbWUgPSBIeWJyaWRDdXN0b2R5LmdldENoaWxkQWNjb3VudElkZW50aWZpZXIoYWNjdC5hZGRyZXNzKQogICAgICAgIGxldCBjYXAgPSBhY2N0LmluYm94LmNsYWltPGF1dGgoSHlicmlkQ3VzdG9keS5DaGlsZCkgJntIeWJyaWRDdXN0b2R5LkFjY291bnRQcml2YXRlLCBIeWJyaWRDdXN0b2R5LkFjY291bnRQdWJsaWMsIFZpZXdSZXNvbHZlci5SZXNvbHZlcn0+KGluYm94TmFtZSwgcHJvdmlkZXI6IGNoaWxkQWRkcmVzcykKICAgICAgICAgICAgPz8gcGFuaWMoImNoaWxkIGFjY291bnQgY2FwIG5vdCBmb3VuZCIpCgogICAgICAgIGxldCBtYW5hZ2VyID0gYWNjdC5zdG9yYWdlLmJvcnJvdzxhdXRoKEh5YnJpZEN1c3RvZHkuTWFuYWdlKSAmSHlicmlkQ3VzdG9keS5NYW5hZ2VyPihmcm9tOiBIeWJyaWRDdXN0b2R5Lk1hbmFnZXJTdG9yYWdlUGF0aCkKICAgICAgICAgICAgPz8gcGFuaWMoIm1hbmFnZXIgbm8gZm91bmQiKQoKICAgICAgICBtYW5hZ2VyLmFkZEFjY291bnQoY2FwOiBjYXApCiAgICB9Cn0\u003d", - "createAccount": "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", - "hcPublish": "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\u003d\u003d", - "mintNFT": "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\u003d\u003d", - "onboardEvmToFlow": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgb25ib2FyZEV2bVRvRmxvdyAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweDlhMDc2NmQ5M2I2NjA4YjcKCmltcG9ydCBGbG93VG9rZW4gZnJvbSAweDdlNjBkZjA0MmE5YzA4NjgKCgppbXBvcnQgU2NvcGVkRlRQcm92aWRlcnMgZnJvbSAweGRmYzIwYWVlNjUwZmNiZGYKCgppbXBvcnQgRVZNIGZyb20gMHg4YzUzMDNlYWEyNjIwMmQ2CgoKaW1wb3J0IEZsb3dFVk1CcmlkZ2UgZnJvbSAweGRmYzIwYWVlNjUwZmNiZGYKCmltcG9ydCBGbG93RVZNQnJpZGdlQ29uZmlnIGZyb20gMHhkZmMyMGFlZTY1MGZjYmRmCkNvbmZpZwoKLy8vIFRoaXMgdHJhbnNhY3Rpb24gb25ib2FyZHMgRVJDMjAvRVJDNzIxIGFzc2V0cyB0byB0aGUgYnJpZGdlLCBjb25maWd1cmluZyB0aGUgYnJpZGdlIHRvIG1vdmUgYXNzZXRzIGJldHdlZW4KLy8vIGVudmlyb25tZW50cwovLy8gTk9URTogVGhpcyBtdXN0IGJlIGRvbmUgYmVmb3JlIGJyaWRnaW5nIGEgQ2FkZW5jZS1uYXRpdmUgTkZUIHRvIEVWTQovLy8KLy8vIEBwYXJhbSBhZGRyZXNzZXNBc0hleDogQXJyYXkgb2YgRVZNIGNvbnRyYWN0IGFkZHJlc3NlcyBkZWZpbmluZyB0aGUgCi8vLyAgICAgYnJpZGdlYWJsZSBhc3NldCB0byBiZSBvbmJvYXJkZWQKLy8vCnRyYW5zYWN0aW9uKGFkZHJlc3Nlc0FzSGV4OiBbU3RyaW5nXSkgewpsZXQgc2NvcGVkUHJvdmlkZXI6IEBTY29wZWRGVFByb3ZpZGVycy5TY29wZWRGVFByb3ZpZGVyCgpwcmVwYXJlKHNpZ25lcjogYXV0aChDb3B5VmFsdWUsIEJvcnJvd1ZhbHVlLCBJc3N1ZVN0b3JhZ2VDYXBhYmlsaXR5Q29udHJvbGxlciwgUHVibGlzaENhcGFiaWxpdHksIFNhdmVWYWx1ZSkgJkFjY291bnQpIHsKICAgIC8qIC0tLSBDb25maWd1cmUgYSBTY29wZWRGVFByb3ZpZGVyIC0tLSAqLwogICAgLy8KICAgIC8vIElzc3VlIGFuZCBzdG9yZSBicmlkZ2UtZGVkaWNhdGVkIFByb3ZpZGVyIENhcGFiaWxpdHkgaW4gc3RvcmFnZSBpZiBuZWNlc3NhcnkKICAgIGlmIHNpZ25lci5zdG9yYWdlLnR5cGUoYXQ6IEZsb3dFVk1CcmlkZ2VDb25maWcucHJvdmlkZXJDYXBhYmlsaXR5U3RvcmFnZVBhdGgpID09IG5pbCB7CiAgICAgICAgbGV0IHByb3ZpZGVyQ2FwID0gc2lnbmVyLmNhcGFiaWxpdGllcy5zdG9yYWdlLmlzc3VlPGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntGdW5naWJsZVRva2VuLlByb3ZpZGVyfT4oCiAgICAgICAgICAgIC9zdG9yYWdlL2Zsb3dUb2tlblZhdWx0CiAgICAgICAgKQogICAgICAgIHNpZ25lci5zdG9yYWdlLnNhdmUocHJvdmlkZXJDYXAsIHRvOiBGbG93RVZNQnJpZGdlQ29uZmlnLnByb3ZpZGVyQ2FwYWJpbGl0eVN0b3JhZ2VQYXRoKQogICAgfQogICAgLy8gQ29weSB0aGUgc3RvcmVkIFByb3ZpZGVyIGNhcGFiaWxpdHkgYW5kIGNyZWF0ZSBhIFNjb3BlZEZUUHJvdmlkZXIKICAgIGxldCBwcm92aWRlckNhcENvcHkgPSBzaWduZXIuc3RvcmFnZS5jb3B5PENhcGFiaWxpdHk8YXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAme0Z1bmdpYmxlVG9rZW4uUHJvdmlkZXJ9Pj4oCiAgICAgICAgICAgIGZyb206IEZsb3dFVk1CcmlkZ2VDb25maWcucHJvdmlkZXJDYXBhYmlsaXR5U3RvcmFnZVBhdGgKICAgICAgICApID8/IHBhbmljKCJJbnZhbGlkIFByb3ZpZGVyIENhcGFiaWxpdHkgZm91bmQgaW4gc3RvcmFnZS4iKQogICAgLy8gU2V0IGEgd2l0aGRyYXdhbCBsaW1pdCBmb3IgdGhlIHByb3ZpZGVyCiAgICBsZXQgcHJvdmlkZXJMaW1pdCA9IEZsb3dFVk1CcmlkZ2VDb25maWcub25ib2FyZEZlZSAqIFVGaXg2NChhZGRyZXNzZXNBc0hleC5sZW5ndGgpCiAgICBsZXQgcHJvdmlkZXJGaWx0ZXIgPSBTY29wZWRGVFByb3ZpZGVycy5BbGxvd2FuY2VGaWx0ZXIocHJvdmlkZXJMaW1pdCkKICAgIC8vIENyZWF0ZSBTY29wZWRGVFByb3ZpZGVyIHRvIGV4cGlyZSBqdXN0IGFmdGVyIHRoaXMgdHJhbnNhY3Rpb24KICAgIHNlbGYuc2NvcGVkUHJvdmlkZXIgPC0gU2NvcGVkRlRQcm92aWRlcnMuY3JlYXRlU2NvcGVkRlRQcm92aWRlcigKICAgICAgICAgICAgcHJvdmlkZXI6IHByb3ZpZGVyQ2FwQ29weSwKICAgICAgICAgICAgZmlsdGVyczogWyBwcm92aWRlckZpbHRlciBdLAogICAgICAgICAgICBleHBpcmF0aW9uOiBnZXRDdXJyZW50QmxvY2soKS50aW1lc3RhbXAgKyAxLjAKICAgICAgICApCn0KZXhlY3V0ZSB7CiAgICAvLyBJdGVyYXRlIG92ZXIgcHJvdmlkZWQgYXJyYXkKICAgIGZvciBhZGRyZXNzSGV4IGluIGFkZHJlc3Nlc0FzSGV4IHsKICAgICAgICAvLyBDb252ZXJ0IGhleCBzdHJpbmcgdG8gRVZNQWRkcmVzcwogICAgICAgIGxldCBhZGRyZXNzID0gRVZNLmFkZHJlc3NGcm9tU3RyaW5nKGFkZHJlc3NIZXgpCiAgICAgICAgLy8gQ29udGludWUgaWYgdGhlIGhleCBpcyBub3QgYSB2YWxpZCBFVk0gYWRkcmVzcyBvciBpZiB0aGUgYWRkcmVzcyBpcyBhbHJlYWR5IG9uYm9hcmRlZAogICAgICAgIGlmIGFkZHJlc3MgPT0gbmlsIHx8IEZsb3dFVk1CcmlkZ2UuZXZtQWRkcmVzc1JlcXVpcmVzT25ib2FyZGluZyhhZGRyZXNzISkgIT0gdHJ1ZSB7CiAgICAgICAgICAgIGNvbnRpbnVlCiAgICAgICAgfQogICAgICAgIEZsb3dFVk1CcmlkZ2Uub25ib2FyZEJ5RVZNQWRkcmVzcygKICAgICAgICAgICAgYWRkcmVzcyEsCiAgICAgICAgICAgIGZlZVByb3ZpZGVyOiAmc2VsZi5zY29wZWRQcm92aWRlciBhcyBhdXRoKEZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RnVuZ2libGVUb2tlbi5Qcm92aWRlcn0KICAgICAgICApCiAgICB9CiAgICBkZXN0cm95IHNlbGYuc2NvcGVkUHJvdmlkZXIKfQp9", - "queryBall": "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\u003d", - "queryBals": "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\u003d\u003d", - "queryCeCheck": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcXVlcnlDZUNoZWNrIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgU3dhcEludGVyZmFjZXMgZnJvbSAweGI3OGVmN2FmYTUyZmY5MDYKaW1wb3J0IEZ1bmdpYmxlVG9rZW4gZnJvbSAweGYyMzNkY2VlODhmZTBhYmUKYWNjZXNzKGFsbCkgZnVuIG1haW4odXNlckFkZHI6IEFkZHJlc3MpOiBBbnlTdHJ1Y3QgewogICAgbGV0IHRva2VOYW1lICAgICAgID0gWyJjZVdCVEMiLCAgICAgICAgICAgICAgICJjZUFWQVgiLCAgICAgICAgICAgICAgICJjZUJOQiIsICAgICAgICAgICAgICAgImNlQlVTRCIsICAgICAgICAgICAgICAgImNlREFJIiwgICAgICAgICAgICAgICAiY2VGVE0iLCAgICAgICAgICAgICAgICJjZU1BVElDIiwgICAgICAgICAgICAgICAiY2VVU0RUIiwgICAgICAgICAgICAgICAiY2VXRVRIIl0KICAgIGxldCB2YXVsdFBhdGhzICAgICA9IFsvc3RvcmFnZS9jZVdCVENWYXVsdCwgICAvc3RvcmFnZS9jZUFWQVhWYXVsdCwgICAvc3RvcmFnZS9jZUJOQlZhdWx0LCAgIC9zdG9yYWdlL2NlQlVTRFZhdWx0LCAgIC9zdG9yYWdlL2NlREFJVmF1bHQsICAgL3N0b3JhZ2UvY2VGVE1WYXVsdCwgICAvc3RvcmFnZS9jZU1BVElDVmF1bHQsICAgL3N0b3JhZ2UvY2VVU0RUVmF1bHQsICAgL3N0b3JhZ2UvY2VXRVRIVmF1bHRdCiAgICBsZXQgYmFsYW5jZVBhdGhzMSAgPSBbL3B1YmxpYy9jZVdCVENCYWxhbmNlLCAgL3B1YmxpYy9jZUFWQVhCYWxhbmNlLCAgL3B1YmxpYy9jZUJOQkJhbGFuY2UsICAvcHVibGljL2NlQlVTREJhbGFuY2UsICAvcHVibGljL2NlREFJQmFsYW5jZSwgIC9wdWJsaWMvY2VGVE1CYWxhbmNlLCAgL3B1YmxpYy9jZU1BVElDQmFsYW5jZSwgIC9wdWJsaWMvY2VVU0RUQmFsYW5jZSwgIC9wdWJsaWMvY2VXRVRIQmFsYW5jZV0KICAgIGxldCBiYWxhbmNlUGF0aHMyICA9IFsvcHVibGljL2NlV0JUQ1JlY2VpdmVyLCAvcHVibGljL2NlQVZBWFJlY2VpdmVyLCAvcHVibGljL2NlQk5CUmVjZWl2ZXIsIC9wdWJsaWMvY2VCVVNEUmVjZWl2ZXIsIC9wdWJsaWMvY2VEQUlSZWNlaXZlciwgL3B1YmxpYy9jZUZUTVJlY2VpdmVyLCAvcHVibGljL2NlTUFUSUNSZWNlaXZlciwgL3B1YmxpYy9jZVVTRFRSZWNlaXZlciwgL3B1YmxpYy9jZVdFVEhSZWNlaXZlcl0KICAgIGxldCByZWNlaXZlclBhdGhzMiA9IFsvcHVibGljL2NlV0JUQ1ZhdWx0LCAgICAvcHVibGljL2NlQVZBWFZhdWx0LCAgICAvcHVibGljL2NlQk5CVmF1bHQsICAgIC9wdWJsaWMvY2VCVVNEVmF1bHQsICAgIC9wdWJsaWMvY2VEQUlWYXVsdCwgICAgL3B1YmxpYy9jZUZUTVZhdWx0LCAgICAvcHVibGljL2NlTUFUSUNWYXVsdCwgICAgL3B1YmxpYy9jZVVTRFRWYXVsdCwgICAgL3B1YmxpYy9jZVdFVEhWYXVsdF0KICAgIGxldCByZXM6IHtTdHJpbmc6IFVGaXg2NH0gPSB7fQogICAgdmFyIGkgPSAwCiAgICBmb3IgYmFsYW5jZVBhdGgxIGluIGJhbGFuY2VQYXRoczEgewogICAgICAgIGxldCBiYWxhbmNlUGF0aDIgPSBiYWxhbmNlUGF0aHMyW2ldCiAgICAgICAgbGV0IGNhcDEgPSBnZXRBY2NvdW50KHVzZXJBZGRyKS5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5CYWxhbmNlfT4oYmFsYW5jZVBhdGgxKQogICAgICAgIGxldCBjYXAyID0gZ2V0QWNjb3VudCh1c2VyQWRkcikuY2FwYWJpbGl0aWVzLmJvcnJvdzwme0Z1bmdpYmxlVG9rZW4uQmFsYW5jZX0+KGJhbGFuY2VQYXRoMikKICAgICAgICBsZXQgY2FwcjIgPSBnZXRBY2NvdW50KHVzZXJBZGRyKS5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5SZWNlaXZlcn0+KHJlY2VpdmVyUGF0aHMyW2ldKQogICAgICAgIGlmIChjYXAxICE9IG5pbCAmJiAoY2FwMiA9PSBuaWwgfHwgY2FwcjIgPT0gbmlsKSkgewogICAgICAgICAgICByZXNbdG9rZU5hbWVbaV1dID0gY2FwMSEuYmFsYW5jZQogICAgICAgIH0KICAgICAgICBpID0gaSArIDEKICAgIH0KICAgIHJldHVybiByZXMKfQ\u003d\u003d", - "queryEnable": "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\u003d\u003d", - "relinkVault": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcmVsaW5rVmF1bHQgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCmltcG9ydCBjZVdFVEggZnJvbSAweDIzMWNjMGRiYmNmZmM0YjcKCnRyYW5zYWN0aW9uIHsKCiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChTdG9yYWdlLCBDYXBhYmlsaXRpZXMpICZBY2NvdW50KSB7CgoKICAgICAgICBzaWduZXIuY2FwYWJpbGl0aWVzLnVucHVibGlzaCgvcHVibGljL2NlV0VUSFJlY2VpdmVyKQogICAgICAgIGxldCByZWNlaXZlckNhcGFiaWxpdHkgPSBzaWduZXIuY2FwYWJpbGl0aWVzLnN0b3JhZ2UuaXNzdWU8JmNlV0VUSC5WYXVsdD4oL3N0b3JhZ2UvY2VXRVRIVmF1bHQpCiAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy5wdWJsaXNoKHJlY2VpdmVyQ2FwYWJpbGl0eSwgYXQ6IC9wdWJsaWMvY2VXRVRIUmVjZWl2ZXIpCiAgICAgICAgCgogICAgICAgCiAgICAgICAgc2lnbmVyLmNhcGFiaWxpdGllcy51bnB1Ymxpc2goL3B1YmxpYy9jZVdFVEhCYWxhbmNlKQogICAgICAgIGxldCBiYWxhbmNlQ2FwYWJpbGl0eSA9IHNpZ25lci5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTwmY2VXRVRILlZhdWx0Pigvc3RvcmFnZS9jZVdFVEhWYXVsdCkKICAgICAgICAKICAgICAgICBzaWduZXIuY2FwYWJpbGl0aWVzLnB1Ymxpc2goYmFsYW5jZUNhcGFiaWxpdHksIGF0OiAvcHVibGljL2NlV0VUSEJhbGFuY2UpCiAgICAKICAgIH0KfQ\u003d\u003d", - "rmChild": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgcm1DaGlsZCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoKaW1wb3J0IEh5YnJpZEN1c3RvZHkgZnJvbSAweDI5NGU0NGUxZWM2OTkzYzYKCnRyYW5zYWN0aW9uKGNoaWxkOiBBZGRyZXNzKSB7CiAgICBwcmVwYXJlIChhY2N0OiBhdXRoKFN0b3JhZ2UpICZBY2NvdW50KSB7CiAgICAgICAgbGV0IG1hbmFnZXIgPSBhY2N0LnN0b3JhZ2UuYm9ycm93PGF1dGgoSHlicmlkQ3VzdG9keS5NYW5hZ2UpICZIeWJyaWRDdXN0b2R5Lk1hbmFnZXI+KGZyb206IEh5YnJpZEN1c3RvZHkuTWFuYWdlclN0b3JhZ2VQYXRoKQogICAgICAgICAgICA/PyBwYW5pYygibWFuYWdlciBub3QgZm91bmQiKQogICAgICAgIG1hbmFnZXIucmVtb3ZlQ2hpbGQoYWRkcjogY2hpbGQpCiAgICB9Cn0\u003d", - "setupFTProvider": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgc2V0dXBGVFByb3ZpZGVyIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgRnVuZ2libGVUb2tlbiBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKCmltcG9ydCBGdW5naWJsZVRva2VuTWV0YWRhdGFWaWV3cyBmcm9tIDB4OWEwNzY2ZDkzYjY2MDhiNwoKaW1wb3J0IDxUb2tlbj4gZnJvbSA8VG9rZW5BZGRyZXNzPgoKdHJhbnNhY3Rpb24gewogICAgcHJlcGFyZShhY2N0OiBhdXRoKENhcGFiaWxpdGllcykgJkFjY291bnQpIHsKICAgICAgICBsZXQgdmF1bHREYXRhID0gRXhhbXBsZVRva2VuLnJlc29sdmVDb250cmFjdFZpZXcocmVzb3VyY2VUeXBlOiBuaWwsIHZpZXdUeXBlOiBUeXBlPEZ1bmdpYmxlVG9rZW5NZXRhZGF0YVZpZXdzLkZUVmF1bHREYXRhPigpKSBhcyEgRnVuZ2libGVUb2tlbk1ldGFkYXRhVmlld3MuRlRWYXVsdERhdGE/CiAgICAgICAgICAgID8/IHBhbmljKCJDb3VsZCBub3QgZ2V0IHRoZSB2YXVsdCBkYXRhIHZpZXcgZm9yIEV4YW1wbGVUb2tlbiIpCiAgICAKICAgICAgICBhY2N0LmNhcGFiaWxpdGllcy5zdG9yYWdlLmlzc3VlPGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJntGdW5naWJsZVRva2VuLlByb3ZpZGVyfT4odmF1bHREYXRhLnN0b3JhZ2VQYXRoKQogICAgfQp9CiA\u003d", - "setupNFTFull": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgc2V0dXBORlRGdWxsIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgppbXBvcnQgTm9uRnVuZ2libGVUb2tlbiBmcm9tIDB4NjMxZTg4YWU3ZjFkN2MyMAoKaW1wb3J0IE1ldGFkYXRhVmlld3MgZnJvbSAweDYzMWU4OGFlN2YxZDdjMjAKCgppbXBvcnQgPFRva2VuPiBmcm9tIDxUb2tlbkFkZHJlc3M+Cgp0cmFuc2FjdGlvbiB7CiAgICBwcmVwYXJlKGFjY3Q6IGF1dGgoU3RvcmFnZSwgQ2FwYWJpbGl0aWVzKSAmQWNjb3VudCkgewogICAgICAgIGxldCBkID0gRXhhbXBsZU5GVC5yZXNvbHZlQ29udHJhY3RWaWV3KHJlc291cmNlVHlwZTogbmlsLCB2aWV3VHlwZTogVHlwZTxNZXRhZGF0YVZpZXdzLk5GVENvbGxlY3Rpb25EYXRhPigpKSEgYXMhIE1ldGFkYXRhVmlld3MuTkZUQ29sbGVjdGlvbkRhdGEKCiAgICAgICAgaWYgYWNjdC5zdG9yYWdlLmJvcnJvdzwmRXhhbXBsZU5GVC5Db2xsZWN0aW9uPihmcm9tOiBkLnN0b3JhZ2VQYXRoKSA9PSBuaWwgewogICAgICAgICAgICBhY2N0LnN0b3JhZ2Uuc2F2ZSg8LSBFeGFtcGxlTkZULmNyZWF0ZUVtcHR5Q29sbGVjdGlvbigpLCB0bzogRXhhbXBsZU5GVC5Db2xsZWN0aW9uU3RvcmFnZVBhdGgpCiAgICAgICAgfQoKICAgICAgICBhY2N0LmNhcGFiaWxpdGllcy51bnB1Ymxpc2goZC5wdWJsaWNQYXRoKQogICAgICAgIGxldCBjYXAgPSBhY2N0LmNhcGFiaWxpdGllcy5zdG9yYWdlLmlzc3VlPCZ7RXhhbXBsZU5GVC5FeGFtcGxlTkZUQ29sbGVjdGlvblB1YmxpYywgTm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9uUHVibGljfT4oZC5zdG9yYWdlUGF0aCkKICAgICAgICBhY2N0LmNhcGFiaWxpdGllcy5wdWJsaXNoKGNhcCwgYXQ6IGQucHVibGljUGF0aCkKCiAgICAgICAgYWNjdC5jYXBhYmlsaXRpZXMuc3RvcmFnZS5pc3N1ZTxhdXRoKE5vbkZ1bmdpYmxlVG9rZW4uV2l0aGRyYXcpICZ7RXhhbXBsZU5GVC5FeGFtcGxlTkZUQ29sbGVjdGlvblB1YmxpYywgTm9uRnVuZ2libGVUb2tlbi5Db2xsZWN0aW9uUHVibGljLCBOb25GdW5naWJsZVRva2VuLlByb3ZpZGVyfT4oZC5zdG9yYWdlUGF0aCkKICAgIH0KfQo\u003d", - "test": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdGVzdCAtIHYyLjcyCi8vIDxwbGF0Zm9ybV9pbmZvPgoK", - "transWeth": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdHJhbnNXZXRoIC0gdjIuNzIKLy8gPHBsYXRmb3JtX2luZm8+CgovLyBGbG93IFdhbGxldCAtIG1haW5uZXQgU2NyaXB0ICB0cmFuc2ZlclRva2VucyAtIHYyLjQyCi8vIEV4dGVuc2lvbi0yLjUuMjIKCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHhmMjMzZGNlZTg4ZmUwYWJlCmltcG9ydCBjZVdFVEggZnJvbSAweDIzMWNjMGRiYmNmZmM0YjcKCnRyYW5zYWN0aW9uKGFtb3VudDogVUZpeDY0LCByZWNpcGllbnQ6IEFkZHJlc3MpIHsKCi8vIFRoZSBWYXVsdCByZXNvdXJjZSB0aGF0IGhvbGRzIHRoZSB0b2tlbnMgdGhhdCBhcmUgYmVpbmcgdHJhbnNmZXJlZApsZXQgc2VudFZhdWx0OiBAe0Z1bmdpYmxlVG9rZW4uVmF1bHR9CgpwcmVwYXJlKHNpZ25lcjogYXV0aChTdG9yYWdlLCBCb3Jyb3dWYWx1ZSkgJkFjY291bnQpIHsKICAgICAvLyBHZXQgYSByZWZlcmVuY2UgdG8gdGhlIHNpZ25lcidzIHN0b3JlZCB2YXVsdAogICAgbGV0IHZhdWx0UmVmID0gc2lnbmVyLnN0b3JhZ2UuYm9ycm93PGF1dGgoRnVuZ2libGVUb2tlbi5XaXRoZHJhdykgJmNlV0VUSC5WYXVsdD4oZnJvbTogL3N0b3JhZ2UvY2VXRVRIVmF1bHQpCiAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgcmVmZXJlbmNlIHRvIHRoZSBvd25lcidzIFZhdWx0ISIpCgogICAgLy8gV2l0aGRyYXcgdG9rZW5zIGZyb20gdGhlIHNpZ25lcidzIHN0b3JlZCB2YXVsdAogICAgc2VsZi5zZW50VmF1bHQgPC0gdmF1bHRSZWYud2l0aGRyYXcoYW1vdW50OiBhbW91bnQpCn0KCmV4ZWN1dGUgewogICAgLy8gR2V0IHRoZSByZWNpcGllbnQncyBwdWJsaWMgYWNjb3VudCBvYmplY3QKICAgIGxldCByZWNpcGllbnRBY2NvdW50ID0gZ2V0QWNjb3VudChyZWNpcGllbnQpCgogICAgLy8gR2V0IGEgcmVmZXJlbmNlIHRvIHRoZSByZWNpcGllbnQncyBSZWNlaXZlcgogICAgbGV0IHJlY2VpdmVyUmVmID0gcmVjaXBpZW50QWNjb3VudC5jYXBhYmlsaXRpZXMuYm9ycm93PCZ7RnVuZ2libGVUb2tlbi5WYXVsdH0+KC9wdWJsaWMvY2VXRVRIVmF1bHQpIQogICAgICAgIAogICAgLy8gRGVwb3NpdCB0aGUgd2l0aGRyYXduIHRva2VucyBpbiB0aGUgcmVjaXBpZW50J3MgcmVjZWl2ZXIKICAgIHJlY2VpdmVyUmVmLmRlcG9zaXQoZnJvbTogPC1zZWxmLnNlbnRWYXVsdCkKfQp9", - "transferTokens": "Ly8gRmxvdyBXYWxsZXQgLSB0ZXN0bmV0IFNjcmlwdCAgdHJhbnNmZXJUb2tlbnMgLSB2Mi43MgovLyA8cGxhdGZvcm1faW5mbz4KCmltcG9ydCBGdW5naWJsZVRva2VuIGZyb20gMHg5YTA3NjZkOTNiNjYwOGI3CgppbXBvcnQgRmxvd1Rva2VuIGZyb20gMHg3ZTYwZGYwNDJhOWMwODY4CgoKdHJhbnNhY3Rpb24ocmVjaXBpZW50OiBBZGRyZXNzLCBhbW91bnQ6IFVGaXg2NCkgewogICAgLy8gVGhlIFZhdWx0IHJlc291cmNlIHRoYXQgaG9sZHMgdGhlIHRva2VucyB0aGF0IGFyZSBiZWluZyB0cmFuc2ZlcmVkCiAgICBsZXQgc2VudFZhdWx0OiBAe0Z1bmdpYmxlVG9rZW4uVmF1bHR9CiAgICBwcmVwYXJlKHNpZ25lcjogYXV0aChTdG9yYWdlLCBCb3Jyb3dWYWx1ZSkgJkFjY291bnQpIHsKICAgICAgICAgLy8gR2V0IGEgcmVmZXJlbmNlIHRvIHRoZSBzaWduZXIncyBzdG9yZWQgdmF1bHQKICAgICAgICBsZXQgdmF1bHRSZWYgPSBzaWduZXIuc3RvcmFnZS5ib3Jyb3c8YXV0aChGdW5naWJsZVRva2VuLldpdGhkcmF3KSAmRmxvd1Rva2VuLlZhdWx0Pihmcm9tOiAvc3RvcmFnZS9GbG93VG9rZW5WYXVsdCkKICAgICAgICAgICAgPz8gcGFuaWMoIkNvdWxkIG5vdCBib3Jyb3cgcmVmZXJlbmNlIHRvIHRoZSBvd25lcidzIFZhdWx0ISIpCgogICAgICAgIC8vIFdpdGhkcmF3IHRva2VucyBmcm9tIHRoZSBzaWduZXIncyBzdG9yZWQgdmF1bHQKICAgICAgICBzZWxmLnNlbnRWYXVsdCA8LSB2YXVsdFJlZi53aXRoZHJhdyhhbW91bnQ6IGFtb3VudCkKICAgIH0KCiAgICBleGVjdXRlIHsKICAgICAgICAvLyBHZXQgdGhlIHJlY2lwaWVudCdzIHB1YmxpYyBhY2NvdW50IG9iamVjdAogICAgICAgIGxldCByZWNpcGllbnRBY2NvdW50ID0gZ2V0QWNjb3VudChyZWNpcGllbnQpCgogICAgICAgIC8vIEdldCBhIHJlZmVyZW5jZSB0byB0aGUgcmVjaXBpZW50J3MgUmVjZWl2ZXIKICAgICAgICBsZXQgcmVjZWl2ZXJSZWYgPSByZWNpcGllbnRBY2NvdW50LmNhcGFiaWxpdGllcy5ib3Jyb3c8JntGdW5naWJsZVRva2VuLlJlY2VpdmVyfT4oL3B1YmxpYy9GbG93VG9rZW5SZWNlaXZlcikhCiAgICAgICAgICAgIAogICAgICAgIC8vIERlcG9zaXQgdGhlIHdpdGhkcmF3biB0b2tlbnMgaW4gdGhlIHJlY2lwaWVudCdzIHJlY2VpdmVyCiAgICAgICAgcmVjZWl2ZXJSZWYuZGVwb3NpdChmcm9tOiA8LXNlbGYuc2VudFZhdWx0KQogICAgfQp9" - } + "version": "1.0" } }, - "version": "2.72" + "version": "2.78" }, - "status": 200.0 -} \ No newline at end of file + "status": 200 +} diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt index 9a899009..c185c7f6 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/account/AccountManager.kt @@ -128,6 +128,9 @@ object AccountManager { // Migrate key material to independent storage now that accounts are loaded. // This must run inside the ioScope block so accounts list is fully populated. safeRun { KeyStorageMigration.runMigrationIfNeeded() } + // Load emoji list for current account before building wallet data, + // otherwise getEmojiByAddress() sees an empty list and re-randomizes emojis. + AccountEmojiManager.init() // Update Accounts info with WalletDataManager WalletDataManager.updateWalletData() diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/emoji/AccountEmojiManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/emoji/AccountEmojiManager.kt index 4e653595..a92633c7 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/emoji/AccountEmojiManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/emoji/AccountEmojiManager.kt @@ -85,7 +85,7 @@ object AccountEmojiManager { val filterEmojiList = getEmojiList().filter { emoji -> emoji.id !in idList } - return if(filterEmojiList.isEmpty()) Emoji.PENGUIN else filterEmojiList.random() + return if (filterEmojiList.isEmpty()) getEmojiList().random() else filterEmojiList.random() } fun changeEmojiInfo(userName: String, address: String, emojiId: Int, emojiName: String) { @@ -142,13 +142,43 @@ object AccountEmojiManager { val usedIds = emojiList.map { it.emojiId } val available = getEmojiList().filter { it.id !in usedIds } - val emoji = if (available.isEmpty()) Emoji.PENGUIN else available.random() + val emoji = if (available.isEmpty()) getEmojiList().random() else available.random() val info = WalletEmojiInfo(address, emoji.id, emoji.defaultName) emojiList.add(info) AccountManager.updateWalletEmojiInfo(username, emojiList.toMutableList()) return info } + /** + * Remove emoji entries whose address is not in [validAddresses]. + * This prevents stale entries from exhausting the 12-emoji pool. + */ + @Synchronized + fun cleanStaleEntries(validAddresses: Set) { + val before = accountEmojiList.size + accountEmojiList.removeAll { it.address !in validAddresses } + if (accountEmojiList.size != before) { + val username = AccountManager.userInfo()?.username ?: return + AccountManager.updateWalletEmojiInfo(username, accountEmojiList.toMutableList()) + } + } + + /** + * Remove emoji entries whose address is not in [validAddresses] from the given per-account list. + */ + @Synchronized + fun cleanStaleEntriesForAccount( + validAddresses: Set, + username: String, + emojiList: MutableList + ) { + val before = emojiList.size + emojiList.removeAll { it.address !in validAddresses } + if (emojiList.size != before) { + AccountManager.updateWalletEmojiInfo(username, emojiList.toMutableList()) + } + } + fun clear() { accountEmojiList.clear() listeners.clear() diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/evm/COAVisibilityCache.kt b/app/src/main/java/com/flowfoundation/wallet/manager/evm/COAVisibilityCache.kt new file mode 100644 index 00000000..3a35f123 --- /dev/null +++ b/app/src/main/java/com/flowfoundation/wallet/manager/evm/COAVisibilityCache.kt @@ -0,0 +1,40 @@ +package com.flowfoundation.wallet.manager.evm + +import java.util.concurrent.ConcurrentHashMap + +/** + * Thread-safe singleton cache for COA (Cadence-Owned Account) EVM address visibility. + * + * Tracks which EVM addresses have been verified to have assets (FLOW balance, EVM tokens, or NFTs) + * and should be displayed in the wallet list. Each entry has a 30-minute TTL to avoid stale data. + * + * Shared across DrawerLayoutViewModel and AccountListViewModel to avoid redundant API calls. + * Cleared automatically via [com.flowfoundation.wallet.network.clearUserCache] on network/account switch. + */ +object COAVisibilityCache { + + private const val TTL_MS = 30L * 60 * 1000 // 30 minutes + + private val cache = ConcurrentHashMap() + + fun isVerified(evmAddress: String): Boolean { + val timestamp = cache[evmAddress] ?: return false + if (System.currentTimeMillis() - timestamp > TTL_MS) { + cache.remove(evmAddress) + return false + } + return true + } + + fun markVerified(evmAddress: String) { + cache[evmAddress] = System.currentTimeMillis() + } + + fun markUnverified(evmAddress: String) { + cache.remove(evmAddress) + } + + fun clear() { + cache.clear() + } +} diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/evm/EVMWalletManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/evm/EVMWalletManager.kt index 79ddc0da..e59d326f 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/evm/EVMWalletManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/evm/EVMWalletManager.kt @@ -72,7 +72,7 @@ object EVMWalletManager { fun getEVMAddressByAddress(address: String): String? { val evmAddress = AccountManager.walletNodes() ?.filterIsInstance() - ?.firstOrNull { it.address == address } + ?.firstOrNull { it.address.equals(address, true) } ?.linkedWallets ?.filterIsInstance() ?.firstOrNull()?.address diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/evm/Utils.kt b/app/src/main/java/com/flowfoundation/wallet/manager/evm/Utils.kt index aa2b2c0d..3a9effc4 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/evm/Utils.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/evm/Utils.kt @@ -5,7 +5,6 @@ import com.flowfoundation.wallet.BuildConfig import com.flowfoundation.wallet.R import com.flowfoundation.wallet.manager.app.networkChainId import com.flowfoundation.wallet.manager.app.networkRPCUrl -import com.flowfoundation.wallet.manager.config.AppConfig import com.flowfoundation.wallet.manager.config.isWrapEOATxWithCadence import com.flowfoundation.wallet.manager.flowjvm.EVM_GAS_LIMIT import com.flowfoundation.wallet.manager.flowjvm.cadenceGetNonce @@ -49,7 +48,7 @@ import wallet.core.jni.proto.Ethereum import wallet.core.jni.Hash import java.math.BigInteger -suspend fun loadInitJS(): String { +fun loadInitJS(): String { // Refresh account data first DAppEVMConnectionManager.refreshAccounts() @@ -166,7 +165,9 @@ Unit) { // Parse transaction parameters val chainId = networkChainId().toBigInteger() val valueAmount = Numeric.decodeQuantity(transaction.value ?: "0x0") - val gasLimit = Numeric.decodeQuantity(transaction.gas ?: "0x5208") + val gasLimit = transaction.gas?.let { + Numeric.decodeQuantity(it) + } ?: EVM_GAS_LIMIT.toBigInteger() // Check for EIP-1559 parameters val maxFeePerGasStr = transaction.maxFeePerGas diff --git a/app/src/main/java/com/flowfoundation/wallet/manager/walletdata/WalletDataManager.kt b/app/src/main/java/com/flowfoundation/wallet/manager/walletdata/WalletDataManager.kt index 118ac81e..80f71173 100644 --- a/app/src/main/java/com/flowfoundation/wallet/manager/walletdata/WalletDataManager.kt +++ b/app/src/main/java/com/flowfoundation/wallet/manager/walletdata/WalletDataManager.kt @@ -20,6 +20,8 @@ import com.flowfoundation.wallet.wallet.toAddress import kotlinx.coroutines.async import kotlinx.coroutines.awaitAll import kotlinx.coroutines.flow.first +import kotlinx.coroutines.sync.Semaphore +import kotlinx.coroutines.sync.withPermit import kotlinx.coroutines.withTimeout import org.onflow.flow.infrastructure.Cadence @@ -258,7 +260,7 @@ object WalletDataManager { // 3. Merge both sources to avoid losing networks (like Testnet) when indexer is slow val allBlockchainData = (indexerBlockchainData + backendBlockchainData) - .distinctBy { "${it.address}-${it.chainId}" } + .distinctBy { "${it.address.lowercase()}-${it.chainId}" } .filter { it.address.isNotBlank() } logd(TAG, "Merged blockchain data: ${allBlockchainData.map { "${it.address} (${it.chainId})" }}") @@ -267,6 +269,14 @@ object WalletDataManager { val nodes = mutableListOf() logd(TAG, "Fetching data for ${allBlockchainData.size} BlockchainData entries for node construction") + + // Collect all valid addresses before emoji assignment to clean stale entries + val validAddresses = mutableSetOf() + allBlockchainData.forEach { validAddresses.add(it.address) } + // EOA addresses will be added below; existing EOAs are included now + account.walletNodes.filterIsInstance().forEach { validAddresses.add(it.address) } + AccountEmojiManager.cleanStaleEntries(validAddresses) + fun getEmojiInfo(address: String) = AccountEmojiManager.getEmojiByAddress(address) // EOA Wallet - canDeriveEoa is determined per-wallet by WalletCreationHelper @@ -301,69 +311,72 @@ object WalletDataManager { } } + val semaphore = Semaphore(3) kotlinx.coroutines.supervisorScope { val deferredFlowNodes = allBlockchainData.map { blockchainData -> val address = blockchainData.address val chainId = blockchainData.chainId async { - // Find existing node if any to preserve existing linked wallets - val existingNode = account.walletNodes.filterIsInstance() - .firstOrNull { it.address == address && it.chainIdString == chainId } - - val linkedWallets = mutableListOf() - - // Start with existing linked wallets to prevent flickering/loss on error - existingNode?.linkedWallets?.let { linkedWallets.addAll(it) } - - try { - // Update Child Accounts - val children = fetchChildAccountsForAddress(address) - // Only update if we successfully fetched something or if we know for sure it's empty - // (Here assuming fetchChildAccountsForAddress returns emptyList on error, - // but we might want to check log logs. For now, strict replacement is risky without error diff. - // Better strategy: replace specific types only if fetch succeeds) - - if (children.isNotEmpty()) { - val nonChildLinks = linkedWallets.filter { it !is ChildWallet } - val newChildren = children.map { child -> - ChildWallet( - address = child.address, - name = child.name, - icon = child.icon, - emojiId = getEmojiInfo(child.address).emojiId - ) + semaphore.withPermit { + // Find existing node if any to preserve existing linked wallets + val existingNode = account.walletNodes.filterIsInstance() + .firstOrNull { it.address.equals(address, ignoreCase = true) && it.chainIdString == chainId } + + val linkedWallets = mutableListOf() + + // Start with existing linked wallets to prevent flickering/loss on error + existingNode?.linkedWallets?.let { linkedWallets.addAll(it) } + + try { + // Update Child Accounts + val children = fetchChildAccountsForAddress(address) + // Only update if we successfully fetched something or if we know for sure it's empty + // (Here assuming fetchChildAccountsForAddress returns emptyList on error, + // but we might want to check log logs. For now, strict replacement is risky without error diff. + // Better strategy: replace specific types only if fetch succeeds) + + if (children.isNotEmpty()) { + val nonChildLinks = linkedWallets.filter { it !is ChildWallet } + val newChildren = children.map { child -> + ChildWallet( + address = child.address, + name = child.name, + icon = child.icon, + emojiId = getEmojiInfo(child.address).emojiId + ) + } + linkedWallets.clear() + linkedWallets.addAll(nonChildLinks + newChildren) } - linkedWallets.clear() - linkedWallets.addAll(nonChildLinks + newChildren) - } - // Update COA - val coa = fetchEVMAddressForAddress(address) - if (coa != null) { - val nonCoaLinks = linkedWallets.filter { it !is COAWallet } - val coaEmojiInfo = getEmojiInfo(coa) - linkedWallets.clear() - linkedWallets.addAll(nonCoaLinks + COAWallet( - address = coa, - name = coaEmojiInfo.emojiName, - emojiId = coaEmojiInfo.emojiId - )) - logd(TAG, "Updated COA for $address: $coa") + // Update COA + val coa = fetchEVMAddressForAddress(address) + if (coa != null) { + val nonCoaLinks = linkedWallets.filter { it !is COAWallet } + val coaEmojiInfo = getEmojiInfo(coa) + linkedWallets.clear() + linkedWallets.addAll(nonCoaLinks + COAWallet( + address = coa, + name = coaEmojiInfo.emojiName, + emojiId = coaEmojiInfo.emojiId + )) + logd(TAG, "Updated COA for $address: $coa") + } + } catch (e: Exception) { + logd(TAG, "Error updating linked data for $address: ${e.message}") + // Keep existing linkedWallets on error } - } catch (e: Exception) { - logd(TAG, "Error updating linked data for $address: ${e.message}") - // Keep existing linkedWallets on error - } - val emojiInfo = getEmojiInfo(address) - FlowWallet( - address = address, - name = emojiInfo.emojiName, - emojiId = emojiInfo.emojiId, - chainIdString = chainId, - linkedWallets = linkedWallets - ) + val emojiInfo = getEmojiInfo(address) + FlowWallet( + address = address, + name = emojiInfo.emojiName, + emojiId = emojiInfo.emojiId, + chainIdString = chainId, + linkedWallets = linkedWallets + ) + } } } nodes.addAll(deferredFlowNodes.awaitAll()) @@ -401,6 +414,13 @@ object WalletDataManager { val nodes = mutableListOf() val accountUsername = account.userInfo.username val accountEmojiList = (account.walletEmojiList ?: emptyList()).toMutableList() + + // Collect valid addresses and clean stale emoji entries before assignment + val validAddresses = mutableSetOf() + walletList.forEach { validAddresses.add(it.address) } + account.walletNodes.filterIsInstance().forEach { validAddresses.add(it.address) } + AccountEmojiManager.cleanStaleEntriesForAccount(validAddresses, accountUsername, accountEmojiList) + fun getEmojiInfo(address: String) = AccountEmojiManager.getEmojiByAddressForAccount( address, accountUsername, accountEmojiList ) diff --git a/app/src/main/java/com/flowfoundation/wallet/network/UserRegisterUtils.kt b/app/src/main/java/com/flowfoundation/wallet/network/UserRegisterUtils.kt index 568586d2..f645ee1d 100644 --- a/app/src/main/java/com/flowfoundation/wallet/network/UserRegisterUtils.kt +++ b/app/src/main/java/com/flowfoundation/wallet/network/UserRegisterUtils.kt @@ -19,6 +19,7 @@ import com.flowfoundation.wallet.manager.app.chainNetWorkString import com.flowfoundation.wallet.manager.app.isMainnet import com.flowfoundation.wallet.manager.app.refreshChainNetworkSync import com.flowfoundation.wallet.manager.emoji.AccountEmojiManager +import com.flowfoundation.wallet.manager.evm.COAVisibilityCache import com.flowfoundation.wallet.manager.evm.DAppEVMConnectionManager import com.flowfoundation.wallet.manager.key.AndroidKeystoreCryptoProvider import com.flowfoundation.wallet.manager.key.CryptoProviderManager @@ -652,6 +653,7 @@ suspend fun clearUserCache() { StakingManager.clear() CryptoProviderManager.clear() cleanBackupMnemonicPreference() + COAVisibilityCache.clear() delay(1000) } diff --git a/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt b/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt index 92026e07..990cbf7a 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt @@ -8,6 +8,7 @@ import com.flowfoundation.wallet.manager.account.AccountVisibilityManager import com.flowfoundation.wallet.manager.app.chainNetWorkString import com.flowfoundation.wallet.manager.emoji.AccountEmojiManager import com.flowfoundation.wallet.manager.emoji.OnEmojiUpdate +import com.flowfoundation.wallet.manager.evm.COAVisibilityCache import com.flowfoundation.wallet.manager.flowjvm.cadenceGetAllFlowBalance import com.flowfoundation.wallet.manager.wallet.WalletManager import com.flowfoundation.wallet.manager.walletdata.COAWallet @@ -56,9 +57,6 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { private val service by lazy { retrofitApi().create(ApiService::class.java) } - // Cache for verified EVM addresses that should be included in linkedAccounts - private val verifiedEvmAddresses = mutableSetOf() - init { AccountEmojiManager.addListener(this) } @@ -75,6 +73,8 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { val addressList = mutableListOf() val accounts = mutableListOf() val pendingEvmAddresses = mutableListOf>() // EVM address to wallet address mapping + val hideCOAWithZeroBalance = isHideCOAWithZeroBalanceEnable() + val selectedAddress = WalletManager.selectedWalletAddress() walletNodes.forEach { mainNode -> when (mainNode) { @@ -85,7 +85,7 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { address = mainNode.address, name = mainNode.name, emojiId = mainNode.emojiId, - isSelected = WalletManager.selectedWalletAddress().equals(mainNode.address, ignoreCase = true), + isSelected = selectedAddress.equals(mainNode.address, ignoreCase = true), isEOAAccount = true ) ) @@ -104,7 +104,7 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { name = linkedWallet.name, icon = linkedWallet.icon, emojiId = linkedWallet.emojiId, - isSelected = WalletManager.selectedWalletAddress().equals(linkedWallet.address, ignoreCase = true), + isSelected = selectedAddress.equals(linkedWallet.address, ignoreCase = true), isCOAAccount = false ) ) @@ -112,20 +112,21 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { is COAWallet -> { val evmAddress = linkedWallet.address addressList.add(evmAddress) - // Restore logic: Only add if verified, otherwise add to pending - if (evmAddress !in verifiedEvmAddresses) { - pendingEvmAddresses.add(Pair(evmAddress, mainNode.address)) - } else { + val isSelected = selectedAddress.equals(evmAddress, ignoreCase = true) + // Show immediately if: currently selected, preference disabled, or cache-verified + if (isSelected || !hideCOAWithZeroBalance || COAVisibilityCache.isVerified(evmAddress)) { linkedAccounts.add( LinkedAccountData( address = evmAddress, name = linkedWallet.name, icon = null, emojiId = linkedWallet.emojiId, - isSelected = WalletManager.selectedWalletAddress().equals(evmAddress, ignoreCase = true), + isSelected = isSelected, isCOAAccount = true ) ) + } else { + pendingEvmAddresses.add(Pair(evmAddress, mainNode.address)) } } } @@ -136,7 +137,7 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { address = mainNode.address, name = mainNode.name, emojiId = mainNode.emojiId, - isSelected = WalletManager.selectedWalletAddress().equals(mainNode.address, ignoreCase = true), + isSelected = selectedAddress.equals(mainNode.address, ignoreCase = true), linkedAccounts = linkedAccounts, isEOAAccount = false ) @@ -226,28 +227,42 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { } _balanceMap.value = formattedBalanceMap - val hideCOAWithZeroBalance = isHideCOAWithZeroBalanceEnable() + val selectedAddress = WalletManager.selectedWalletAddress() // Check each pending EVM address pendingEvmAddresses.forEach { (evmAddress, walletAddress) -> - val shouldShow = if (!hideCOAWithZeroBalance) { - true - } else { + // Skip balance check for the currently selected COA — it's always shown + if (selectedAddress.equals(evmAddress, ignoreCase = true)) { + COAVisibilityCache.markVerified(evmAddress) + return@forEach + } + + val shouldShow = run { + // 1. Check FLOW balance val evmBalance = balanceMap[evmAddress] - val hasBalance = evmBalance != null && evmBalance > BigDecimal.ZERO - var hasNFTs = false - - if (!hasBalance) { - try { - val nftResponse = service.getEVMNFTCollections(evmAddress) - val totalNftCount = nftResponse.data?.sumOf { it.count ?: 0 } ?: 0 - hasNFTs = nftResponse.data?.isNotEmpty() == true && totalNftCount > 0 - } catch (_: Exception) { - // Ignore NFT API errors - } + if (evmBalance != null && evmBalance > BigDecimal.ZERO) return@run true + + // 2. Check EVM token balances (USDC, WETH, etc.) + try { + val tokenResponse = service.getEVMTokenList(evmAddress, null, null) + val hasEvmTokens = tokenResponse.data?.any { token -> + token.balance?.toBigDecimalOrNull()?.let { it > BigDecimal.ZERO } == true + } == true + if (hasEvmTokens) return@run true + } catch (_: Exception) { + // Ignore EVM token API errors + } + + // 3. Check NFT collections + try { + val nftResponse = service.getEVMNFTCollections(evmAddress) + val totalNftCount = nftResponse.data?.sumOf { it.count ?: 0 } ?: 0 + if (nftResponse.data?.isNotEmpty() == true && totalNftCount > 0) return@run true + } catch (_: Exception) { + // Ignore NFT API errors } - hasBalance || hasNFTs + false } if (shouldShow) { @@ -255,7 +270,6 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { val currentAccounts = _accounts.value.toMutableList() val walletAccount = currentAccounts.find { it.address == walletAddress } walletAccount?.let { account -> - // Check if EVM address already exists in linked accounts val alreadyExists = account.linkedAccounts.any { it.address == evmAddress } if (!alreadyExists) { val emojiInfo = AccountEmojiManager.getEmojiByAddress(evmAddress) @@ -266,7 +280,7 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { name = emojiInfo.emojiName, icon = null, emojiId = emojiInfo.emojiId, - isSelected = WalletManager.selectedWalletAddress().equals(evmAddress, ignoreCase = true), + isSelected = selectedAddress.equals(evmAddress, ignoreCase = true), isCOAAccount = true ) ) @@ -277,13 +291,10 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { _accounts.value = currentAccounts } } - // Add to verified cache for future refreshWalletList calls - verifiedEvmAddresses.add(evmAddress) + COAVisibilityCache.markVerified(evmAddress) } } else { // Remove EVM address from linked accounts if it no longer has assets - // (Though typically it wouldn't be there yet if it was pending, - // this handles the case where it might have been removed or balance drained) val currentAccounts = _accounts.value.toMutableList() val walletAccount = currentAccounts.find { it.address == walletAddress } walletAccount?.let { account -> @@ -299,8 +310,7 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { } } } - // Remove from verified cache - verifiedEvmAddresses.remove(evmAddress) + COAVisibilityCache.markUnverified(evmAddress) } } } diff --git a/app/src/main/java/com/flowfoundation/wallet/page/dialog/common/AddNewAccountDialog.kt b/app/src/main/java/com/flowfoundation/wallet/page/dialog/common/AddNewAccountDialog.kt index 6469ff05..70bb0f08 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/dialog/common/AddNewAccountDialog.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/dialog/common/AddNewAccountDialog.kt @@ -97,7 +97,7 @@ private fun AddNewAccountContent( modifier = Modifier .fillMaxWidth() .background( - color = colorResource(id = R.color.deep_bg), + color = colorResource(id = R.color.deep_bg_dialog), shape = RoundedCornerShape(topStart = 16.dp, topEnd = 16.dp) ) .padding(18.dp) diff --git a/app/src/main/java/com/flowfoundation/wallet/page/dialog/profile/ProfileSwitchDialog.kt b/app/src/main/java/com/flowfoundation/wallet/page/dialog/profile/ProfileSwitchDialog.kt index d3c9813e..a5d97464 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/dialog/profile/ProfileSwitchDialog.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/dialog/profile/ProfileSwitchDialog.kt @@ -107,7 +107,7 @@ private fun ProfileSwitchContent( modifier = Modifier .fillMaxWidth() .background( - color = colorResource(id = R.color.deep_bg), + color = colorResource(id = R.color.deep_bg_dialog), shape = RoundedCornerShape(topStart = 16.dp, topEnd = 16.dp) ) .padding(18.dp) diff --git a/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt b/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt index 84c3a9fd..b5cf7d4b 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt @@ -7,6 +7,7 @@ import com.flowfoundation.wallet.manager.account.AccountManager import com.flowfoundation.wallet.manager.app.chainNetWorkString import com.flowfoundation.wallet.manager.emoji.AccountEmojiManager import com.flowfoundation.wallet.manager.emoji.OnEmojiUpdate +import com.flowfoundation.wallet.manager.evm.COAVisibilityCache import com.flowfoundation.wallet.manager.evm.EVMWalletManager import com.flowfoundation.wallet.manager.flowjvm.cadenceGetAllFlowBalance import com.flowfoundation.wallet.manager.walletdata.FlowWallet @@ -62,9 +63,6 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { private val service by lazy { retrofitApi().create(ApiService::class.java) } - // Cache for verified EVM addresses that should be included in linkedAccounts - private val verifiedEvmAddresses = mutableSetOf() - init { AccountManager.addListener(this) AccountEmojiManager.addListener(this) @@ -87,6 +85,8 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { val addressList = mutableListOf() val accounts = mutableListOf() val pendingEvmAddresses = mutableListOf>() // EVM address to wallet address mapping + val hideCOAWithZeroBalance = isHideCOAWithZeroBalanceEnable() + val selectedAddress = WalletManager.selectedWalletAddress() walletNodes.forEach { mainNode -> when (mainNode) { @@ -97,7 +97,7 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { address = mainNode.address, name = mainNode.name, emojiId = mainNode.emojiId, - isSelected = WalletManager.selectedWalletAddress().equals(mainNode.address, ignoreCase = true), + isSelected = selectedAddress.equals(mainNode.address, ignoreCase = true), isEOAAccount = true ) ) @@ -116,7 +116,7 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { name = linkedWallet.name, icon = linkedWallet.icon, emojiId = linkedWallet.emojiId, - isSelected = WalletManager.selectedWalletAddress().equals(linkedWallet.address, ignoreCase = true), + isSelected = selectedAddress.equals(linkedWallet.address, ignoreCase = true), isCOAAccount = false ) ) @@ -124,19 +124,21 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { is COAWallet -> { val evmAddress = linkedWallet.address addressList.add(evmAddress) - if (evmAddress !in verifiedEvmAddresses) { - pendingEvmAddresses.add(Pair(evmAddress, mainNode.address)) - } else { + val isSelected = selectedAddress.equals(evmAddress, ignoreCase = true) + // Show immediately if: currently selected, preference disabled, or cache-verified + if (isSelected || !hideCOAWithZeroBalance || COAVisibilityCache.isVerified(evmAddress)) { linkedAccounts.add( LinkedAccountData( address = evmAddress, name = linkedWallet.name, icon = null, emojiId = linkedWallet.emojiId, - isSelected = WalletManager.selectedWalletAddress().equals(evmAddress, ignoreCase = true), + isSelected = isSelected, isCOAAccount = true ) ) + } else { + pendingEvmAddresses.add(Pair(evmAddress, mainNode.address)) } } } @@ -147,7 +149,7 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { address = mainNode.address, name = mainNode.name, emojiId = mainNode.emojiId, - isSelected = WalletManager.selectedWalletAddress().equals(mainNode.address, ignoreCase = true), + isSelected = selectedAddress.equals(mainNode.address, ignoreCase = true), linkedAccounts = linkedAccounts ) ) @@ -231,7 +233,6 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { } } } - private fun fetchAllBalances(addressList: List, pendingEvmAddresses: List> = emptyList()) { ioScope { val balanceMap = cadenceGetAllFlowBalance(addressList) ?: return@ioScope @@ -240,28 +241,42 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { } _balanceMap.value = formattedBalanceMap - val hideCOAWithZeroBalance = isHideCOAWithZeroBalanceEnable() + val selectedAddress = WalletManager.selectedWalletAddress() // Check each pending EVM address pendingEvmAddresses.forEach { (evmAddress, walletAddress) -> - val shouldShow = if (!hideCOAWithZeroBalance) { - true - } else { + // Skip balance check for the currently selected COA — it's always shown + if (selectedAddress.equals(evmAddress, ignoreCase = true)) { + COAVisibilityCache.markVerified(evmAddress) + return@forEach + } + + val shouldShow = run { + // 1. Check FLOW balance val evmBalance = balanceMap[evmAddress] - val hasBalance = evmBalance != null && evmBalance > BigDecimal.ZERO - var hasNFTs = false - - if (!hasBalance) { - try { - val nftResponse = service.getEVMNFTCollections(evmAddress) - val totalNftCount = nftResponse.data?.sumOf { it.count ?: 0 } ?: 0 - hasNFTs = nftResponse.data?.isNotEmpty() == true && totalNftCount > 0 - } catch (_: Exception) { - // Ignore NFT API errors - } + if (evmBalance != null && evmBalance > BigDecimal.ZERO) return@run true + + // 2. Check EVM token balances (USDC, WETH, etc.) + try { + val tokenResponse = service.getEVMTokenList(evmAddress, null, null) + val hasEvmTokens = tokenResponse.data?.any { token -> + token.balance?.toBigDecimalOrNull()?.let { it > BigDecimal.ZERO } == true + } == true + if (hasEvmTokens) return@run true + } catch (_: Exception) { + // Ignore EVM token API errors + } + + // 3. Check NFT collections + try { + val nftResponse = service.getEVMNFTCollections(evmAddress) + val totalNftCount = nftResponse.data?.sumOf { it.count ?: 0 } ?: 0 + if (nftResponse.data?.isNotEmpty() == true && totalNftCount > 0) return@run true + } catch (_: Exception) { + // Ignore NFT API errors } - hasBalance || hasNFTs + false } if (shouldShow) { @@ -269,7 +284,6 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { val currentAccounts = _accounts.value.toMutableList() val walletAccount = currentAccounts.find { it.address == walletAddress } walletAccount?.let { account -> - // Check if EVM address already exists in linked accounts val alreadyExists = account.linkedAccounts.any { it.address == evmAddress } if (!alreadyExists) { val emojiInfo = AccountEmojiManager.getEmojiByAddress(evmAddress) @@ -280,7 +294,7 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { name = emojiInfo.emojiName, icon = null, emojiId = emojiInfo.emojiId, - isSelected = WalletManager.selectedWalletAddress() == evmAddress, + isSelected = selectedAddress.equals(evmAddress, ignoreCase = true), isCOAAccount = true ) ) @@ -291,8 +305,7 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { _accounts.value = currentAccounts } } - // Add to verified cache for future refreshWalletList calls - verifiedEvmAddresses.add(evmAddress) + COAVisibilityCache.markVerified(evmAddress) } } else { // Remove EVM address from linked accounts if it no longer has assets @@ -311,8 +324,7 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { } } } - // Remove from verified cache - verifiedEvmAddresses.remove(evmAddress) + COAVisibilityCache.markUnverified(evmAddress) } } } diff --git a/app/src/main/res/layout/dialog_add_collection_confirm.xml b/app/src/main/res/layout/dialog_add_collection_confirm.xml index c346176c..e68e02e4 100644 --- a/app/src/main/res/layout/dialog_add_collection_confirm.xml +++ b/app/src/main/res/layout/dialog_add_collection_confirm.xml @@ -95,7 +95,7 @@ + android:backgroundTint="@color/deep_bg_dialog"> diff --git a/app/src/main/res/layout/dialog_fcl_wrong_network.xml b/app/src/main/res/layout/dialog_fcl_wrong_network.xml index 91c5c55a..c4308b10 100644 --- a/app/src/main/res/layout/dialog_fcl_wrong_network.xml +++ b/app/src/main/res/layout/dialog_fcl_wrong_network.xml @@ -6,7 +6,7 @@ android:layout_width="match_parent" android:layout_height="wrap_content" android:background="@drawable/bg_top_radius_16dp" - android:backgroundTint="@color/deep_bg" + android:backgroundTint="@color/deep_bg_dialog" android:orientation="vertical" android:paddingHorizontal="18dp" android:paddingTop="18dp" diff --git a/app/src/main/res/layout/dialog_link_account.xml b/app/src/main/res/layout/dialog_link_account.xml index 1640aa4a..6eca6ecc 100644 --- a/app/src/main/res/layout/dialog_link_account.xml +++ b/app/src/main/res/layout/dialog_link_account.xml @@ -6,7 +6,7 @@ android:layout_width="match_parent" android:layout_height="wrap_content" android:background="@drawable/bg_top_radius_16dp" - android:backgroundTint="@color/deep_bg" + android:backgroundTint="@color/deep_bg_dialog" android:paddingBottom="@dimen/wallet_create_button_margin"> @@ -112,4 +112,4 @@ app:cornerRadius="12dp" app:layout_constraintTop_toBottomOf="@id/content_wrapper" app:rippleColor="@color/primary10"/> - \ No newline at end of file + diff --git a/app/src/main/res/layout/dialog_root_detected.xml b/app/src/main/res/layout/dialog_root_detected.xml index 13558324..fdffccdb 100644 --- a/app/src/main/res/layout/dialog_root_detected.xml +++ b/app/src/main/res/layout/dialog_root_detected.xml @@ -5,7 +5,7 @@ android:layout_width="match_parent" android:layout_height="wrap_content" android:background="@drawable/bg_top_radius_16dp" - android:backgroundTint="@color/deep_bg" + android:backgroundTint="@color/deep_bg_dialog" android:paddingBottom="@dimen/wallet_create_button_margin"> @@ -153,7 +153,7 @@ android:layout_width="36dp" android:layout_height="16dp" android:src="@drawable/ic_unlink_mid" - android:background="@color/deep_bg" + android:background="@color/deep_bg_dialog" app:layout_constraintBottom_toBottomOf="@id/line" app:layout_constraintEnd_toEndOf="@id/line" app:layout_constraintStart_toStartOf="@id/line" diff --git a/app/src/main/res/layout/dialog_wallet_confirmation.xml b/app/src/main/res/layout/dialog_wallet_confirmation.xml index ecb2c5ab..68616ee5 100644 --- a/app/src/main/res/layout/dialog_wallet_confirmation.xml +++ b/app/src/main/res/layout/dialog_wallet_confirmation.xml @@ -42,7 +42,7 @@ android:layout_height="136dp" android:layout_marginHorizontal="18dp" android:layout_marginTop="10dp" - app:cardBackgroundColor="@color/deep_bg" + app:cardBackgroundColor="@color/deep_bg_dialog" app:cardCornerRadius="16dp" app:cardElevation="0dp" app:layout_constraintTop_toBottomOf="@id/title_view"> diff --git a/app/src/main/res/layout/fragment_evm_account.xml b/app/src/main/res/layout/fragment_evm_account.xml index 9708a641..f2490af6 100644 --- a/app/src/main/res/layout/fragment_evm_account.xml +++ b/app/src/main/res/layout/fragment_evm_account.xml @@ -6,7 +6,7 @@ android:layout_width="match_parent" android:layout_height="wrap_content" android:background="@drawable/bg_top_radius_16dp" - android:backgroundTint="@color/deep_bg" + android:backgroundTint="@color/deep_bg_dialog" android:paddingHorizontal="18dp" android:paddingTop="18dp" android:paddingBottom="@dimen/wallet_create_button_margin"> diff --git a/app/src/main/res/layout/fragment_evm_select_account.xml b/app/src/main/res/layout/fragment_evm_select_account.xml index b8b19cba..eccf7ded 100644 --- a/app/src/main/res/layout/fragment_evm_select_account.xml +++ b/app/src/main/res/layout/fragment_evm_select_account.xml @@ -6,7 +6,7 @@ android:layout_height="wrap_content" android:minHeight="500dp" android:background="@drawable/bg_top_radius_16dp" - android:backgroundTint="@color/deep_bg" + android:backgroundTint="@color/deep_bg_dialog" android:padding="24dp"> diff --git a/app/src/main/res/values-night/colors.xml b/app/src/main/res/values-night/colors.xml index 5e94ba53..26daeb0a 100644 --- a/app/src/main/res/values-night/colors.xml +++ b/app/src/main/res/values-night/colors.xml @@ -55,6 +55,7 @@ #C44536 #261C1B #000000 + #121212 #333333 diff --git a/app/src/main/res/values/colors.xml b/app/src/main/res/values/colors.xml index fd949cf9..692a086b 100644 --- a/app/src/main/res/values/colors.xml +++ b/app/src/main/res/values/colors.xml @@ -90,6 +90,7 @@ #1a1a1a #ffffff #fafafa + #fafafa #f0f0f0 #00ffffff From cfa82f75dd43866fd8623b3be576cab11e1f9df1 Mon Sep 17 00:00:00 2001 From: Meng Date: Tue, 24 Mar 2026 11:37:16 +0800 Subject: [PATCH 24/27] fix: account bridge & eth sign with address --- .../reactnative/bridge/NativeFRWBridge.kt | 2 +- .../bridge/handlers/AccountBridgeHandler.kt | 273 +++++++----------- .../bridge/handlers/WalletBridgeHandler.kt | 6 +- 3 files changed, 104 insertions(+), 177 deletions(-) diff --git a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/NativeFRWBridge.kt b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/NativeFRWBridge.kt index a0a8c823..9d460a08 100644 --- a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/NativeFRWBridge.kt +++ b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/NativeFRWBridge.kt @@ -431,7 +431,7 @@ class NativeFRWBridge(reactContext: ReactApplicationContext) : NativeFRWBridgeSp } } - override fun ethSign(hexData: String?, promise: Promise?) = walletHandler.ethSign(hexData, promise) + override fun ethSign(hexData: String?, address: String?, promise: Promise?) = walletHandler.ethSign(hexData, address, promise) override fun listenTransaction(txid: String) = walletHandler.listenTransaction(txid) diff --git a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/AccountBridgeHandler.kt b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/AccountBridgeHandler.kt index aabe25db..6aa80af0 100644 --- a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/AccountBridgeHandler.kt +++ b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/AccountBridgeHandler.kt @@ -7,8 +7,6 @@ import com.flowfoundation.wallet.cache.recentTransactionCache import com.flowfoundation.wallet.manager.account.Account import com.flowfoundation.wallet.manager.account.AccountManager import com.flowfoundation.wallet.manager.evm.EVMWalletManager -import com.flowfoundation.wallet.manager.evm.EVMWalletManager.isValidEVMAddress -import com.flowfoundation.wallet.manager.evm.EVMWalletManager.toChecksumEVMAddress import com.flowfoundation.wallet.manager.flowjvm.currentKeyId import com.flowfoundation.wallet.manager.key.CryptoProviderManager import com.flowfoundation.wallet.manager.wallet.WalletManager @@ -101,33 +99,24 @@ class AccountBridgeHandler(private val reactContext: ReactApplicationContext) { ioScope { try { val bridgeAccounts = mutableListOf() - - // Get main wallet address - for hardware-backed keys, wallet() returns null, - // so we need to use selectedWalletAddress() as fallback - var mainAddress = WalletManager.getCurrentFlowWalletAddress() - if (mainAddress.isNullOrEmpty()) { - // Hardware-backed key fallback: use the selected address - mainAddress = WalletManager.selectedWalletAddress() + val currentAccount = AccountManager.get() ?: run { + val emptyResponse = RNBridge.WalletAccountsResponse(accounts = emptyList()) + uiScope { promise.resolve(bridgeModelToWritableMap(emptyResponse)) } + return@ioScope } - val mainEmojiInfo = createEmojiInfo(mainAddress) - if (mainAddress.isNotEmpty()) { - // For secure enclave COA accounts, check if main address has EVM capabilities - // If it does, set type to EVM instead of MAIN - // Check both evmAddressMap and getEVMAddress() since evmAddressMap might not be populated yet - val mainAccountType = try { - val isEVM = EVMWalletManager.isEVMWalletAddress(mainAddress) || - mainAddress.equals(EVMWalletManager.getEVMAddress(), ignoreCase = true) || - isValidEVMAddress(mainAddress) - if (isEVM) { - RNBridge.AccountType.EVM - } else { - RNBridge.AccountType.MAIN - } - } catch (e: Exception) { - RNBridge.AccountType.MAIN - } - val mainAccount = RNBridge.WalletAccount( + val currentNetwork = com.flowfoundation.wallet.manager.app.chainNetWorkString() + + // 1. Process FlowWallets (main account + linked wallets) + val flowWallets = currentAccount.walletNodes.filterIsInstance() + .filter { it.chainIdString == currentNetwork } + + flowWallets.forEach { flowWallet -> + val mainAddress = flowWallet.address + val mainEmojiInfo = createEmojiInfo(mainAddress) + + // Main account + bridgeAccounts.add(RNBridge.WalletAccount( id = "main", name = mainEmojiInfo?.name ?: "Main Account", address = mainAddress, @@ -136,134 +125,75 @@ class AccountBridgeHandler(private val reactContext: ReactApplicationContext) { parentAddress = null, avatar = null, isActive = isSelectedWalletAddress(mainAddress), - type = mainAccountType, + type = RNBridge.AccountType.MAIN, balance = null, nfts = null, - ) - bridgeAccounts.add(mainAccount) - } - - // Get child accounts - try { - val childAccounts = WalletManager.childAccountList(mainAddress) - childAccounts.forEach { childAccount -> - val childAccountBridge = RNBridge.WalletAccount( - id = "child_${childAccount.address}", - name = childAccount.name, - address = childAccount.address, - emojiInfo = null, - parentEmoji = mainEmojiInfo, - parentAddress = mainAddress, - avatar = childAccount.icon, - isActive = isSelectedWalletAddress(childAccount.address), - type = RNBridge.AccountType.CHILD, - balance = null, - nfts = null, - ) - bridgeAccounts.add(childAccountBridge) - } - } catch (e: Exception) { - // Child accounts might not be available, continue without them - println("Child accounts not available: ${e.message}") - } - - // Get EVM address if available - // For Secure Type (hardware-backed keys), skip adding separate EVM account entry - // because the COA child account already represents the EVM account - var evmAddress: String? = null - val currentAccount = AccountManager.get() - val isSecureType = !currentAccount?.prefix.isNullOrBlank() - - try { - evmAddress = EVMWalletManager.getEVMAddress() - if (!evmAddress.isNullOrEmpty()) { - // Check if EVM address matches any child account address - // If it does, don't add a separate EVM account entry (it's already represented as a child account) - val childAccounts = WalletManager.childAccountList(mainAddress) - val evmMatchesChildAccount = childAccounts.any { - it.address.equals(evmAddress, ignoreCase = true) - } - - // Only add EVM account entry if: - // 1. Not Secure Type (Recovery Phrase flow), OR - // 2. EVM address doesn't match any child account (shouldn't happen, but safety check) - if (!isSecureType || !evmMatchesChildAccount) { - val evmEmojiInfo = createEmojiInfo(evmAddress) - - val evmAccount = RNBridge.WalletAccount( - id = "evm", - name = evmEmojiInfo?.name ?: "EVM Account", - address = evmAddress, - parentAddress = mainAddress, - emojiInfo = evmEmojiInfo, - parentEmoji = mainEmojiInfo, - avatar = null, - isActive = isSelectedWalletAddress(evmAddress), - type = RNBridge.AccountType.EVM, - balance = null, - nfts = null, - ) - bridgeAccounts.add(evmAccount) + )) + + // Linked wallets (COA/EVM + Child) + flowWallet.linkedWallets.forEach { linkedWallet -> + when (linkedWallet) { + is COAWallet -> { + val evmEmojiInfo = createEmojiInfo(linkedWallet.address) + bridgeAccounts.add(RNBridge.WalletAccount( + id = "evm", + name = evmEmojiInfo?.name ?: linkedWallet.name, + address = linkedWallet.address, + parentAddress = mainAddress, + emojiInfo = evmEmojiInfo, + parentEmoji = mainEmojiInfo, + avatar = null, + isActive = isSelectedWalletAddress(linkedWallet.address), + type = RNBridge.AccountType.EVM, + balance = null, + nfts = null, + )) + } + is ChildWallet -> { + bridgeAccounts.add(RNBridge.WalletAccount( + id = "child_${linkedWallet.address}", + name = linkedWallet.name, + address = linkedWallet.address, + emojiInfo = null, + parentEmoji = mainEmojiInfo, + parentAddress = mainAddress, + avatar = linkedWallet.icon, + isActive = isSelectedWalletAddress(linkedWallet.address), + type = RNBridge.AccountType.CHILD, + balance = null, + nfts = null, + )) + } } } - } catch (e: Exception) { - // EVM account might not be available, continue without it - println("EVM account not available: ${e.message}") } - // Get EOA addresses only if they're different from EVM address - // For Secure Type (COA) accounts, EOA and EVM addresses are the same, - // so we should only show the EVM account to avoid duplicate "EOA" chip - try { - val isSecureTypeAccount = !currentAccount?.prefix.isNullOrBlank() - val eoaWallets = AccountManager.walletNodes() - ?.filterIsInstance() ?: emptyList() - - for (eoaWallet in eoaWallets) { - val eoaAddress = eoaWallet.address - if (eoaAddress.isEmpty()) continue - - // Only add EOA if: - // 1. EOA address is different from EVM address, AND - // 2. Account is NOT Secure Type (Recovery Phrase account) - val isDifferentFromEVM = evmAddress == null || - !eoaAddress.equals(evmAddress, ignoreCase = true) - - if (isDifferentFromEVM && !isSecureTypeAccount) { - val eoaEmojiInfo = createEmojiInfo(eoaAddress) - val eoaAccount = RNBridge.WalletAccount( - id = "eoa_${eoaAddress}", - name = eoaEmojiInfo?.name ?: "EOA Account", - address = eoaAddress, - parentAddress = mainAddress, - emojiInfo = eoaEmojiInfo, - parentEmoji = mainEmojiInfo, - avatar = null, - isActive = isSelectedWalletAddress(eoaAddress), - type = RNBridge.AccountType.EOA, - balance = null, - nfts = null, - ) - bridgeAccounts.add(eoaAccount) - } - } - } catch (e: Exception) { - // EOA accounts might not be available, continue without them - println("EOA accounts not available: ${e.message}") + // 2. Process EOAWallets (already correctly populated by WalletDataManager based on canDeriveEoa) + currentAccount.walletNodes.filterIsInstance().forEach { eoaWallet -> + val eoaAddress = eoaWallet.address + if (eoaAddress.isEmpty()) return@forEach + + val eoaEmojiInfo = createEmojiInfo(eoaAddress) + bridgeAccounts.add(RNBridge.WalletAccount( + id = "eoa_${eoaAddress}", + name = eoaEmojiInfo?.name ?: "EOA Account", + address = eoaAddress, + parentAddress = null, + emojiInfo = eoaEmojiInfo, + parentEmoji = null, + avatar = null, + isActive = isSelectedWalletAddress(eoaAddress), + type = RNBridge.AccountType.EOA, + balance = null, + nfts = null, + )) } val response = RNBridge.WalletAccountsResponse(accounts = bridgeAccounts) - val result = bridgeModelToWritableMap(response) - - uiScope { - promise.resolve(result) - } + uiScope { promise.resolve(bridgeModelToWritableMap(response)) } } catch (e: Exception) { val emptyResponse = RNBridge.WalletAccountsResponse(accounts = emptyList()) - val result = bridgeModelToWritableMap(emptyResponse) - uiScope { - promise.resolve(result) - } + uiScope { promise.resolve(bridgeModelToWritableMap(emptyResponse)) } } } } @@ -478,36 +408,33 @@ class AccountBridgeHandler(private val reactContext: ReactApplicationContext) { } } - // Add EOA addresses only for currently selected wallet - val mainAddress = flowWallets.firstOrNull()?.address - if (mainAddress != null && isSelectedWalletAddress(mainAddress)) { - try { - val eoaWallets = AccountManager.walletNodes() - ?.filterIsInstance() ?: emptyList() - - for (eoaWallet in eoaWallets) { - val eoaAddress = eoaWallet.address - if (eoaAddress.isEmpty()) continue - - val eoaEmojiInfo = createEmojiInfo(eoaAddress) - val eoaAccount = RNBridge.WalletAccount( - id = "eoa_${eoaAddress}", - name = eoaEmojiInfo?.name ?: "EVM Account (EOA)", - address = eoaAddress, - parentAddress = mainAddress, - emojiInfo = eoaEmojiInfo, - parentEmoji = null, - avatar = null, - isActive = isSelectedWalletAddress(eoaAddress), - type = RNBridge.AccountType.EOA, - balance = null, - nfts = null, - ) - bridgeAccounts.add(eoaAccount) - } - } catch (e: Exception) { - logw(TAG, "createWalletProfileFromAccount() - EOA accounts not available: ${e.message}") + // Add EOA addresses from account's walletNodes + // EOAWallet is only present when canDeriveEoa=true (populated by WalletDataManager) + try { + val eoaWallets = account.walletNodes.filterIsInstance() + + for (eoaWallet in eoaWallets) { + val eoaAddress = eoaWallet.address + if (eoaAddress.isEmpty()) continue + + val eoaEmojiInfo = createEmojiInfo(eoaAddress) + val eoaAccount = RNBridge.WalletAccount( + id = "eoa_${eoaAddress}", + name = eoaEmojiInfo?.name ?: "EVM Account (EOA)", + address = eoaAddress, + parentAddress = null, + emojiInfo = eoaEmojiInfo, + parentEmoji = null, + avatar = null, + isActive = isSelectedWalletAddress(eoaAddress), + type = RNBridge.AccountType.EOA, + balance = null, + nfts = null, + ) + bridgeAccounts.add(eoaAccount) } + } catch (e: Exception) { + logw(TAG, "createWalletProfileFromAccount() - EOA accounts not available: ${e.message}") } // Create wallet profile diff --git a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/WalletBridgeHandler.kt b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/WalletBridgeHandler.kt index 60fe6f8b..e2b2a89a 100644 --- a/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/WalletBridgeHandler.kt +++ b/app/src/main/java/com/flowfoundation/wallet/reactnative/bridge/handlers/WalletBridgeHandler.kt @@ -45,11 +45,11 @@ class WalletBridgeHandler(private val reactContext: ReactApplicationContext) { } } - fun ethSign(hexData: String?, promise: Promise?) { + fun ethSign(hexData: String?, address: String?, promise: Promise?) { ioScope { try { - logd(TAG, "ethSign() called with hexData: $hexData") - val eoaIndex = WalletManager.getSelectedEOAIndex() + logd(TAG, "ethSign() called with hexData: $hexData, address: $address") + val eoaIndex = WalletManager.getEOAIndexForAddress(address ?: "") val signature = WalletManager.wallet()?.ethSignDigest(hexData?.hexToBytes() ?: throw IllegalArgumentException("hexData is null"), index = eoaIndex) if (signature != null && signature.isNotEmpty()) { val result = Numeric.toHexString(signature) From 44a1f05919b6d162561428627982f40f5a3229d1 Mon Sep 17 00:00:00 2001 From: Meng Date: Wed, 25 Mar 2026 14:32:44 +0800 Subject: [PATCH 25/27] fix: coa display in profile switch --- .../page/account/AccountListViewModel.kt | 14 ++++----- .../dialog/profile/ProfileSwitchViewModel.kt | 29 ++++++++++++++----- .../page/main/drawer/DrawerLayoutViewModel.kt | 14 ++++----- .../layout_wallet_coordinator_header.xml | 2 +- gradle.properties | 2 +- 5 files changed, 37 insertions(+), 24 deletions(-) diff --git a/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt b/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt index 990cbf7a..99e5e482 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/account/AccountListViewModel.kt @@ -268,9 +268,9 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { if (shouldShow) { // Add EVM address to linked accounts val currentAccounts = _accounts.value.toMutableList() - val walletAccount = currentAccounts.find { it.address == walletAddress } + val walletAccount = currentAccounts.find { it.address.equals(walletAddress, ignoreCase = true) } walletAccount?.let { account -> - val alreadyExists = account.linkedAccounts.any { it.address == evmAddress } + val alreadyExists = account.linkedAccounts.any { it.address.equals(evmAddress, ignoreCase = true) } if (!alreadyExists) { val emojiInfo = AccountEmojiManager.getEmojiByAddress(evmAddress) val updatedLinkedAccounts = account.linkedAccounts.toMutableList() @@ -285,7 +285,7 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { ) ) val updatedAccount = account.copy(linkedAccounts = updatedLinkedAccounts) - val accountIndex = currentAccounts.indexOfFirst { it.address == walletAddress } + val accountIndex = currentAccounts.indexOfFirst { it.address.equals(walletAddress, ignoreCase = true) } if (accountIndex >= 0) { currentAccounts[accountIndex] = updatedAccount _accounts.value = currentAccounts @@ -296,14 +296,14 @@ class AccountListViewModel : ViewModel(), OnEmojiUpdate { } else { // Remove EVM address from linked accounts if it no longer has assets val currentAccounts = _accounts.value.toMutableList() - val walletAccount = currentAccounts.find { it.address == walletAddress } + val walletAccount = currentAccounts.find { it.address.equals(walletAddress, ignoreCase = true) } walletAccount?.let { account -> - val existingLinkedAccount = account.linkedAccounts.find { it.address == evmAddress } + val existingLinkedAccount = account.linkedAccounts.find { it.address.equals(evmAddress, ignoreCase = true) } if (existingLinkedAccount != null) { val updatedLinkedAccounts = account.linkedAccounts.toMutableList() - updatedLinkedAccounts.removeAll { it.address == evmAddress } + updatedLinkedAccounts.removeAll { it.address.equals(evmAddress, ignoreCase = true) } val updatedAccount = account.copy(linkedAccounts = updatedLinkedAccounts) - val accountIndex = currentAccounts.indexOfFirst { it.address == walletAddress } + val accountIndex = currentAccounts.indexOfFirst { it.address.equals(walletAddress, ignoreCase = true) } if (accountIndex >= 0) { currentAccounts[accountIndex] = updatedAccount _accounts.value = currentAccounts diff --git a/app/src/main/java/com/flowfoundation/wallet/page/dialog/profile/ProfileSwitchViewModel.kt b/app/src/main/java/com/flowfoundation/wallet/page/dialog/profile/ProfileSwitchViewModel.kt index 0cfcd51d..d520c352 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/dialog/profile/ProfileSwitchViewModel.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/dialog/profile/ProfileSwitchViewModel.kt @@ -173,21 +173,34 @@ class ProfileSwitchViewModel : ViewModel() { flowWallet.linkedWallets.filterIsInstance().forEach { coaWallet -> val coaAddress = coaWallet.address - // Only show COA if it has balance or NFTs - val coaBalance = balanceMap[coaAddress] - val hasBalance = coaBalance != null && coaBalance > BigDecimal.ZERO - var hasNFTs = false + // Only show COA if it has balance, EVM tokens, or NFTs + val shouldShowCoa = run { + // 1. Check FLOW balance + val coaBalance = balanceMap[coaAddress] + if (coaBalance != null && coaBalance > BigDecimal.ZERO) return@run true - if (!hasBalance) { + // 2. Check EVM token balances (USDC, WETH, etc.) + try { + val tokenResponse = service.getEVMTokenList(coaAddress, null, null) + val hasEvmTokens = tokenResponse.data?.any { token -> + token.balance?.toBigDecimalOrNull()?.let { it > BigDecimal.ZERO } == true + } == true + if (hasEvmTokens) return@run true + } catch (_: Exception) { + // Ignore EVM token API errors + } + + // 3. Check NFT collections try { val nftResponse = service.getEVMNFTCollections(coaAddress) val totalNftCount = nftResponse.data?.sumOf { it.count ?: 0 } ?: 0 - hasNFTs = nftResponse.data?.isNotEmpty() == true && totalNftCount > 0 - } catch (e: Exception) { + if (nftResponse.data?.isNotEmpty() == true && totalNftCount > 0) return@run true + } catch (_: Exception) { // Ignore NFT API errors } + + false } - val shouldShowCoa = hasBalance || hasNFTs if (shouldShowCoa) { // Add if not present diff --git a/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt b/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt index b5cf7d4b..fe22b75e 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt @@ -282,9 +282,9 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { if (shouldShow) { // Add EVM address to linked accounts val currentAccounts = _accounts.value.toMutableList() - val walletAccount = currentAccounts.find { it.address == walletAddress } + val walletAccount = currentAccounts.find { it.address.equals(walletAddress, true) } walletAccount?.let { account -> - val alreadyExists = account.linkedAccounts.any { it.address == evmAddress } + val alreadyExists = account.linkedAccounts.any { it.address.equals(evmAddress, true) } if (!alreadyExists) { val emojiInfo = AccountEmojiManager.getEmojiByAddress(evmAddress) val updatedLinkedAccounts = account.linkedAccounts.toMutableList() @@ -299,7 +299,7 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { ) ) val updatedAccount = account.copy(linkedAccounts = updatedLinkedAccounts) - val accountIndex = currentAccounts.indexOfFirst { it.address == walletAddress } + val accountIndex = currentAccounts.indexOfFirst { it.address.equals(walletAddress, ignoreCase = true) } if (accountIndex >= 0) { currentAccounts[accountIndex] = updatedAccount _accounts.value = currentAccounts @@ -310,14 +310,14 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { } else { // Remove EVM address from linked accounts if it no longer has assets val currentAccounts = _accounts.value.toMutableList() - val walletAccount = currentAccounts.find { it.address == walletAddress } + val walletAccount = currentAccounts.find { it.address.equals(walletAddress, ignoreCase = true) } walletAccount?.let { account -> - val existingLinkedAccount = account.linkedAccounts.find { it.address == evmAddress } + val existingLinkedAccount = account.linkedAccounts.find { it.address.equals(evmAddress, ignoreCase = true) } if (existingLinkedAccount != null) { val updatedLinkedAccounts = account.linkedAccounts.toMutableList() - updatedLinkedAccounts.removeAll { it.address == evmAddress } + updatedLinkedAccounts.removeAll { it.address.equals(evmAddress, ignoreCase = true) } val updatedAccount = account.copy(linkedAccounts = updatedLinkedAccounts) - val accountIndex = currentAccounts.indexOfFirst { it.address == walletAddress } + val accountIndex = currentAccounts.indexOfFirst { it.address.equals(walletAddress, ignoreCase = true) } if (accountIndex >= 0) { currentAccounts[accountIndex] = updatedAccount _accounts.value = currentAccounts diff --git a/app/src/main/res/layout/layout_wallet_coordinator_header.xml b/app/src/main/res/layout/layout_wallet_coordinator_header.xml index cb3faf73..e387edcc 100644 --- a/app/src/main/res/layout/layout_wallet_coordinator_header.xml +++ b/app/src/main/res/layout/layout_wallet_coordinator_header.xml @@ -305,7 +305,7 @@ android:id="@+id/tv_token_count" android:layout_width="wrap_content" android:layout_height="wrap_content" - android:layout_marginStart="24dp" + android:layout_marginStart="16dp" android:layout_marginTop="24dp" android:fontFamily="@font/inter" android:textColor="@color/text_3" diff --git a/gradle.properties b/gradle.properties index 6c0dc2e6..55c24698 100644 --- a/gradle.properties +++ b/gradle.properties @@ -64,7 +64,7 @@ android.r8.dexing.parallel=true #android.bundle.enableUncompressedNativeLibs=false #android.experimental.enableArtProfiles=true -vCode=400000537 +vCode=400000549 vName=r3.1.0 # --- GitHub Packages (Flow Wallet Kit) --- From 7de765cbc4191925ecdeceefecfd54bfc6989608 Mon Sep 17 00:00:00 2001 From: Meng Date: Wed, 25 Mar 2026 21:25:11 +0800 Subject: [PATCH 26/27] fix: currently account hidden status --- .../page/main/drawer/DrawerLayoutViewModel.kt | 11 +++++++- .../subpage/wallet/WalletSettingActivity.kt | 27 +++++++++++-------- 2 files changed, 26 insertions(+), 12 deletions(-) diff --git a/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt b/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt index fe22b75e..89fc7aab 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/main/drawer/DrawerLayoutViewModel.kt @@ -163,12 +163,21 @@ class DrawerLayoutViewModel : ViewModel(), OnAccountUpdate, OnEmojiUpdate { // Use AccountManager (already updated before listeners fire) rather than // firebaseUid() (reads Firebase.auth.currentUser which can still be anonymous // during the auth transition window of an account switch). + // Always keep the currently selected account visible to avoid broken UI state. val userId = AccountManager.get()?.wallet?.id val filteredAccounts = if (userId != null) { AccountVisibilityManager.filterVisibleAccounts( userId, accounts - ) { it.address } + ) { it.address }.let { visible -> + // Ensure the currently selected account is always present + if (visible.none { it.address.equals(selectedAddress, ignoreCase = true) }) { + val selected = accounts.find { it.address.equals(selectedAddress, ignoreCase = true) } + if (selected != null) visible + selected else visible + } else { + visible + } + } } else { accounts } diff --git a/app/src/main/java/com/flowfoundation/wallet/page/profile/subpage/wallet/WalletSettingActivity.kt b/app/src/main/java/com/flowfoundation/wallet/page/profile/subpage/wallet/WalletSettingActivity.kt index 4603b83a..27dea2d1 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/profile/subpage/wallet/WalletSettingActivity.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/profile/subpage/wallet/WalletSettingActivity.kt @@ -34,6 +34,7 @@ import com.flowfoundation.wallet.utils.extensions.setVisible import com.flowfoundation.wallet.utils.extensions.visible import com.flowfoundation.wallet.manager.account.AccountVisibilityManager import com.flowfoundation.wallet.firebase.auth.firebaseUid +import com.flowfoundation.wallet.manager.wallet.WalletManager class WalletSettingActivity : BaseActivity(), OnEmojiUpdate { @@ -97,17 +98,21 @@ class WalletSettingActivity : BaseActivity(), OnEmojiUpdate { } // Initialize account visibility preference - val userId = firebaseUid() ?: "" - val isAccountVisible = !AccountVisibilityManager.isAccountHidden(userId, walletAddress) - showInAccountListPreference.setChecked(isAccountVisible) - showInAccountListPreference.setOnCheckedChangeListener { checked -> - val currentUserId = firebaseUid() ?: "" - if (checked) { - // User wants to show the account in the list (make it visible) - AccountVisibilityManager.showAccount(currentUserId, walletAddress) - } else { - // User wants to hide the account from the list - AccountVisibilityManager.hideAccount(currentUserId, walletAddress) + // Hide the toggle for the currently selected account — it must remain visible + val isCurrentlySelected = WalletManager.selectedWalletAddress() + .equals(walletAddress, ignoreCase = true) + showInAccountListPreference.setVisible(!isCurrentlySelected) + if (!isCurrentlySelected) { + val userId = firebaseUid() ?: "" + val isAccountVisible = !AccountVisibilityManager.isAccountHidden(userId, walletAddress) + showInAccountListPreference.setChecked(isAccountVisible) + showInAccountListPreference.setOnCheckedChangeListener { checked -> + val currentUserId = firebaseUid() ?: "" + if (checked) { + AccountVisibilityManager.showAccount(currentUserId, walletAddress) + } else { + AccountVisibilityManager.hideAccount(currentUserId, walletAddress) + } } } From 148c43982ea550615b5f2384a95d4b91945a907a Mon Sep 17 00:00:00 2001 From: Meng Date: Wed, 1 Apr 2026 07:23:40 +0800 Subject: [PATCH 27/27] feat: replace flowscan with backend api --- .../wallet/network/ExplorerUtils.kt | 22 +++++++++++++++++++ .../wallet/page/browser/Utils.kt | 6 ++--- .../common/NotificationDispatchActivity.kt | 9 +++----- .../detail/presenter/TokenDetailPresenter.kt | 5 +++-- .../TransactionViewMoreItemPresenter.kt | 16 ++++---------- 5 files changed, 35 insertions(+), 23 deletions(-) create mode 100644 app/src/main/java/com/flowfoundation/wallet/network/ExplorerUtils.kt diff --git a/app/src/main/java/com/flowfoundation/wallet/network/ExplorerUtils.kt b/app/src/main/java/com/flowfoundation/wallet/network/ExplorerUtils.kt new file mode 100644 index 00000000..3c4866ca --- /dev/null +++ b/app/src/main/java/com/flowfoundation/wallet/network/ExplorerUtils.kt @@ -0,0 +1,22 @@ +package com.flowfoundation.wallet.network + +import com.flowfoundation.wallet.manager.app.isTestnet + +/** + * Build explorer redirect URL via /api/v4/explorer endpoint. + * The server returns a 302 redirect to the appropriate block explorer. + * + * @param id Transaction hash, address, or contract identifier + * @param type "tx", "address", "account", "contract", "token" + * @param chain "flow" or "evm" + * @param network Optional, defaults to current network environment + */ +fun explorerUrl( + id: String, + type: String = "tx", + chain: String = "flow", + network: String? = null +): String { + val net = network ?: if (isTestnet()) "testnet" else "mainnet" + return "https://web.api.wallet.flow.com/api/v4/explorer?chain=$chain&network=$net&type=$type&id=$id" +} diff --git a/app/src/main/java/com/flowfoundation/wallet/page/browser/Utils.kt b/app/src/main/java/com/flowfoundation/wallet/page/browser/Utils.kt index 880012cd..8fa38595 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/browser/Utils.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/browser/Utils.kt @@ -12,8 +12,8 @@ import com.bumptech.glide.load.model.LazyHeaders import com.flowfoundation.wallet.R import com.flowfoundation.wallet.database.AppDataBase import com.flowfoundation.wallet.database.WebviewRecord -import com.flowfoundation.wallet.manager.app.isTestnet import com.flowfoundation.wallet.manager.config.AppConfig +import com.flowfoundation.wallet.network.explorerUrl import com.flowfoundation.wallet.page.browser.tools.browserTabLast import com.flowfoundation.wallet.page.browser.tools.expandWebView import com.flowfoundation.wallet.page.browser.tools.shrinkWebView @@ -159,11 +159,11 @@ fun String.toFavIcon(size: Int = 256): String { } fun openInFlowScan(activity: Activity, transactionId: String) { - openBrowser(activity, "https://${if (isTestnet()) "testnet." else ""}flowscan" + ".io/tx/$transactionId") + openBrowser(activity, explorerUrl(id = transactionId, type = "tx", chain = "flow")) } fun openInFlowEVMScan(activity: Activity, transactionId: String) { - openBrowser(activity, "https://${if (isTestnet()) "evm-testnet" else "evm"}.flowscan.io/tx/$transactionId") + openBrowser(activity, explorerUrl(id = transactionId, type = "tx", chain = "evm")) } class BrowserParams( diff --git a/app/src/main/java/com/flowfoundation/wallet/page/common/NotificationDispatchActivity.kt b/app/src/main/java/com/flowfoundation/wallet/page/common/NotificationDispatchActivity.kt index 5123c132..5df6c424 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/common/NotificationDispatchActivity.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/common/NotificationDispatchActivity.kt @@ -6,7 +6,7 @@ import com.flowfoundation.wallet.base.activity.BaseActivity import com.google.gson.Gson import com.google.gson.reflect.TypeToken import com.zackratos.ultimatebarx.ultimatebarx.UltimateBarX -import com.flowfoundation.wallet.manager.app.isTestnet +import com.flowfoundation.wallet.network.explorerUrl import com.flowfoundation.wallet.utils.logd import com.flowfoundation.wallet.utils.safeRun @@ -28,7 +28,6 @@ class NotificationDispatchActivity : BaseActivity() { } finish() - logd("xxx", "data: $data") } override fun finish() { @@ -44,8 +43,6 @@ class NotificationDispatchActivity : BaseActivity() { } private fun String.toFlowScanTransactionUrl(): String { - return if (isTestnet()) { - "https://testnet.flowscan.io/tx/$this" - } else "https://flowscan.io/tx/$this" + return explorerUrl(id = this, type = "tx", chain = "flow") } -} \ No newline at end of file +} diff --git a/app/src/main/java/com/flowfoundation/wallet/page/token/detail/presenter/TokenDetailPresenter.kt b/app/src/main/java/com/flowfoundation/wallet/page/token/detail/presenter/TokenDetailPresenter.kt index bc536a3f..231e9e84 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/token/detail/presenter/TokenDetailPresenter.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/token/detail/presenter/TokenDetailPresenter.kt @@ -22,6 +22,7 @@ import com.flowfoundation.wallet.page.profile.subpage.wallet.ChildAccountCollect import com.flowfoundation.wallet.page.receive.ReceiveActivity import com.flowfoundation.wallet.reactnative.ReactNativeActivity import com.flowfoundation.wallet.manager.app.isTestnet +import com.flowfoundation.wallet.network.explorerUrl import com.flowfoundation.wallet.reactnative.bridge.RNBridge import com.flowfoundation.wallet.reactnative.bridge.toRNBridgeTokenModel import com.flowfoundation.wallet.page.staking.openStakingPage @@ -135,9 +136,9 @@ class TokenDetailPresenter( binding.tvContractAddress.paintFlags = binding.tvContractAddress.paintFlags or Paint.UNDERLINE_TEXT_FLAG binding.tvContractAddress.setOnClickListener { val url = if (token.tokenType == FungibleTokenType.FLOW || token.isFlowToken()) { - "https://www.flowscan.io/ft/token/${token.tokenIdentifier()}" + explorerUrl(id = token.tokenIdentifier(), type = "token", chain = "flow") } else { - "https://evm.flowscan.io/token/${token.tokenAddress()}" + explorerUrl(id = token.tokenAddress(), type = "token", chain = "evm") } openBrowser(activity, url) } diff --git a/app/src/main/java/com/flowfoundation/wallet/page/transaction/record/presenter/TransactionViewMoreItemPresenter.kt b/app/src/main/java/com/flowfoundation/wallet/page/transaction/record/presenter/TransactionViewMoreItemPresenter.kt index 283842e7..62a9d0f9 100644 --- a/app/src/main/java/com/flowfoundation/wallet/page/transaction/record/presenter/TransactionViewMoreItemPresenter.kt +++ b/app/src/main/java/com/flowfoundation/wallet/page/transaction/record/presenter/TransactionViewMoreItemPresenter.kt @@ -3,8 +3,8 @@ package com.flowfoundation.wallet.page.transaction.record.presenter import android.view.View import com.flowfoundation.wallet.base.presenter.BasePresenter import com.flowfoundation.wallet.base.recyclerview.BaseViewHolder -import com.flowfoundation.wallet.manager.app.isTestnet import com.flowfoundation.wallet.manager.evm.EVMWalletManager +import com.flowfoundation.wallet.network.explorerUrl import com.flowfoundation.wallet.page.browser.openBrowser import com.flowfoundation.wallet.page.transaction.record.model.TransactionViewMoreModel import com.flowfoundation.wallet.utils.findActivity @@ -18,16 +18,8 @@ class TransactionViewMoreItemPresenter( } private fun TransactionViewMoreModel.url(): String { - return if (EVMWalletManager.isEVMWalletAddress(address)) { - if (isTestnet()) { - "https://evm-testnet.flowscan.io/address/$address" - } else { - "https://evm.flowscan.io/address/$address" - } - } else { - if (isTestnet()) { - "https://testnet.flowscan.io/account/$address" - } else "https://flowscan.io/account/$address" - } + val chain = if (EVMWalletManager.isEVMWalletAddress(address)) "evm" else "flow" + val type = if (chain == "evm") "address" else "account" + return explorerUrl(id = address, type = type, chain = chain) } } \ No newline at end of file