Merge pull request #1154 from onflow/change-lilico-to-flow-wallet

bz-hashtag-0780 · web-flow · commit 66f5a2172461 · 2025-02-22T05:24:31.000+04:00
Replace 'Lilico' with 'Flow Wallet'
diff --git a/docs/build/guides/mobile/ios-quickstart.md b/docs/build/guides/mobile/ios-quickstart.md
@@ -56,14 +56,13 @@ For run in real device, there are a few steps to deal with signing:
 
    ![XCode Target Setup](resources/xcode_setup.png)
 
-
 ## Connecting to a Wallet
 
 To connect with wallets, there is native wallet discovery in the app. Once you click on connect, it will bring out the list of the wallets which support `HTTP/POST` or `WC/RPC` method.
 
 ### FCL Config
 
-To make sure, the wallet can recognise your dApp, there is a few field you will need to config before connect to a wallet. The account proof config is optional. In addition, you will need to create a project id from [walletconnect](https://cloud.walletconnect.com/app) cloud before you can connect to the `WC/RPC` compatible wallet such as dapper self custody or lilico wallet.
+To make sure, the wallet can recognise your dApp, there is a few field you will need to config before connect to a wallet. The account proof config is optional. In addition, you will need to create a project id from [walletconnect](https://cloud.walletconnect.com/app) cloud before you can connect to the `WC/RPC` compatible wallet such as [Flow Wallet](https://wallet.flow.com/).
 
 ```swift
 import FCL
@@ -166,91 +165,90 @@ During development, you always can query your NFT with `fcl.query`. Here is an e
 
 - Query cadence
 
-    ```cadence
-    import NonFungibleToken from 0xNonFungibleToken
-        import MonsterMaker from 0xMonsterMaker
-        import MetadataViews from 0xMetadataViews
-        
-        access(all) struct Monster {
-            access(all) let name: String
-            access(all) let description: String
-            access(all) let thumbnail: String
-            access(all) let itemID: UInt64
-            access(all) let resourceID: UInt64
-            access(all) let owner: Address
-            access(all) let component: MonsterMaker.MonsterComponent
-    
-            init(
-                name: String,
-                description: String,
-                thumbnail: String,
-                itemID: UInt64,
-                resourceID: UInt64,
-                owner: Address,
-                component: MonsterMaker.MonsterComponent
-            ) {
-                self.name = name
-                self.description = description
-                self.thumbnail = thumbnail
-                self.itemID = itemID
-                self.resourceID = resourceID
-                self.owner = owner
-                self.component = component
-            }
-        }
-    
-        access(all) fun getMonsterById(address: Address, itemID: UInt64): Monster? {
-    
-            if let collection = getAccount(address).capabilities.get<&MonsterMaker.Collection>(MonsterMaker.CollectionPublicPath).borrow() {
-                
-                if let item = collection.borrowMonsterMaker(id: itemID) {
-                    if let view = item.resolveView(Type<MetadataViews.Display>()) {
-                        let display = view as! MetadataViews.Display
-                        let owner: Address = item.owner!.address!
-                        let thumbnail = display.thumbnail as! MetadataViews.HTTPFile
-    
-                        return Monster(
-                            name: display.name,
-                            description: display.description,
-                            thumbnail: thumbnail.url,
-                            itemID: itemID,
-                            resourceID: item.uuid,
-                            owner: address,
-                            component: item.component
-                        )
-                    }
-                }
-            }
-    
-            return nil
-        }
-    
-        access(all) fun main(address: Address): [Monster] {
-            let account = getAccount(address)
-            let collectionRef = account.capabilities.get<&{NonFungibleToken.Collection}>(MonsterMaker.CollectionPublicPath).borrow()
-            ?? panic("The account with address "
-                    .concat(address.toString)
-                    .concat(" does not have a NonFungibleToken Collection at ")
-                    .concat(MonsterMaker.CollectionPublicPath.toString())
-                    .concat(". Make sure the account address is correct and is initialized their account with a MonsterMaker Collection!"))
-            
-            let ids = collectionRef.getIDs()
-    
-            let monsters : [Monster] = []
-    
-            for id in ids {
-                if let monster = getMonsterById(address: address, itemID: id) {
-                    monsters.append(monster)
-                }
-            }
-    
-            return monsters
-        }
-    ```
-
+  ```cadence
+  import NonFungibleToken from 0xNonFungibleToken
+      import MonsterMaker from 0xMonsterMaker
+      import MetadataViews from 0xMetadataViews
+
+      access(all) struct Monster {
+          access(all) let name: String
+          access(all) let description: String
+          access(all) let thumbnail: String
+          access(all) let itemID: UInt64
+          access(all) let resourceID: UInt64
+          access(all) let owner: Address
+          access(all) let component: MonsterMaker.MonsterComponent
+
+          init(
+              name: String,
+              description: String,
+              thumbnail: String,
+              itemID: UInt64,
+              resourceID: UInt64,
+              owner: Address,
+              component: MonsterMaker.MonsterComponent
+          ) {
+              self.name = name
+              self.description = description
+              self.thumbnail = thumbnail
+              self.itemID = itemID
+              self.resourceID = resourceID
+              self.owner = owner
+              self.component = component
+          }
+      }
+
+      access(all) fun getMonsterById(address: Address, itemID: UInt64): Monster? {
+
+          if let collection = getAccount(address).capabilities.get<&MonsterMaker.Collection>(MonsterMaker.CollectionPublicPath).borrow() {
+
+              if let item = collection.borrowMonsterMaker(id: itemID) {
+                  if let view = item.resolveView(Type<MetadataViews.Display>()) {
+                      let display = view as! MetadataViews.Display
+                      let owner: Address = item.owner!.address!
+                      let thumbnail = display.thumbnail as! MetadataViews.HTTPFile
+
+                      return Monster(
+                          name: display.name,
+                          description: display.description,
+                          thumbnail: thumbnail.url,
+                          itemID: itemID,
+                          resourceID: item.uuid,
+                          owner: address,
+                          component: item.component
+                      )
+                  }
+              }
+          }
+
+          return nil
+      }
+
+      access(all) fun main(address: Address): [Monster] {
+          let account = getAccount(address)
+          let collectionRef = account.capabilities.get<&{NonFungibleToken.Collection}>(MonsterMaker.CollectionPublicPath).borrow()
+          ?? panic("The account with address "
+                  .concat(address.toString)
+                  .concat(" does not have a NonFungibleToken Collection at ")
+                  .concat(MonsterMaker.CollectionPublicPath.toString())
+                  .concat(". Make sure the account address is correct and is initialized their account with a MonsterMaker Collection!"))
+
+          let ids = collectionRef.getIDs()
+
+          let monsters : [Monster] = []
+
+          for id in ids {
+              if let monster = getMonsterById(address: address, itemID: id) {
+                  monsters.append(monster)
+              }
+          }
+
+          return monsters
+      }
+  ```
 
 ```swift
-let nftList = try await fcl.query(script: cadenceScript, 
+let nftList = try await fcl.query(script: cadenceScript,
 																		args: [.address(address)])
 														.decode([NFTModel].self)
 ```
@@ -271,11 +269,10 @@ https://github.com/Outblock/fcl-android
 
 **FCL Wallet Connect 2.0**
 
-One of the easiest ways to connect to a wallet via a mobile native dApp is through Flow's new support for Wallet Connect 2.0. This is the pattern that Monster Maker uses to connect to the Dapper Self Custody wallet and Lilico. For more information on FCL Wallet Connect 2.0, check out this page:
+One of the easiest ways to connect to a wallet via a mobile native dApp is through Flow's new support for Wallet Connect 2.0. This is the pattern that Monster Maker uses to connect to the [Flow Wallet](https://wallet.flow.com/). For more information on FCL Wallet Connect 2.0, check out this page:
 
 [FCL Wallet Connect](../../../tools/clients/fcl-js/wallet-connect.md)
 
-
 **How to Build a Native iOS Dapp**
 
 The Agile Monkeys has written a very comprehensive guide on how to build a native mobile application on iOS and interface with fcl-swift. Found here:
diff --git a/docs/evm/using.mdx b/docs/evm/using.mdx
@@ -31,7 +31,7 @@ Manual method: Add Flow EVM as a custom network to MetaMask:
 
 | Name            | Value                                |
 | --------------- | ------------------------------------ |
-| Network Name    | Flow EVM                          |
+| Network Name    | Flow EVM                             |
 | Description     | The public RPC url for Flow Mainnet  |
 | RPC Endpoint    | https://mainnet.evm.nodes.onflow.org |
 | Chain ID        | 747                                  |
@@ -46,7 +46,7 @@ To additionally add the Flow EVM Testnet to MetaMask, follow the same steps as a
 
 | Name            | Value                                |
 | --------------- | ------------------------------------ |
-| Network Name    | Flow EVM Testnet                  |
+| Network Name    | Flow EVM Testnet                     |
 | Description     | The public RPC url for Flow Testnet  |
 | RPC Endpoint    | https://testnet.evm.nodes.onflow.org |
 | Chain ID        | 545                                  |
@@ -59,7 +59,7 @@ Use the [Flow Testnet Faucet](https://faucet.flow.com/fund-account) to fund your
 
 ### [Flow Wallet](https://wallet.flow.com)
 
-Flow Wallet is available on [Android](https://play.google.com/store/apps/details?id=io.outblock.lilico&hl=en_US&gl=US) and [iOS](https://apps.apple.com/ca/app/flow-core/id1644169603), with desktop support using the Flow Wallet [Chrome extension](https://chromewebstore.google.com/detail/flow-reference-wallet/hpclkefagolihohboafpheddmmgdffjm). In addition to being able to transact in both EVM and Cadence environments, Flow Wallet will also allow you to view and move assets between EVM and Cadence, making it possible to manage all your assets in one place.
+Flow Wallet is available on [Android](https://play.google.com/store/apps/details?id=com.flowfoundation.wallet) and [iOS](https://apps.apple.com/ca/app/flow-wallet-nfts-and-crypto/id6478996750), with desktop support using the Flow Wallet [Chrome extension](https://chromewebstore.google.com/detail/flow-reference-wallet/hpclkefagolihohboafpheddmmgdffjm). In addition to being able to transact in both EVM and Cadence environments, Flow Wallet will also allow you to view and move assets between EVM and Cadence, making it possible to manage all your assets in one place.
 
 To use the Flow Wallet Chrome extension:
 
diff --git a/docs/tools/clients/fcl-js/index.md b/docs/tools/clients/fcl-js/index.md
@@ -11,10 +11,12 @@ It was created to make developing applications that connect to the Flow blockcha
 While FCL itself is a concept and standard, FCL JS is the javascript implementation of FCL and can be used in both browser and server environments. All functionality for connecting and communicating with wallet providers is restricted to the browser. We also have FCL Swift implementation for iOS, see [FCL Swift](https://github.com/zed-io/fcl-swift) contributed by [@lmcmz](https://github.com/lmcmz).
 
 ---
+
 ## Getting Started
 
 ### Requirements
--  Node version `v12.0.0 or higher`.
+
+- Node version `v12.0.0 or higher`.
 
 ### Installation
 
@@ -27,45 +29,56 @@ npm i -S @onflow/fcl
 ```shell
 yarn add @onflow/fcl
 ```
+
 #### Importing
 
 **ES6**
+
 ```js
-import * as fcl from "@onflow/fcl";
+import * as fcl from '@onflow/fcl';
 ```
+
 **Node.js**
+
 ```js
-const fcl = require("@onflow/fcl");
+const fcl = require('@onflow/fcl');
 ```
+
 ---
+
 ## FCL for Dapps
+
 #### Wallet Interactions
 
-- *Wallet Discovery* and *Sign-up/Login*: Onboard users with ease. Never worry about supporting multiple wallets. 
-Authenticate users with any [FCL compatible wallet](./index.md#current-wallet-providers).
+- _Wallet Discovery_ and _Sign-up/Login_: Onboard users with ease. Never worry about supporting multiple wallets.
+  Authenticate users with any [FCL compatible wallet](./index.md#current-wallet-providers).
+
 ```js
 // in the browser
-import * as fcl from "@onflow/fcl"
+import * as fcl from '@onflow/fcl';
 
 fcl.config({
-  "discovery.wallet": "https://fcl-discovery.onflow.org/testnet/authn", // Endpoint set to Testnet
-})
+  'discovery.wallet': 'https://fcl-discovery.onflow.org/testnet/authn', // Endpoint set to Testnet
+});
 
-fcl.authenticate()
+fcl.authenticate();
 ```
+
 ![FCL Default Discovery UI](images/discovery.png)
 
 > **Note**: A [Dapper Wallet](https://meetdapper.com/developers) developer account is required. To enable Dapper Wallet inside FCL, you need to [follow this guide](https://docs.meetdapper.com/quickstart).
 
-- *Interact with smart contracts*: Authorize transactions via the user's chosen wallet 
-- *Prove ownership of a wallet address*: Signing and verifying user signed data
+- _Interact with smart contracts_: Authorize transactions via the user's chosen wallet
+- _Prove ownership of a wallet address_: Signing and verifying user signed data
 
 [Learn more about wallet interactions >](./api.md#wallet-interactions)
 
 #### Blockchain Interactions
-- *Query the chain*: Send arbitrary Cadence scripts to the chain and receive back decoded values
+
+- _Query the chain_: Send arbitrary Cadence scripts to the chain and receive back decoded values
+
 ```js
-import * as fcl from "@onflow/fcl";
+import * as fcl from '@onflow/fcl';
 
 const result = await fcl.query({
   cadence: `
@@ -77,14 +90,16 @@ const result = await fcl.query({
   args: (arg, t) => [
     arg(7, t.Int), // a: Int
     arg(6, t.Int), // b: Int
-    arg("0xba1132bc08f82fe2", t.Address), // addr: Address
+    arg('0xba1132bc08f82fe2', t.Address), // addr: Address
   ],
 });
 console.log(result); // 13
 ```
-- *Mutate the chain*: Send arbitrary transactions with your own signatures or via a user's wallet to perform state changes on chain.
+
+- _Mutate the chain_: Send arbitrary transactions with your own signatures or via a user's wallet to perform state changes on chain.
+
 ```js
-import * as fcl from "@onflow/fcl";
+import * as fcl from '@onflow/fcl';
 // in the browser, FCL will automatically connect to the user's wallet to request signatures to run the transaction
 const txId = await fcl.mutate({
   cadence: `
@@ -96,13 +111,14 @@ const txId = await fcl.mutate({
       }
     }
   `,
-  args: (arg, t) => [arg("myName", t.String)],
+  args: (arg, t) => [arg('myName', t.String)],
 });
 ```
 
 [Learn more about on-chain interactions >](./api.md#on-chain-interactions)
 
 #### Utilities
+
 - Get account details from any Flow address
 - Get the latest block
 - Transaction status polling
@@ -111,7 +127,6 @@ const txId = await fcl.mutate({
 
 [Learn more about utilities >](./api.md#pre-built-interactions)
 
-
 ## Next Steps
 
 See the [Flow App Quick Start](../../../build/getting-started/fcl-quickstart.md).
@@ -122,28 +137,31 @@ Learn Flow's smart contract language to build any script or transactions: [Caden
 
 Explore all of Flow [docs and tools](/).
 
-
 ---
+
 ## FCL for Wallet Providers
+
 Wallet providers on Flow have the flexibility to build their user interactions and UI through a variety of ways:
+
 - Front channel communication via Iframe, pop-up, tab, or extension
 - Back channel communication via HTTP
 
 FCL is agnostic to the communication channel and is configured to create both custodial and non-custodial wallets. This enables users to interact with wallet providers without needing to download an app or extension.
 
-The communication channels involve responding to a set of pre-defined FCL messages to deliver the requested information to the dapp.  Implementing a FCL compatible wallet on Flow is as simple as filling in the responses with the appropriate data when FCL requests them. If using any of the front-channel communication methods, FCL also provides a set of [wallet utilities](https://github.com/onflow/fcl-js/blob/master/packages/fcl/src/wallet-utils/index.js) to simplify this process.
-
+The communication channels involve responding to a set of pre-defined FCL messages to deliver the requested information to the dapp. Implementing a FCL compatible wallet on Flow is as simple as filling in the responses with the appropriate data when FCL requests them. If using any of the front-channel communication methods, FCL also provides a set of [wallet utilities](https://github.com/onflow/fcl-js/blob/master/packages/fcl/src/wallet-utils/index.js) to simplify this process.
 
 ### Current Wallet Providers
-- [Blocto](https://blocto.portto.io/en/)
-- [Ledger](https://ledger.com) (limited transaction support)
+
+- [Flow Wallet](https://wallet.flow.com/)
 - [Dapper Wallet](https://www.meetdapper.com/)
-- [Lilico](https://lilico.app/)
-- [Flipper](https://flipper.org/)
+- [Blocto](https://blocto.portto.io/en/)
 - [NuFi](https://nu.fi)
+- [Ledger](https://ledger.com) (limited transaction support)
 
 ### Wallet Discovery
+
 It can be difficult to get users to discover new wallets on a chain. To solve this, we created a wallet discovery service that can be configured and accessed through FCL to display all available Flow wallet providers to the user. This means:
+
 - Dapps can display and support all FCL compatible wallets that launch on Flow without needing to change any code
 - Users don't need to sign up for new wallets - they can carry over their existing one to any dapp that uses FCL for authentication and authorization.
 
diff --git a/src/data/tools/index.ts b/src/data/tools/index.ts

-Original file line number
+Diff line change
     'A mobile self custody wallet to help you explore the world of Flow',
 };
 -const lilicoWallet: Tool = {
 -  title: 'Lilico',
 +const flowWallet: Tool = {
 +  title: 'Flow Wallet',
   tags: ['web', 'extension', 'wallet', 'non-custodial'],
 -  link: 'https://lilico.app/',
 -  iconSrc: 'https://lilico.app/logo-cat.svg',
 -  description: 'The First Extension Wallet on Flow',
 +  link: 'https://wallet.flow.com/',
 +  iconSrc: 'https://lilico.app/logo_mobile.svg',
 +  description:
 +    'A reference wallet created for everyone. Trusted. Battle-tested. Beautifully designed.',
 };
 const fionaWallet: Tool = {
   dapperWallet,
   ledgerWallet,
   nufiWallet,
 -  lilicoWallet,
 +  flowWallet,
   fionaWallet,
   niftoryTool,
   flowviewTool,