Merge pull request #412 from onflow/nialexsan/remove-nft-marketplace

remove nft marketplace

docs/build/basics/fees.md

@@ -125,7 +125,7 @@ You should see the `computationUsed` field. Take a note of the value, you will u
 
 **On testnet or mainnet**
 
-Once a transaction is completed, you can use an explorer like [Flowscan](https://flowscan.org/) to review the transaction details and events emitted. For Flowscan, you can open the transaction in question and look for the event `FeesDeducted` from the [`FlowFees`](https://github.com/onflow/flow-core-contracts/blob/master/contracts/FlowFees.cdc) contract:
+Once a transaction is completed, you can use an explorer like [Flowdiver](https://flowdiver.io/) to review the transaction details and events emitted. For Flowdiver, you can open the transaction in question and look for the event `FeesDeducted` from the [`FlowFees`](https://github.com/onflow/flow-core-contracts/blob/master/contracts/FlowFees.cdc) contract:
 
 ![flowscan-fees](./_fees_images/flowscan-fees.png)
 

docs/build/building-vs-other-chains.md

@@ -177,7 +177,7 @@ If you’re already familiar with blockchain development, here's a comparison be
 - [hardhat](https://hardhat.org/) / [Truffle](https://trufflesuite.com/) / [Foundry](https://github.com/foundry-rs/foundry)
     - [Flow CLI](https://github.com/onflow/flow-cli/) provides local development tools and the [Flow Emulator](https://github.com/onflow/flow-emulator)
 - [OpenZeppelin](https://www.openzeppelin.com/)
-    - No equivalent, you can pick contracts from any core Flow contract repository
+    - [Emerald OZ](https://oz.ecdao.org/overview)
 - [go-ethereum](https://geth.ethereum.org/)
     - [Flow Go SDK](https://github.com/onflow/flow-go-sdk/)
     - [FCL](https://github.com/onflow/fcl-js/) also provides Backend API for Flow in JS

docs/build/cadence.md

@@ -40,7 +40,7 @@ Cadence, a new high-level programming language, observes the following requireme
 Security is the prevention of attacks on the network or smart contracts (i.e., unauthorized actions by malicious actors).
 Safety and security are critical in smart contracts because of the immutable nature of blockchains,
 and because they often deal with high-value assets. While auditing and reviewing code will be a crucial part of smart contract development,
-Cadence maximizes efficiency while maintaining the highest levels of safety and security at its foundation.
+Cadence maximizes efficiency while maintaining the highest levels of safety and security.
 It accomplishes this via a strong static type system, design by contract, and ownership primitives inspired by linear types (which are useful when dealing with assets).
 - **Clarity:** Code needs to be easy to read, and its meaning should be as unambiguous as possible.
 It should also be suited for verification so that tooling can help with ensuring safety and security guarantees.

docs/build/getting-started/quickstarts/fcl-quickstart.md

@@ -4,7 +4,7 @@ sidebar_position: 3
 
 # Hello World Pt. 3 - Interacting with the Blockchain
 
-FCL, or Flow Client Library, is a JavaScript library developed to facilitate interactions with the Flow blockchain. It provides developers with tools to build, integrate, and interact with Flow directly from web applications. This web app quickstart will get you interacting with a contract already deployed to Flow.
+Flow Client Library (FCL), is a JavaScript library developed to facilitate interactions with the Flow blockchain. It provides developers with tools to build, integrate, and interact with Flow directly from web applications. This web app quickstart will get you interacting with a contract already deployed to Flow.
 
 For this tutorial, we're going to be making a [React](https://react.dev/learn) app with [Create React App](https://create-react-app.dev/). We'll try and keep the code as simple as possible in case you're coming from another framework.
 

docs/build/getting-started/quickstarts/flow-cli.md

@@ -4,7 +4,7 @@ sidebar_position: 2
 
 # Hello World Pt. 2 - Local Development
 
-The Flow CLI (Command Line Interface) is a set of tools that developers can use to interact with the Flow blockchain by managing accounts, sending transactions, deploying smart contracts, running the emulator, and more. This quickstart will get you familiar with its main concepts and functionality.
+The Flow Command Line Interface (CLI) is a set of tools that developers can use to interact with the Flow blockchain by managing accounts, sending transactions, deploying smart contracts, running the emulator, and more. This quickstart will get you familiar with its main concepts and functionality.
 
 ## Installation
 
@@ -18,7 +18,7 @@ For other ways of installing, please [refer to the installation guide](../../../
 
 ## Configuration
 
-Let's first create a directory, then setup a project.
+Let's first create a directory, then set up a project.
 
 ```
 mkdir cli-quickstart
@@ -30,13 +30,13 @@ And then let's navigate to our new directory:
 cd cli-quickstart
 ```
 
-Let's first create a `flow.json` file for our project (we'll use this in a later step, but this is a good spot to bring it up). The `flow.json` file is a configuration file used by the Flow CLI when interacting with the Flow blockchain. It helps manage various project-specific settings, such as network configurations, account details, contract names and source files, and deployment targets. To create one, run:
+Let's first create a `flow.json` file for our project. We'll use this in a later step, but this is a good spot to bring it up. The `flow.json` file is a configuration file used by the Flow CLI when interacting with the Flow blockchain. It helps manage various project-specific settings, such as network configurations, account details, contract names and source files, and deployment targets. To create one, run:
 
 ```
 flow init
 ```
 
-If you look at `flow.json` now you'll see it's listed access nodes for networks and accounts. The default `emulator-account` create will come in handy when we want to run the emulator.
+If you look at `flow.json` now, you'll see its listed access nodes for networks and accounts. The default `emulator-account` create will come in handy when we want to run the emulator.
 
 ## Running Scripts
 
@@ -118,7 +118,7 @@ Next we'll add a contracts section to our `flow.json` configuration that will de
 }
 ```
 
-We're also going to change the imports of our script so that there are no hardcoded network specific addresses. The CLI can figure out how to interact with the network (ie. emulator, testnet or mainnet) based on our configuration.
+We're also going to change the imports of our script so that there are no hardcoded network specific addresses. The CLI can figure out how to interact with the network (i.e. emulator, testnet or mainnet) based on our configuration.
 
 ```
 // script.cdc
@@ -166,9 +166,9 @@ flow scripts execute script.cdc --network emulator
 
 ## Creating an Account and Running a Transaction
 
-To change state on the Flow Blockchain, you need to run a transaction. Let's create a simple transaction file, we can use to modify the `greeting` on the `HelloWorld` contract.
+To change state on the Flow Blockchain, you need to run a transaction. Let's create a simple transaction file. We can use to modify the `greeting` on the `HelloWorld` contract.
 
-First, create file called `transaction.cdc` from the root of your project:
+First, create a file called `transaction.cdc` from the root of your project:
 
 ```
 touch transaction.cdc
@@ -191,9 +191,9 @@ transaction(greeting: String) {
 }
 ```
 
-This will log the account signing the transaction and call the `changeGreeting` method of the `HelloWorld` contract, and pass in the new greeting. (If you want to learn more about writing transactions, please [read here](../../basics/transactions.md)).
+This will log the account signing the transaction, call the `changeGreeting` method of the `HelloWorld` contract, and pass in the new greeting. (If you want to learn more about writing transactions, please [read here](../../basics/transactions.md)).
 
-In order to run a transaction, the signing account needs to pay for it. We could run a transaction on emulator using the default `emulator-account` account, let's learn one more command for creating accounts.
+In order to run a transaction, the signing account needs to pay for it. We could run a transaction on emulator using the default `emulator-account` account. Let's learn one more command for creating accounts.
 
 The easiest way to create an account using CLI is by running (remember, your emulator should still be running at this point in another terminal):
 

docs/build/mobile/react-native-quickstart.mdx → docs/build/mobile/react-native-quickstart.md

@@ -12,9 +12,9 @@ sidebar_position: 3
 
 FCL-JS is the easiest way to start building decentralized applications. FCL (aka Flow Client Library) wraps much of the logic you'd have to write yourself on other blockchains. Follow this quick start and you'll have a solid overview of how to build a shippable dapp on Flow.
 
-We're going to make an assumption that you know or understand React; however, the concepts should be easy to understand and transfer to another framework. While this tutorial will make use of Cadence (Flow's smart contract language), you do not need to know it. Instead, we recommend later diving into [learning the Cadence language](../../build/cadence.md) once you've gotten the core FCL concepts down.
+We're going to make an assumption that you know or understand React; however, the concepts should be easy to understand and transfer to another framework. While this tutorial will make use of Cadence (Flow's smart contract language), you do not need to know it. Instead, we recommend later diving into [learning the Cadence language](../cadence.md) once you've gotten the core FCL concepts down.
 
-In this tutorial, we are going to interact with an existing smart contract on Flow's testnet known as the [Profile Contract](https://testnet.flowscan.org/contract/A.ba1132bc08f82fe2.Profile). Using this contract, we will create a new profile and edit the profile information, both via a wallet. In order to do this, the FCL concepts we'll cover are:
+In this tutorial, we are going to interact with an existing smart contract on Flow's testnet known as the [Profile Contract](https://testnet.flowdiver.io/contract/A.ba1132bc08f82fe2.Profile). Using this contract, we will create a new profile and edit the profile information, both via a wallet. In order to do this, the FCL concepts we'll cover are:
 
 - [Installation](#installation)
 - [Configuration](#configuration)
@@ -196,7 +196,7 @@ config({
 })
 ```
 
-If you want to see the on chain smart contract we'll be speaking with next, you can view the [Profile Contract](https://testnet.flowscan.org/contract/A.ba1132bc08f82fe2.Profile) source code but again for this tutorial it's not necessary you understand it.
+If you want to see the on chain smart contract we'll be speaking with next, you can view the [Profile Contract](https://testnet.flowdiver.io/contract/A.ba1132bc08f82fe2.Profile) source code but again for this tutorial it's not necessary you understand it.
 
 **First, lets query the contract to see what the user's profile name is.** 
 
@@ -301,13 +301,13 @@ Go ahead and click the "Send Query" button. You should see "No Profile." That's
 
 ## Initializing the Account
 
-For the Profile contract to store a Profile in a user's account, it does so by initializing what is called a "resource." A resource is an ownable piece of data and functionality that can live in the user's account storage. This paradigm is known is as "resource-oriented-programming", a principle that is core to Cadence and differentiates its ownership model from other smart contract languages, [read more here](../../build/cadence.md#intuiting-ownership-with-resources). Cadence makes it so that resources can only exist in one place at any time, they must be deliberately created, cannot be copied, and if desired, must be deliberately destroyed.
+For the Profile contract to store a Profile in a user's account, it does so by initializing what is called a "resource." A resource is an ownable piece of data and functionality that can live in the user's account storage. This paradigm is known is as "resource-oriented-programming", a principle that is core to Cadence and differentiates its ownership model from other smart contract languages, [read more here](../cadence.md#intuiting-ownership-with-resources). Cadence makes it so that resources can only exist in one place at any time, they must be deliberately created, cannot be copied, and if desired, must be deliberately destroyed.
 
-> There's a lot more to resources in Cadence than we'll cover in this guide, so if you'd like to know more, check out [this Cadence intro](../../build/cadence.md).
+> There's a lot more to resources in Cadence than we'll cover in this guide, so if you'd like to know more, check out [this Cadence intro](../cadence.md).
 
 To do this resource initialization on an account, we're going to add another function called `initAccount`. Inside of that function, we're going to add some Cadence code which says, *"Hey, does this account have a profile? If it doesn't, let's add one."* We do that using something called a "transaction." Transactions occur when you want to change the state of the blockchain, in this case, some data in a resource, in a specific account. And there is a cost (transaction fee) in order to do that; unlike a query.
 
-That's where we jump back into FCL code. Instead of `query`, we use `mutate` for transactions. And because there is a cost, we need to add a few fields that tell Flow who is proposing the transaction, who is authorizing it, who is paying for it, and how much they're willing to pay for it. Those fields — not surprisingly — are called: `proposer`, `authorizer`, `payer`, and `limit`. For more information on these signatory roles, check out [this doc](../../build/basics/transactions.md#signer-roles).
+That's where we jump back into FCL code. Instead of `query`, we use `mutate` for transactions. And because there is a cost, we need to add a few fields that tell Flow who is proposing the transaction, who is authorizing it, who is paying for it, and how much they're willing to pay for it. Those fields — not surprisingly — are called: `proposer`, `authorizer`, `payer`, and `limit`. For more information on these signatory roles, check out [this doc](../basics/transactions.md#signer-roles).
 
 Let's take a look at what our account initialization function looks like:
 
@@ -341,7 +341,7 @@ const initAccount = async () => {
 }
 ```
 
-You can see the new fields we talked about. You'll also notice `fcl.authz`. That's shorthand for "use the current user to authorize this transaction", (you could also write it as `fcl.currentUser.authorization`). If you want to learn more about transactions and signing transactions, you can [view the docs here](../../build/basics/transactions.md). For this example, we'll keep it simple with the user being each of these roles.
+You can see the new fields we talked about. You'll also notice `fcl.authz`. That's shorthand for "use the current user to authorize this transaction", (you could also write it as `fcl.currentUser.authorization`). If you want to learn more about transactions and signing transactions, you can [view the docs here](../basics/transactions.md). For this example, we'll keep it simple with the user being each of these roles.
 
 You'll also notice we are awaiting a response with our transaction data by using the syntax `fcl.tx(transactionId).onceSealed()`. This will return when the blockchain has sealed the transaction and it's complete in processing it and verifying it.
 
@@ -444,7 +444,7 @@ const styles = StyleSheet.create({
 
 ```
 
-Press the "Init Account" button you should see the wallet ask you to approve a transaction. After approving, you will see a transaction response appear in your console (make sure to have that open). It may take a few moments. With the transaction result printed, you can use the `transactionId` to look up the details of the transaction using a [block explorer](https://testnet.flowscan.org).
+Press the "Init Account" button you should see the wallet ask you to approve a transaction. After approving, you will see a transaction response appear in your console (make sure to have that open). It may take a few moments. With the transaction result printed, you can use the `transactionId` to look up the details of the transaction using a [block explorer](https://testnet.flowdiver.io/).
 
 ## Mutating the Blockchain
 

docs/overview/dive-in/fungible-tokens.md

@@ -324,7 +324,7 @@ Some exchanges require payment of listing fees, but many do not. As a result, ma
 While this guide does not cover the technicals of creating your fungible token, please find a couple of resources that may be helpful as you get ready to launch your token: 
 
 - [Flow Token List](https://github.com/FlowFans/flow-token-list) - How to add a token to the Flow native token list
-- [Flowscan Request Form](https://docs.google.com/forms/d/e/1FAIpQLSdMiIkj2goF3Ib7wJHRb-YNvruwBghq1NP1IOfz4p2smIFp0w/viewform) - Please fill this out to update your token metadata on Flowscan
+- [Flowdiver Request Form](https://docs.google.com/forms/d/e/1FAIpQLSdMiIkj2goF3Ib7wJHRb-YNvruwBghq1NP1IOfz4p2smIFp0w/viewform) - Please fill this out to update your token metadata on Flowdiver
 - [Flow Developer Portal](/) - Documentation, guides, and resources for developers building on Flow
 
 ## Final Words

docs/references/run-and-secure/node-operation/FAQ.md

@@ -54,7 +54,7 @@ More on this [here](./node-migration.mdx)
 
 ### Where can I find how many nodes are currently running Flow?
 
-If you are running a node, then you most definitely have this information on your node in the file `<your bootstrap dir>/public-root-information/node-infos.pub.json`. If you are not running a node, you can find this information by using a Cadence script to query the [Staking Smart Contract](../../../references/core-contracts/06-staking-contract-reference.md) (or check [Flowscan](https://flowscan.org/staking/overview))
+If you are running a node, then you most definitely have this information on your node in the file `<your bootstrap dir>/public-root-information/node-infos.pub.json`. If you are not running a node, you can find this information by using a Cadence script to query the [Staking Smart Contract](../../../references/core-contracts/06-staking-contract-reference.md) (or check [Flowdiver](https://flowdiver.io/staking/overview))
 
 ### Why do I need to update my node's ulimit?
 

docs/references/run-and-secure/node-operation/index.md

@@ -52,7 +52,7 @@ The Archive node follows the chain, stores and indexes both protocol and executi
 
 It also allows script execution and other read-only queries that require the execution state to be read. It can answer any queries from past data e.g. “what was the Flow account balance at height X?”, where X is several thousand blocks in the past.
 
-_The archive node is currently in beta and will be available as a GA release in H2 2023 (see [here](https://flow.com/post/flow-blockchain-node-operation-archive-node) for more)_
+_The archive node is currently in beta and will be available as a GA release in H2 2023 (see [here](https://flow.com/post/flow-blockchain-node-operation-archive-node) for more)._
 
 ## Full node
 

docs/references/run-and-secure/nodes/faq/backers.mdx

@@ -7,7 +7,7 @@ description: FAQ
 
 There are two block explorers live today. You can find them here:
 
-- https://flowscan.org/
+- https://flowdiver.io/
 - https://flow.bigdipper.live/
 
 ## I staked and now I can't see my FLOW - what happened?

docs/references/run-and-secure/nodes/faq/developers.mdx

@@ -12,7 +12,7 @@ Flow’s transaction throughput depends on a variety of factors, such as network
 
 There are two block explorers live today. You can find them here:
 
-- https://flowscan.org/
+- https://flowdiver.io/
 - https://flow.bigdipper.live/
 
 ## How can I connect to and query the Access Nodes? What data is available there?

docs/references/run-and-secure/nodes/faq/operators.mdx

@@ -16,7 +16,7 @@ Flow targets 1 second block times but the protocol is still early in its develop
 
 There are two block explorers live today. You can find them here:
 
-- https://flowscan.org/
+- https://flowdiver.io/
 - https://flow.bigdipper.live/
 
 ## How can I connect to and query the Access Nodes? What data is available there?