diff --git a/src/components/Tabs/Tabs.module.css b/src/components/Tabs/Tabs.module.css
index 899e2833682..60e6cd48cef 100644
--- a/src/components/Tabs/Tabs.module.css
+++ b/src/components/Tabs/Tabs.module.css
@@ -18,6 +18,7 @@
   font-weight: var(--font-weight-medium);
   text-align: center;
   padding: var(--space-2x) var(--space-3x);
+  margin-bottom: var(--space-3x);
   outline-offset: 2px;
 }
 
diff --git a/src/content/any-api/api-reference.mdx b/src/content/any-api/api-reference.mdx
index eec97d4f5fc..6e10aea9e7a 100644
--- a/src/content/any-api/api-reference.mdx
+++ b/src/content/any-api/api-reference.mdx
@@ -10,8 +10,8 @@ import AnyApiCallout from "@features/any-api/common/AnyApiCallout.astro"
 
 <Aside type="note" title="API reference for ChainlinkClient">
 
-`ChainlinkClient` [contracts](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/ChainlinkClient.sol)
-can communicate with `Operator` [contracts](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/Operator.sol).
+`ChainlinkClient` [contracts](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/ChainlinkClient.sol)
+can communicate with `Operator` [contracts](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/Operator.sol).
 
 </Aside>
 
@@ -19,23 +19,23 @@ can communicate with `Operator` [contracts](https://github.com/smartcontractkit/
 
 ### Methods
 
-| Name                                                          | Description                                                                                                                                                                                                                                             |
-| :------------------------------------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| [setChainlinkOracle](#setchainlinkoracle)                     | Sets the stored address for the oracle contract                                                                                                                                                                                                         |
-| [setChainlinkToken](#setchainlinktoken)                       | Sets the stored address for the LINK token                                                                                                                                                                                                              |
-| [buildChainlinkRequest](#buildchainlinkrequest)               | Instantiates a Request object with the required parameters                                                                                                                                                                                              |
-| [buildOperatorRequest](#buildoperatorrequest)                 | Instantiates a Request object with the required parameters. **Note** the oracle must be an `Operator` [contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/Operator.sol)                       |
-| [sendChainlinkRequest](#sendchainlinkrequest)                 | Sends the request payload to the stored address stored as chainlinkOracleAddress                                                                                                                                                                        |
-| [sendChainlinkRequestTo](#sendchainlinkrequestto)             | Sends a request to the oracle address specified                                                                                                                                                                                                         |
-| [sendOperatorRequest](#sendoperatorrequest)                   | Sends the request payload to the stored address stored as chainlinkOracleAddress. **Note** the oracle must be an `Operator` [contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/Operator.sol) |
-| [sendOperatorRequestTo](#sendoperatorrequestto)               | Sends a request to the oracle address specified. **Note** the oracle must be an `Operator` [contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/Operator.sol)                                  |
-| [validateChainlinkCallback](#validatechainlinkcallback)       | Secures the fulfillment callback to make sure it is only called by permissioned senders                                                                                                                                                                 |
-| [addChainlinkExternalRequest](#addchainlinkexternalrequest)   | Allows a Chainlinked contract to track unfulfilled requests that it hasn't created itself                                                                                                                                                               |
-| [cancelChainlinkRequest](#cancelchainlinkrequest)             | Cancels Chainlink requests attempting to contact an unresponsive node                                                                                                                                                                                   |
-| [useChainlinkWithENS](#usechainlinkwithens)                   | Looks up the addresses of the LINK token and Oracle contract through ENS                                                                                                                                                                                |
-| [updateChainlinkOracleWithENS](#updatechainlinkoraclewithens) | Updates the stored oracle address with the latest address resolved through ENS                                                                                                                                                                          |
-| [chainlinkTokenAddress](#chainlinktokenaddress)               | Returns the stored address of the LINK token                                                                                                                                                                                                            |
-| [chainlinkOracleAddress](#chainlinkoracleaddress)             | Returns the stored address of the oracle contract                                                                                                                                                                                                       |
+| Name                                                          | Description                                                                                                                                                                                                                                          |
+| :------------------------------------------------------------ | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [setChainlinkOracle](#setchainlinkoracle)                     | Sets the stored address for the oracle contract                                                                                                                                                                                                      |
+| [setChainlinkToken](#setchainlinktoken)                       | Sets the stored address for the LINK token                                                                                                                                                                                                           |
+| [buildChainlinkRequest](#buildchainlinkrequest)               | Instantiates a Request object with the required parameters                                                                                                                                                                                           |
+| [buildOperatorRequest](#buildoperatorrequest)                 | Instantiates a Request object with the required parameters. **Note** the oracle must be an `Operator` [contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/Operator.sol)                       |
+| [sendChainlinkRequest](#sendchainlinkrequest)                 | Sends the request payload to the stored address stored as chainlinkOracleAddress                                                                                                                                                                     |
+| [sendChainlinkRequestTo](#sendchainlinkrequestto)             | Sends a request to the oracle address specified                                                                                                                                                                                                      |
+| [sendOperatorRequest](#sendoperatorrequest)                   | Sends the request payload to the stored address stored as chainlinkOracleAddress. **Note** the oracle must be an `Operator` [contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/Operator.sol) |
+| [sendOperatorRequestTo](#sendoperatorrequestto)               | Sends a request to the oracle address specified. **Note** the oracle must be an `Operator` [contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/Operator.sol)                                  |
+| [validateChainlinkCallback](#validatechainlinkcallback)       | Secures the fulfillment callback to make sure it is only called by permissioned senders                                                                                                                                                              |
+| [addChainlinkExternalRequest](#addchainlinkexternalrequest)   | Allows a Chainlinked contract to track unfulfilled requests that it hasn't created itself                                                                                                                                                            |
+| [cancelChainlinkRequest](#cancelchainlinkrequest)             | Cancels Chainlink requests attempting to contact an unresponsive node                                                                                                                                                                                |
+| [useChainlinkWithENS](#usechainlinkwithens)                   | Looks up the addresses of the LINK token and Oracle contract through ENS                                                                                                                                                                             |
+| [updateChainlinkOracleWithENS](#updatechainlinkoraclewithens) | Updates the stored oracle address with the latest address resolved through ENS                                                                                                                                                                       |
+| [chainlinkTokenAddress](#chainlinktokenaddress)               | Returns the stored address of the LINK token                                                                                                                                                                                                         |
+| [chainlinkOracleAddress](#chainlinkoracleaddress)             | Returns the stored address of the oracle contract                                                                                                                                                                                                    |
 
 ### Events
 
@@ -113,7 +113,7 @@ constructor(address _link)
 ### buildChainlinkRequest
 
 Use `buildOperatorRequest` [function](#buildoperatorrequest) if the oracle is an `Operator`
-[contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/Operator.sol).
+[contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/Operator.sol).
 
 {/* prettier-ignore */}
 ```solidity
@@ -150,7 +150,7 @@ is that `buildOperatorRequest` does not allow setting up the address of the call
 is set to the address of the calling contract.
 
 It is recommended to use `buildOperatorRequest` but make sure the oracle you are contacting is an `Operator`
-[contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/Operator.sol).
+[contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/Operator.sol).
 
 {/* prettier-ignore */}
 ```solidity
@@ -180,7 +180,7 @@ function requestPrice()
 ### sendChainlinkRequest
 
 Use `sendOperatorRequest` [function](#sendoperatorrequest) if the oracle is an `Operator`
-[contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/Operator.sol).
+[contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/Operator.sol).
 
 {/* prettier-ignore */}
 ```solidity
@@ -212,7 +212,7 @@ function requestPrice()
 ### sendChainlinkRequestTo
 
 Use `sendOperatorRequestTo` [function](#sendoperatorrequestto) if the oracle is an `Operator`
-[contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/Operator.sol).
+[contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/Operator.sol).
 
 {/* prettier-ignore */}
 ```solidity
@@ -244,7 +244,7 @@ function requestPriceFrom(address _oracle)
 
 This function is similar to `sendChainlinkRequest`[function](#sendchainlinkrequest).
 It is recommended to use `sendOperatorRequest` but make sure the oracle you are contacting is an `Operator`
-[contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/Operator.sol).
+[contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/Operator.sol).
 
 {/* prettier-ignore */}
 ```solidity
@@ -277,7 +277,7 @@ function requestPrice()
 
 This function is similar to `sendChainlinkRequestTo`[function](#sendchainlinkrequestto).
 It is recommended to use `sendOperatorRequestTo`, but make sure the oracle you are contacting is an `Operator`
-[contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/Operator.sol).
+[contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/Operator.sol).
 
 {/* prettier-ignore */}
 ```solidity
@@ -420,7 +420,7 @@ constructor(){
 
 <Aside type="caution" title="Updating oracle addresses">
 
-If an oracle provider supports listing their oracle on ENS, that provides the added security of being able to update any issues that may arise. The tradeoff here is that by using their ENS record, you are allowing whoever controls that record and the corresponding code it points to. If your contract does this, you must either audit the updated code and make sure it matches [Operator.sol](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/Operator.sol) or trust whoever can update the records.
+If an oracle provider supports listing their oracle on ENS, that provides the added security of being able to update any issues that may arise. The tradeoff here is that by using their ENS record, you are allowing whoever controls that record and the corresponding code it points to. If your contract does this, you must either audit the updated code and make sure it matches [Operator.sol](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/Operator.sol) or trust whoever can update the records.
 
 </Aside>
 
@@ -444,7 +444,7 @@ function updateOracleAddressToLatest() public {
 
 <Aside type="caution" title="Updating oracle addresses">
 
-If an oracle provider supports listing their oracle on ENS, that provides the added security of being able to update any issues that may arise. The tradeoff here is that by using their ENS record, you are allowing whoever controls that record and the corresponding code it points to. If your contract does this, you must either audit the updated code and make sure it matches [Operator.sol](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/Operator.sol) or trust whoever can update the records.
+If an oracle provider supports listing their oracle on ENS, that provides the added security of being able to update any issues that may arise. The tradeoff here is that by using their ENS record, you are allowing whoever controls that record and the corresponding code it points to. If your contract does this, you must either audit the updated code and make sure it matches [Operator.sol](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/Operator.sol) or trust whoever can update the records.
 
 </Aside>
 
diff --git a/src/content/any-api/get-request/examples/array-response.mdx b/src/content/any-api/get-request/examples/array-response.mdx
index dd8573ede29..08ba7f9e282 100644
--- a/src/content/any-api/get-request/examples/array-response.mdx
+++ b/src/content/any-api/get-request/examples/array-response.mdx
@@ -60,7 +60,7 @@ The response should be similar to the following:
 ]
 ```
 
-Fetch the _id_ of the first element. To consume an API, your contract must import [ChainlinkClient.sol](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/ChainlinkClient.sol). This contract exposes a struct named `Chainlink.Request`, which your contract can use to build the API request. The request must include the following parameters:
+Fetch the _id_ of the first element. To consume an API, your contract must import [ChainlinkClient.sol](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/ChainlinkClient.sol). This contract exposes a struct named `Chainlink.Request`, which your contract can use to build the API request. The request must include the following parameters:
 
 - Link token address
 - Oracle address
diff --git a/src/content/any-api/get-request/examples/existing-job-request.mdx b/src/content/any-api/get-request/examples/existing-job-request.mdx
index cdf5d3fcb4f..3afea4e6e65 100644
--- a/src/content/any-api/get-request/examples/existing-job-request.mdx
+++ b/src/content/any-api/get-request/examples/existing-job-request.mdx
@@ -59,7 +59,7 @@ The response should be similar to the following:
 ```
 
 For this example, we created a job that leverages the [EtherScan External Adapter](https://github.com/smartcontractkit/external-adapters-js/tree/develop/packages/sources/etherscan) to fetch the _SafeGasPrice_ , _ProposeGasPrice_ and _FastGasPrice_. You can learn more about External Adapters [here](/chainlink-nodes/external-adapters/external-adapters).
-To consume an API, your contract must import [ChainlinkClient.sol](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/ChainlinkClient.sol). This contract exposes a struct named `Chainlink.Request`, which your contract can use to build the API request. The request must include the following parameters:
+To consume an API, your contract must import [ChainlinkClient.sol](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/ChainlinkClient.sol). This contract exposes a struct named `Chainlink.Request`, which your contract can use to build the API request. The request must include the following parameters:
 
 - Link token address
 - Oracle address
diff --git a/src/content/any-api/get-request/examples/large-responses.mdx b/src/content/any-api/get-request/examples/large-responses.mdx
index 38bba1db0ef..192c41fd256 100644
--- a/src/content/any-api/get-request/examples/large-responses.mdx
+++ b/src/content/any-api/get-request/examples/large-responses.mdx
@@ -46,7 +46,7 @@ The response should be similar to the following:
 }
 ```
 
-Fetch the value of _image_. To consume an API, your contract must import [ChainlinkClient.sol](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/ChainlinkClient.sol). This contract exposes a struct named `Chainlink.Request`, which your contract can use to build the API request. The request must include the following parameters:
+Fetch the value of _image_. To consume an API, your contract must import [ChainlinkClient.sol](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/ChainlinkClient.sol). This contract exposes a struct named `Chainlink.Request`, which your contract can use to build the API request. The request must include the following parameters:
 
 - Link token address
 - Oracle address
diff --git a/src/content/any-api/get-request/examples/multi-variable-responses.mdx b/src/content/any-api/get-request/examples/multi-variable-responses.mdx
index 1ca7a55e52c..6b803ab271e 100644
--- a/src/content/any-api/get-request/examples/multi-variable-responses.mdx
+++ b/src/content/any-api/get-request/examples/multi-variable-responses.mdx
@@ -50,7 +50,7 @@ The response should be similar to the following:
 ```
 
 The request above shows how to get the price of _ETH_ against _BTC_. Now let say we want the price of _ETH_ against several currencies: _BTC_, _USD_, and _EUR_. Our contract will have to support receiving multiple responses.
-To consume an API with multiple responses, your contract should inherit from [ChainlinkClient](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/ChainlinkClient.sol). This contract exposes a struct called `Chainlink.Request`, which your contract should use to build the API request. The request should include the following parameters:
+To consume an API with multiple responses, your contract should inherit from [ChainlinkClient](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/ChainlinkClient.sol). This contract exposes a struct called `Chainlink.Request`, which your contract should use to build the API request. The request should include the following parameters:
 
 - Link token address
 - Oracle address
diff --git a/src/content/any-api/get-request/examples/single-word-response.mdx b/src/content/any-api/get-request/examples/single-word-response.mdx
index 64affe26e4a..58d1fc9b2d9 100644
--- a/src/content/any-api/get-request/examples/single-word-response.mdx
+++ b/src/content/any-api/get-request/examples/single-word-response.mdx
@@ -71,7 +71,7 @@ The response should be similar to the following example:
 }
 ```
 
-To consume an API with multiple responses, your contract must import [ChainlinkClient](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/ChainlinkClient.sol). This contract exposes a struct called `Chainlink.Request`, which your contract should use to build the API request. The request should include the following parameters:
+To consume an API with multiple responses, your contract must import [ChainlinkClient](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/ChainlinkClient.sol). This contract exposes a struct called `Chainlink.Request`, which your contract should use to build the API request. The request should include the following parameters:
 
 - Link token address
 - Oracle address
diff --git a/src/content/any-api/testnet-oracles.mdx b/src/content/any-api/testnet-oracles.mdx
index 9e758a16a41..c2b9e62ed68 100644
--- a/src/content/any-api/testnet-oracles.mdx
+++ b/src/content/any-api/testnet-oracles.mdx
@@ -21,7 +21,7 @@ To retrieve the LINK token address or get faucet details for your testnet of cho
 
 ## Operator Contracts
 
-Testnet [Operator contracts](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/Operator.sol) are deployed and maintained on the following networks:
+Testnet [Operator contracts](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/Operator.sol) are deployed and maintained on the following networks:
 
 | Testnet          | Oracle Address                                                                                                                  |
 | ---------------- | ------------------------------------------------------------------------------------------------------------------------------- |
diff --git a/src/content/architecture-overview/architecture-decentralized-model.mdx b/src/content/architecture-overview/architecture-decentralized-model.mdx
index 21cabcfb643..8b74e69e3a4 100644
--- a/src/content/architecture-overview/architecture-decentralized-model.mdx
+++ b/src/content/architecture-overview/architecture-decentralized-model.mdx
@@ -47,7 +47,7 @@ To learn how to create a consumer contract that uses an existing data feed, read
 
 ### Consumer
 
-A Consumer contract is any contract that uses Chainlink Data Feeds to consume aggregated data. Consumer contracts must reference the correct [`AggregatorV3Interface`](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol) contract and call one of the exposed functions.
+A Consumer contract is any contract that uses Chainlink Data Feeds to consume aggregated data. Consumer contracts must reference the correct [`AggregatorV3Interface`](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol) contract and call one of the exposed functions.
 
 {/* prettier-ignore */}
 ```solidity
@@ -62,13 +62,13 @@ Offchain applications can also consume data feeds. See the Javascript and Python
 
 Proxy contracts are onchain proxies that point to the aggregator for a particular data feed. Using proxies enables the underlying aggregator to be upgraded without any service interruption to consuming contracts.
 
-Proxy contracts can vary from one data feed to another, but the [`AggregatorProxy.sol` contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.7/dev/AggregatorProxy.sol) on Github is a common example.
+Proxy contracts can vary from one data feed to another, but the [`EACAggregatorProxy.sol` contract](https://github.com/smartcontractkit/chainlink/blob/contracts-v1.0.0/contracts/src/v0.6/EACAggregatorProxy.sol) on Github is a common example.
 
 ### Aggregator
 
 An aggregator is the contract that receives periodic data updates from the oracle network. Aggregators store aggregated data onchain so that consumers can retrieve it and act upon it within the same transaction.
 
-You can access this data using the Data Feed address and the [`AggregatorV3Interface` contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol).
+You can access this data using the Data Feed address and the [`AggregatorV3Interface` contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol).
 
 Aggregators receive updates from the oracle network only when the **Deviation Threshold** or **Heartbeat Threshold** triggers an update during an aggregation round. The first condition that is met triggers an update to the data.
 
diff --git a/src/content/architecture-overview/architecture-request-model.mdx b/src/content/architecture-overview/architecture-request-model.mdx
index 8e6157614e8..56cefade3b8 100644
--- a/src/content/architecture-overview/architecture-request-model.mdx
+++ b/src/content/architecture-overview/architecture-request-model.mdx
@@ -22,7 +22,7 @@ All source code is open source and available in the [Chainlink Github repository
 
 ### ChainlinkClient
 
-[`ChainlinkClient`](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/ChainlinkClient.sol) is a parent contract that enables smart contracts to consume data from oracles. It's available in the Chainlink smart contract library which can be [installed using the latest package managers](/resources/create-a-chainlinked-project).
+[`ChainlinkClient`](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/ChainlinkClient.sol) is a parent contract that enables smart contracts to consume data from oracles. It's available in the Chainlink smart contract library which can be [installed using the latest package managers](/resources/create-a-chainlinked-project).
 
 The client constructs and makes a request to a known Chainlink oracle through the `transferAndCall` function, implemented by the LINK token. This request contains encoded information that is required for the cycle to succeed. In the `ChainlinkClient` contract, this call is initiated with a call to `sendChainlinkRequestTo`.
 
@@ -36,7 +36,7 @@ Learn more about [ERC-677 and the LINK token](/resources/link-token-contracts).
 
 ### Operator Contract
 
-[`Operator` contracts](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/Operator.sol) are owned by oracle node operators, which run alongside offchain oracle nodes.
+[`Operator` contracts](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/Operator.sol) are owned by oracle node operators, which run alongside offchain oracle nodes.
 
 #### Request
 
@@ -48,7 +48,7 @@ The client contract that initiates this cycle must create a request with the fol
 
 To learn about how to find oracles to suit your needs, see [Find Existing Jobs](/any-api/find-oracle).
 
-Operator contracts are responsible for handling onchain requests made through the LINK token, by implementing `onTokenTransfer` as a <a href="https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/LinkTokenReceiver.sol">`LinkTokenReceiver`</a>. Upon execution of this function, the operator contract **emits an `OracleRequest` event** containing information about the request. This event is crucial, as it is monitored by the offchain oracle node which acts upon it.
+Operator contracts are responsible for handling onchain requests made through the LINK token, by implementing `onTokenTransfer` as a <a href="https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/LinkTokenReceiver.sol">`LinkTokenReceiver`</a>. Upon execution of this function, the operator contract **emits an `OracleRequest` event** containing information about the request. This event is crucial, as it is monitored by the offchain oracle node which acts upon it.
 
 #### Fulfillment
 
diff --git a/src/content/chainlink-automation/guides/log-trigger.mdx b/src/content/chainlink-automation/guides/log-trigger.mdx
index 7b054894781..1348fd6e12a 100644
--- a/src/content/chainlink-automation/guides/log-trigger.mdx
+++ b/src/content/chainlink-automation/guides/log-trigger.mdx
@@ -78,7 +78,7 @@ Select **Log Trigger**.
   Your upkeeps will be protected against logs that are emitted during a reorg.
 </Aside>
 
-1. **Provide the address of your [Automation-compatible contract](/chainlink-automation/guides/compatible-contracts)** that you want to automate. In this case, we will paste the address of `CountWithLog.sol`. This contract must follow the format of the [ILogAutomation interface](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/automation/interfaces/ILogAutomation.sol) to ensure Automation nodes can interact with your contract as expected.
+1. **Provide the address of your [Automation-compatible contract](/chainlink-automation/guides/compatible-contracts)** that you want to automate. In this case, we will paste the address of `CountWithLog.sol`. This contract must follow the format of the [ILogAutomation interface](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/automation/interfaces/ILogAutomation.sol) to ensure Automation nodes can interact with your contract as expected.
 
    <ClickToZoom src="/images/automation/log_trig_1_upkeep_address.png" />
 
diff --git a/src/content/chainlink-automation/reference/automation-contracts.mdx b/src/content/chainlink-automation/reference/automation-contracts.mdx
index d2d026e77c8..4ff83c52360 100644
--- a/src/content/chainlink-automation/reference/automation-contracts.mdx
+++ b/src/content/chainlink-automation/reference/automation-contracts.mdx
@@ -9,25 +9,25 @@ whatsnext: { "Automation Architecture": "/chainlink-automation/concepts/automati
 
 Automation Nodes use the following contracts. You can find them in the [Chainlink repository](https://github.com/smartcontractkit/chainlink/tree/develop/contracts/src/v0.8/automation). For details about how to use them, visit the [Creating Compatible Contracts](/chainlink-automation/guides/compatible-contracts) guide. To understand the logic behind these contracts, visit the [Architecture](/chainlink-automation/concepts/automation-architecture) page.
 
-- [`AutomationCompatible.sol`](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/automation/AutomationCompatible.sol): Imports the following contracts:
-  - [`AutomationBase.sol`](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/automation/AutomationBase.sol): Enables the use of the `cannotExecute` modifier. Import this contract if you need for this modifier. See the [`checkUpkeep` function](/chainlink-automation/reference/automation-interfaces#checkupkeep-function) for details.
-  - [`AutomationCompatibleInterface.sol`](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/automation/interfaces/AutomationCompatibleInterface.sol): The interface to be implemented in order to make your contract compatible. Import this contract for type safety.
+- [`AutomationCompatible.sol`](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/automation/AutomationCompatible.sol): Imports the following contracts:
+  - [`AutomationBase.sol`](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/automation/AutomationBase.sol): Enables the use of the `cannotExecute` modifier. Import this contract if you need for this modifier. See the [`checkUpkeep` function](/chainlink-automation/reference/automation-interfaces#checkupkeep-function) for details.
+  - [`AutomationCompatibleInterface.sol`](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/automation/interfaces/AutomationCompatibleInterface.sol): The interface to be implemented in order to make your contract compatible. Import this contract for type safety.
 
 ## AutomationRegistry.sol
 
-[`AutomationRegistry2_1.sol`](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/automation/v2_1/KeeperRegistry2_1.sol): The registry contract that tracks all registered Upkeeps and the Automation Nodes that can perform them. _Note_: As Chainlink Automation continues adding new functionalities, a new **Automation Registry** is deployed and the contract address may change.
+[`AutomationRegistry2_1.sol`](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/automation/v2_1/KeeperRegistry2_1.sol): The registry contract that tracks all registered Upkeeps and the Automation Nodes that can perform them. _Note_: As Chainlink Automation continues adding new functionalities, a new **Automation Registry** is deployed and the contract address may change.
 
 ## AutomationRegistrar.sol
 
-[`AutomationRegistrar2_1.sol`](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/automation/v2_1/AutomationRegistrar2_1.sol): The Registrar contract governs the registration of new Upkeeps on the associated `AutomationRegistry` contract. Users who want to register Upkeeps by directly calling the deployed contract have to call the Transfer-and-Call function on the respective ERC-677 LINK contract configured on the Registrar and ensure they pass the correct encoded function call and inputs.
+[`AutomationRegistrar2_1.sol`](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/automation/v2_1/AutomationRegistrar2_1.sol): The Registrar contract governs the registration of new Upkeeps on the associated `AutomationRegistry` contract. Users who want to register Upkeeps by directly calling the deployed contract have to call the Transfer-and-Call function on the respective ERC-677 LINK contract configured on the Registrar and ensure they pass the correct encoded function call and inputs.
 
 ## UpkeepTranscoder.sol
 
-[`UpkeepTranscode4_0.sol`](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/automation/v2_1/UpkeepTranscoder4_0.sol) allows the conversion of upkeep data from previous Automation registry versions 1.2, 1.3, and 2.0 to registry 2.1.
+[`UpkeepTranscode4_0.sol`](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/automation/v2_1/UpkeepTranscoder4_0.sol) allows the conversion of upkeep data from previous Automation registry versions 1.2, 1.3, and 2.0 to registry 2.1.
 
 ## AutomationForwarder.sol
 
-[`AutomationForwarder.sol`](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/automation/v2_1/AutomationForwarder.sol) is a relayer that sits between the registry and the customer's target contract. The purpose of the forwarder is to give customers a consistent address to authorize against that stays consistent between migrations. The Forwarder also exposes the registry address, so that users who want to programatically interact with the registry can do so. The `forward` function in this contract is called by the registry and forwards the call to the target.
+[`AutomationForwarder.sol`](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/automation/AutomationForwarder.sol) is a relayer that sits between the registry and the customer's target contract. The purpose of the forwarder is to give customers a consistent address to authorize against that stays consistent between migrations. The Forwarder also exposes the registry address, so that users who want to programmatically interact with the registry can do so. The `forward` function in this contract is called by the registry and forwards the call to the target.
 
 ## CronUpkeepFactory.sol
 
diff --git a/src/content/chainlink-automation/reference/automation-interfaces.mdx b/src/content/chainlink-automation/reference/automation-interfaces.mdx
index 79c0ed65a65..0d2657dcea0 100644
--- a/src/content/chainlink-automation/reference/automation-interfaces.mdx
+++ b/src/content/chainlink-automation/reference/automation-interfaces.mdx
@@ -26,7 +26,7 @@ Your Automation-compatible contracts may use the following interfaces. You can f
 
 ## AutomationCompatibleInterface
 
-Custom logic upkeeps need to use the [`AutomationCompatibleInterface.sol`](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/automation/interfaces/AutomationCompatibleInterface.sol) interface. Click on one of the functions below to understand its parameters and limits.
+Custom logic upkeeps need to use the [`AutomationCompatibleInterface.sol`](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/automation/interfaces/AutomationCompatibleInterface.sol) interface. Click on one of the functions below to understand its parameters and limits.
 
 | Function Name   | Description                                                                          |
 | --------------- | ------------------------------------------------------------------------------------ |
@@ -35,7 +35,7 @@ Custom logic upkeeps need to use the [`AutomationCompatibleInterface.sol`](https
 
 ### checkUpkeep function
 
-This view function contains the logic that runs offchain during every block as an [`eth_call`](https://eth.wiki/json-rpc/API#eth_call) to determine if `performUpkeep` should be executed onchain. To reduce onchain gas usage, attempt to do your gas intensive calculations offchain in `checkUpkeep` and pass the result to `performUpkeep` onchain. It is a best practice to import the [`AutomationCompatible.sol`](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/automation/AutomationCompatible.sol) contract and use the `cannotExecute` modifier to ensure that the method can be used only for simulation purposes.
+This view function contains the logic that runs offchain during every block as an [`eth_call`](https://eth.wiki/json-rpc/API#eth_call) to determine if `performUpkeep` should be executed onchain. To reduce onchain gas usage, attempt to do your gas intensive calculations offchain in `checkUpkeep` and pass the result to `performUpkeep` onchain. It is a best practice to import the [`AutomationCompatible.sol`](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/automation/AutomationCompatible.sol) contract and use the `cannotExecute` modifier to ensure that the method can be used only for simulation purposes.
 
 ```solidity
 function checkUpkeep(
diff --git a/src/content/chainlink-functions/api-reference/functions-client.mdx b/src/content/chainlink-functions/api-reference/functions-client.mdx
index 42f7d451016..48b68cac957 100644
--- a/src/content/chainlink-functions/api-reference/functions-client.mdx
+++ b/src/content/chainlink-functions/api-reference/functions-client.mdx
@@ -17,7 +17,7 @@ Functions contracts are available starting from version _0.7.1_.
 
 </Aside>
 
-Consumer contract developers inherit [FunctionsClient](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/functions/v1_0_0/FunctionsClient.sol) to create Chainlink Functions requests.
+Consumer contract developers inherit [FunctionsClient](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/functions/v1_0_0/FunctionsClient.sol) to create Chainlink Functions requests.
 
 ## Events
 
diff --git a/src/content/chainlink-functions/api-reference/functions-request.mdx b/src/content/chainlink-functions/api-reference/functions-request.mdx
index 5c960bc01fe..c5adc8b513f 100644
--- a/src/content/chainlink-functions/api-reference/functions-request.mdx
+++ b/src/content/chainlink-functions/api-reference/functions-request.mdx
@@ -17,7 +17,7 @@ Functions contracts are available starting from version _0.7.1_.
 
 </Aside>
 
-Consumer contract developers use the [FunctionsRequest library](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/functions/v1_0_0/libraries/FunctionsRequest.sol) to build their [requests](#request).
+Consumer contract developers use the [FunctionsRequest library](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/functions/v1_0_0/libraries/FunctionsRequest.sol) to build their [requests](#request).
 
 ## Types and Constants
 
diff --git a/src/content/chainlink-functions/getting-started.mdx b/src/content/chainlink-functions/getting-started.mdx
index 7a33adae5aa..bd58f3fd431 100644
--- a/src/content/chainlink-functions/getting-started.mdx
+++ b/src/content/chainlink-functions/getting-started.mdx
@@ -228,7 +228,7 @@ Chainlink Functions is capable of much more than just retrieving data. Try one o
 
 <CodeSample src="samples/ChainlinkFunctions/GettingStartedFunctionsConsumer.sol" />
 
-- To write a Chainlink Functions consumer contract, your contract must import [FunctionsClient.sol](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/functions/v1_0_0/FunctionsClient.sol) and [FunctionsRequest.sol](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/functions/v1_0_0/libraries/FunctionsRequest.sol). You can read the API references: [FunctionsClient](/chainlink-functions/api-reference/functions-client) and [FunctionsRequest](/chainlink-functions/api-reference/functions-request).
+- To write a Chainlink Functions consumer contract, your contract must import [FunctionsClient.sol](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/functions/v1_0_0/FunctionsClient.sol) and [FunctionsRequest.sol](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/functions/v1_0_0/libraries/FunctionsRequest.sol). You can read the API references: [FunctionsClient](/chainlink-functions/api-reference/functions-client) and [FunctionsRequest](/chainlink-functions/api-reference/functions-request).
 
   These contracts are available in an NPM package so that you can import them from within your project.
 
diff --git a/src/content/chainlink-functions/resources/architecture.mdx b/src/content/chainlink-functions/resources/architecture.mdx
index 3819a1bbd4c..d4f0057545d 100644
--- a/src/content/chainlink-functions/resources/architecture.mdx
+++ b/src/content/chainlink-functions/resources/architecture.mdx
@@ -14,7 +14,7 @@ import { Aside, ClickToZoom } from "@components"
 
 ## Request and Receive Data
 
-This model is similar to the [Basic Request Model](/architecture-overview/architecture-request-model): The consumer contract initiates the cycle by sending a request to the [FunctionsRouter contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/functions/v1_0_0/FunctionsRouter.sol). Oracle nodes watch for events emitted by the [FunctionsCoordinator contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/functions/v1_1_0/FunctionsCoordinator.sol) and run the computation offchain. Finally, oracle nodes use the [Chainlink OCR](/architecture-overview/off-chain-reporting) protocol to aggregate all the returned before passing the single aggregated response back to the consumer contract via a callback function.
+This model is similar to the [Basic Request Model](/architecture-overview/architecture-request-model): The consumer contract initiates the cycle by sending a request to the [FunctionsRouter contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/functions/v1_0_0/FunctionsRouter.sol). Oracle nodes watch for events emitted by the [FunctionsCoordinator contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/functions/v1_1_0/FunctionsCoordinator.sol) and run the computation offchain. Finally, oracle nodes use the [Chainlink OCR](/architecture-overview/off-chain-reporting) protocol to aggregate all the returned before passing the single aggregated response back to the consumer contract via a callback function.
 
 <ClickToZoom
   src="/images/chainlink-functions/requestAndReceive.png"
@@ -35,7 +35,7 @@ Let's walk through the sequence of interactions among these components, as illus
 
 1. If there are secrets, a user encrypts secrets with the public key linked to the DON master secret key (MSK) and then uploads the encrypted secrets to the secrets endpoint. The secrets endpoint pushes the encrypted secrets to the nodes part of the DON (The secrets capability depicted in this diagram is called _threshold encryption_ and is explained in [secrets management](/chainlink-functions/resources/secrets#threshold-encryption)).
 1. An [EOA (Externally Owned Account)](https://ethereum.org/en/developers/docs/accounts/#types-of-account) or Chainlink Automation initiates the request by calling the consumer contract.
-1. The consumer contract should inherit the [FunctionsClient](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/functions/v1_0_0/FunctionsClient.sol) contract. This ensures it will be able to receive responses from the [FunctionsRouter](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/functions/v1_0_0/FunctionsRouter.sol) contract via the `handleOracleFulfillment` callback. The router contract starts the billing to estimate the fulfillment costs and block the amount in the _reservation balance_ (To learn more, read [Cost simulation](/chainlink-functions/resources/billing#cost-simulation-reservation)). Then it calls the [FunctionsCoordinator contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/functions/v1_1_0/FunctionsCoordinator.sol).
+1. The consumer contract should inherit the [FunctionsClient](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/functions/v1_0_0/FunctionsClient.sol) contract. This ensures it will be able to receive responses from the [FunctionsRouter](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/functions/v1_0_0/FunctionsRouter.sol) contract via the `handleOracleFulfillment` callback. The router contract starts the billing to estimate the fulfillment costs and block the amount in the _reservation balance_ (To learn more, read [Cost simulation](/chainlink-functions/resources/billing#cost-simulation-reservation)). Then it calls the [FunctionsCoordinator contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/functions/v1_1_0/FunctionsCoordinator.sol).
 1. The coordinator contract emits an `OracleRequest` event containing information about the request.
 1. On reception of the event by the DON, the DON's nodes decrypt the secrets using threshold decryption (The threshold encryption feature is explained in [secrets management](/chainlink-functions/resources/secrets#threshold-encryption)). Each DON's Oracle node executes the request's source code in a serverless environment.
 1. The DON runs the Offchain Reporting protocol (OCR) to aggregate the values returned by each node's execution of the source code.
@@ -51,7 +51,7 @@ Chainlink Functions do not require your consumer contracts to hold LINK tokens a
 
 ### Concepts
 
-- Terms of service (ToS): Before interacting with Chainlink Functions, users must agree to the terms of service. Once signed, the accounts that can manage subscriptions are added to the `allowedSenders` in the [ToS allow list contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/functions/v1_0_0/accessControl/TermsOfServiceAllowList.sol).
+- Terms of service (ToS): Before interacting with Chainlink Functions, users must agree to the terms of service. Once signed, the accounts that can manage subscriptions are added to the `allowedSenders` in the [ToS allow list contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/functions/v1_0_0/accessControl/TermsOfServiceAllowList.sol).
 - Chainlink Functions Subscription Manager: A user interface that allows users to agree to the sign Terms of service and interact with the FunctionsRouter to manage subscriptions.
 - Subscription account: An account that holds LINK tokens and makes them available to fund requests to Chainlink DON. A _Subscription ID_ uniquely identifies each account.
 - Subscription ID: 64-bit unsigned integer representing the unique identifier of the _Subscription account_.
@@ -63,17 +63,17 @@ Chainlink Functions do not require your consumer contracts to hold LINK tokens a
 
 ### Accept ToS
 
-To ensure compliance and governance, Chainlink Functions mandates that any account that manages a subscription must first accept the platform's Terms of Service (ToS). The acceptance is verified by cross-referencing the account with the `allowedSenders` registry contained within the [TermsOfServiceAllowList contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/functions/v1_0_0/accessControl/TermsOfServiceAllowList.sol).
+To ensure compliance and governance, Chainlink Functions mandates that any account that manages a subscription must first accept the platform's Terms of Service (ToS). The acceptance is verified by cross-referencing the account with the `allowedSenders` registry contained within the [TermsOfServiceAllowList contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/functions/v1_0_0/accessControl/TermsOfServiceAllowList.sol).
 
 <ClickToZoom src="/images/chainlink-functions/subscription/acceptToSEOA.png" />
 
-The acceptance process is initiated via the Chainlink Functions Subscription Manager. After a user accepts the ToS by generating the required signature with their externally owned account (EOA), they transmit proof of acceptance to the [TermsOfServiceAllowList contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/functions/v1_0_0/accessControl/TermsOfServiceAllowList.sol). Upon successful validation of the proof, the EOA is added to the `allowedSenders` registry, permitting it to manage subscriptions.
+The acceptance process is initiated via the Chainlink Functions Subscription Manager. After a user accepts the ToS by generating the required signature with their externally owned account (EOA), they transmit proof of acceptance to the [TermsOfServiceAllowList contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/functions/v1_0_0/accessControl/TermsOfServiceAllowList.sol). Upon successful validation of the proof, the EOA is added to the `allowedSenders` registry, permitting it to manage subscriptions.
 
 ### Create subscription
 
 <ClickToZoom src="/images/chainlink-functions/subscription/createSubscription.png" />
 
-After the ToS is accepted, EOAs can create subscriptions. Upon creation, the [FunctionsRouter](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/functions/v1_0_0/FunctionsRouter.sol) assigns a unique identifier, _Subscription ID_.
+After the ToS is accepted, EOAs can create subscriptions. Upon creation, the [FunctionsRouter](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/functions/v1_0_0/FunctionsRouter.sol) assigns a unique identifier, _Subscription ID_.
 
 **Note**: EOAs can directly interact with the FunctionsRouter contract using their preferred web3 library, such as web3.js or ethers.js.
 
@@ -136,7 +136,7 @@ To cancel a subscription:
 Transferring ownership is currently only supported using the [Functions Hardhat Starter kit](https://github.com/smartcontractkit/functions-hardhat-starter-kit) or the [Functions Toolkit NPM package](https://github.com/smartcontractkit/functions-toolkit):
 
 1. Use the `functions-sub-transfer` command to initiate the transfer of ownership by specifying the new owner's address.
-1. As a prerequisite, the prospective owner must be part of the `allowedSenders` registry within the [TermsOfServiceAllowList contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/functions/v1_0_0/accessControl/TermsOfServiceAllowList.sol). This verifies their acceptance of the Chainlink Functions' Terms of Service (ToS).
+1. As a prerequisite, the prospective owner must be part of the `allowedSenders` registry within the [TermsOfServiceAllowList contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/functions/v1_0_0/accessControl/TermsOfServiceAllowList.sol). This verifies their acceptance of the Chainlink Functions' Terms of Service (ToS).
 1. The prospective owner should use the [Functions Hardhat Starter kit](https://github.com/smartcontractkit/functions-hardhat-starter-kit) and run the `functions-sub-accept` command to confirm the ownership transfer.
 
 **Note**: This guide will be updated as soon as the Chainlink Functions Subscription Manager supports ownership transfers.
diff --git a/src/content/chainlink-nodes/contracts/forwarder.mdx b/src/content/chainlink-nodes/contracts/forwarder.mdx
index e6479e7b8bb..85d1955b3d3 100644
--- a/src/content/chainlink-nodes/contracts/forwarder.mdx
+++ b/src/content/chainlink-nodes/contracts/forwarder.mdx
@@ -14,7 +14,7 @@ In the EVM world, [externally-owned account](https://ethereum.org/en/developers/
 To solve these challenges, we introduced two major features that will allow node operators to set up different transaction-sending strategies more securely while lowering their infrastructure costs:
 
 - Chainlink nodes support multiple EOAs.
-- [Forwarder](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/AuthorizedForwarder.sol) contracts allow a node operator to manage multiple EOAs and make them look like a single address. If you use a web2 analogy, forwarder contracts act like a reverse proxy server where the user is served by the same address and does not see which server the traffic is coming from. To do so, nodes call the [forward](#forward) function on the forwarder contract.
+- [Forwarder](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/AuthorizedForwarder.sol) contracts allow a node operator to manage multiple EOAs and make them look like a single address. If you use a web2 analogy, forwarder contracts act like a reverse proxy server where the user is served by the same address and does not see which server the traffic is coming from. To do so, nodes call the [forward](#forward) function on the forwarder contract.
 
 Combining multiple EOAs and forwarder contracts allows greater flexibility and security in terms of design:
 
@@ -25,7 +25,7 @@ Combining multiple EOAs and forwarder contracts allows greater flexibility and s
 
 ## API Reference
 
-The forwarder contract inherits [AuthorizedReceiver.sol](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/AuthorizedReceiver.sol) and [ConfirmedOwnerWithProposal.sol](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/shared/access/ConfirmedOwnerWithProposal.sol). Read the [Receiver](/chainlink-nodes/contracts/receiver) and [Ownership](/chainlink-nodes/contracts/ownership) API references to learn more.
+The forwarder contract inherits [AuthorizedReceiver.sol](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/AuthorizedReceiver.sol) and [ConfirmedOwnerWithProposal.sol](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/shared/access/ConfirmedOwnerWithProposal.sol). Read the [Receiver](/chainlink-nodes/contracts/receiver) and [Ownership](/chainlink-nodes/contracts/ownership) API references to learn more.
 
 ### Methods
 
diff --git a/src/content/chainlink-nodes/contracts/operator.mdx b/src/content/chainlink-nodes/contracts/operator.mdx
index 2204d23095e..7bd00a4afd4 100644
--- a/src/content/chainlink-nodes/contracts/operator.mdx
+++ b/src/content/chainlink-nodes/contracts/operator.mdx
@@ -8,7 +8,7 @@ import { Aside } from "@components"
 
 Oracles must deploy an onchain contract to handle requests made through the LINK token (Read [Basic Request Model](/architecture-overview/architecture-request-model) to learn more).
 
-When the _Basic Request_ model was introduced, node operators had to deploy the legacy [Oracle contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.4/Oracle.sol). However, these come with some limitations, and soon, we introduced [operator contracts](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/Operator.sol).
+When the _Basic Request_ model was introduced, node operators had to deploy the legacy [Oracle contract](https://github.com/smartcontractkit/chainlink/blob/contracts-v1.0.0/contracts/src/v0.4/Oracle.sol). However, these come with some limitations, and soon, we introduced [operator contracts](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/Operator.sol).
 
 <Aside type="note">
   <p>Node operators must use _Operator.sol_ instead of _Oracle.sol_.</p>
@@ -20,13 +20,13 @@ In addition to replacing oracle contracts, operator contracts come with addition
 
 ### Multi-word response
 
-In the EVM architecture, a word is made up of 32 bytes. One limitation of the [Oracle.sol](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.4/Oracle.sol) contract is that it limits responses to requests to 32 bytes.
+In the EVM architecture, a word is made up of 32 bytes. One limitation of the [Oracle.sol](https://github.com/smartcontractkit/chainlink/blob/contracts-v1.0.0/contracts/src/v0.4/Oracle.sol) contract is that it limits responses to requests to 32 bytes.
 
-[Operator.sol](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/Operator.sol) doesn't have the same limitation as it supports a response made of multiple EVM words.
+[Operator.sol](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/Operator.sol) doesn't have the same limitation as it supports a response made of multiple EVM words.
 
 ### Factory deployment
 
-To deploy an _Oracle_ contract, each node operator has to manually compile and deploy [Oracle.sol](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.4/Oracle.sol).
+To deploy an _Oracle_ contract, each node operator has to manually compile and deploy [Oracle.sol](https://github.com/smartcontractkit/chainlink/blob/contracts-v1.0.0/contracts/src/v0.4/Oracle.sol).
 The vast number of Solidity versions and steps involved in verifying the contract made it difficult for a client to verify that the deployed contract had not been tampered with.
 To fix this, node operators can use a [factory](/chainlink-nodes/contracts/operatorfactory) to deploy an instance of the _operator_ contract. Moreover, the factory exposes a getter for clients to check if it deployed a specific _operator_ contract address.
 
@@ -50,7 +50,7 @@ As discussed in the [forwarder](/chainlink-nodes/contracts/forwarder) contracts
 
 ## API reference
 
-The operator contract inherits [AuthorizedReceiver](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/AuthorizedReceiver.sol) and [ConfirmedOwnerWithProposal](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/shared/access/ConfirmedOwnerWithProposal.sol). Read [AuthorizedReceiver](/chainlink-nodes/contracts/receiver) and [ConfirmedOwnerWithProposal](/chainlink-nodes/contracts/ownership) API references.
+The operator contract inherits [AuthorizedReceiver](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/AuthorizedReceiver.sol) and [ConfirmedOwnerWithProposal](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/shared/access/ConfirmedOwnerWithProposal.sol). Read [AuthorizedReceiver](/chainlink-nodes/contracts/receiver) and [ConfirmedOwnerWithProposal](/chainlink-nodes/contracts/ownership) API references.
 
 ### Methods
 
@@ -64,7 +64,7 @@ The operator contract inherits [AuthorizedReceiver](https://github.com/smartcont
 function oracleRequest(address sender, uint256 payment, bytes32 specId, address callbackAddress, bytes4 callbackFunctionId, uint256 nonce, uint256 dataVersion, bytes data) external
 ```
 
-Creates the Chainlink request. This is backwards compatible API with [Oracle.sol contracts](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.4/Oracle.sol), but the behavior changes because `callbackAddress` is assumed to be the same as the request sender.
+Creates the Chainlink request. This is backwards compatible API with [Oracle.sol contracts](https://github.com/smartcontractkit/chainlink/blob/contracts-v1.0.0/contracts/src/v0.4/Oracle.sol), but the behavior changes because `callbackAddress` is assumed to be the same as the request sender.
 
 ##### Parameters
 
diff --git a/src/content/chainlink-nodes/contracts/ownership.mdx b/src/content/chainlink-nodes/contracts/ownership.mdx
index a8c574a37af..41606f44062 100644
--- a/src/content/chainlink-nodes/contracts/ownership.mdx
+++ b/src/content/chainlink-nodes/contracts/ownership.mdx
@@ -4,7 +4,7 @@ date: Last Modified
 title: "Ownership"
 ---
 
-[ConfirmedOwnerWithProposal](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/shared/access/ConfirmedOwnerWithProposal.sol) is inherited by [operator](/chainlink-nodes/contracts/operator) and [forwarder](/chainlink-nodes/contracts/forwarder) contracts. It contains helpers for basic contract ownership.
+[ConfirmedOwnerWithProposal](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/shared/access/ConfirmedOwnerWithProposal.sol) is inherited by [operator](/chainlink-nodes/contracts/operator) and [forwarder](/chainlink-nodes/contracts/forwarder) contracts. It contains helpers for basic contract ownership.
 
 ## API reference
 
diff --git a/src/content/chainlink-nodes/contracts/receiver.mdx b/src/content/chainlink-nodes/contracts/receiver.mdx
index 2730d86ece7..6750557abb8 100644
--- a/src/content/chainlink-nodes/contracts/receiver.mdx
+++ b/src/content/chainlink-nodes/contracts/receiver.mdx
@@ -6,7 +6,7 @@ title: "Receiver"
 
 import { Aside } from "@components"
 
-[AuthorizedReceiver](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/AuthorizedReceiver.sol) is an abstract contract inherited by [operator](/chainlink-nodes/contracts/operator) and [forwarder](/chainlink-nodes/contracts/forwarder) contracts.
+[AuthorizedReceiver](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/AuthorizedReceiver.sol) is an abstract contract inherited by [operator](/chainlink-nodes/contracts/operator) and [forwarder](/chainlink-nodes/contracts/forwarder) contracts.
 
 <Aside type="note">
 Calling [setAuthorizedSenders](#setauthorizedsenders) has a different effect depending if it is called from an [operator](/chainlink-nodes/contracts/operator) or a [forwarder](/chainlink-nodes/contracts/forwarder) contract:
diff --git a/src/content/chainlink-nodes/job-specs/direct-request-existing-job.mdx b/src/content/chainlink-nodes/job-specs/direct-request-existing-job.mdx
index 1cf76954eca..cbc0ac3cb2f 100644
--- a/src/content/chainlink-nodes/job-specs/direct-request-existing-job.mdx
+++ b/src/content/chainlink-nodes/job-specs/direct-request-existing-job.mdx
@@ -7,7 +7,7 @@ title: "Existing Job Example specs"
 This is an example v2 (TOML) job spec for returning gas price using [etherscan](https://docs.etherscan.io/api-endpoints/gas-tracker#get-gas-oracle) in one Chainlink API Call. Note that the job :
 
 - Uses an [external adapter](/chainlink-nodes/external-adapters/external-adapters) to consume the etherscan API: [EtherScan External Adapter](https://github.com/smartcontractkit/external-adapters-js/tree/develop/packages/sources/etherscan). Note that this is done using the [bridge](/chainlink-nodes/oracle-jobs/all-tasks/#bridge-task) task: `type="bridge" name="etherscan"`.
-- Calls the `fulfillOracleRequest2` function. If you are a node operator, use an [Operator contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/Operator.sol) with this job.
+- Calls the `fulfillOracleRequest2` function. If you are a node operator, use an [Operator contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/Operator.sol) with this job.
 
 To test this job spec from a smart contract, see this [Example](/any-api/get-request/examples/existing-job-request).
 
diff --git a/src/content/chainlink-nodes/job-specs/direct-request-get-bool.mdx b/src/content/chainlink-nodes/job-specs/direct-request-get-bool.mdx
index db676f2d90e..8705d71f183 100644
--- a/src/content/chainlink-nodes/job-specs/direct-request-get-bool.mdx
+++ b/src/content/chainlink-nodes/job-specs/direct-request-get-bool.mdx
@@ -4,7 +4,7 @@ date: Last Modified
 title: "GET > Bool Example Job Spec"
 ---
 
-This is an example v2 (TOML) job spec for calling any public API, parsing the result then returning a _bool_ in one Chainlink API Call. Note that the job calls the `fulfillOracleRequest2` function. If you are a node operator, use an [Operator contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/Operator.sol) with this job.
+This is an example v2 (TOML) job spec for calling any public API, parsing the result then returning a _bool_ in one Chainlink API Call. Note that the job calls the `fulfillOracleRequest2` function. If you are a node operator, use an [Operator contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/Operator.sol) with this job.
 
 ```toml
 type = "directrequest"
diff --git a/src/content/chainlink-nodes/job-specs/direct-request-get-bytes.mdx b/src/content/chainlink-nodes/job-specs/direct-request-get-bytes.mdx
index f66fa86c5c9..dc94659ad56 100644
--- a/src/content/chainlink-nodes/job-specs/direct-request-get-bytes.mdx
+++ b/src/content/chainlink-nodes/job-specs/direct-request-get-bytes.mdx
@@ -4,7 +4,7 @@ date: Last Modified
 title: "GET > Bytes Example Job Spec"
 ---
 
-This is an example v2 (TOML) job spec for returning _bytes_ in one Chainlink API Call. Note that the job calls the `fulfillOracleRequest2` function. If you are a node operator, use an [Operator contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/Operator.sol) with this job.
+This is an example v2 (TOML) job spec for returning _bytes_ in one Chainlink API Call. Note that the job calls the `fulfillOracleRequest2` function. If you are a node operator, use an [Operator contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/Operator.sol) with this job.
 To test it from a smart contract, see this [Example](/any-api/get-request/examples/large-responses).
 
 ```toml
diff --git a/src/content/chainlink-nodes/job-specs/direct-request-get-int256.mdx b/src/content/chainlink-nodes/job-specs/direct-request-get-int256.mdx
index 5d8c9f257d7..d918931ad85 100644
--- a/src/content/chainlink-nodes/job-specs/direct-request-get-int256.mdx
+++ b/src/content/chainlink-nodes/job-specs/direct-request-get-int256.mdx
@@ -4,7 +4,7 @@ date: Last Modified
 title: "GET > Int256 Example Job Spec"
 ---
 
-This is an example v2 (TOML) job spec for calling any public API, retrieving a number , removing its decimals then returning _int256_ in one Chainlink API Call. Note that the job calls the `fulfillOracleRequest2` function. If you are a node operator, use an [Operator contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/Operator.sol) with this job.
+This is an example v2 (TOML) job spec for calling any public API, retrieving a number , removing its decimals then returning _int256_ in one Chainlink API Call. Note that the job calls the `fulfillOracleRequest2` function. If you are a node operator, use an [Operator contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/Operator.sol) with this job.
 
 ```toml
 type = "directrequest"
diff --git a/src/content/chainlink-nodes/job-specs/direct-request-get-string.mdx b/src/content/chainlink-nodes/job-specs/direct-request-get-string.mdx
index 6cd2b32aa2b..f38d9071b90 100644
--- a/src/content/chainlink-nodes/job-specs/direct-request-get-string.mdx
+++ b/src/content/chainlink-nodes/job-specs/direct-request-get-string.mdx
@@ -6,7 +6,7 @@ title: "GET > String Example Job Spec"
 
 import { CodeSample } from "@components"
 
-This is an example v2 (TOML) job spec for returning a _string_ in one Chainlink API Call. Note that the job calls the `fulfillOracleRequest2` function. If you are a node operator, use an [Operator contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/Operator.sol) with this job.
+This is an example v2 (TOML) job spec for returning a _string_ in one Chainlink API Call. Note that the job calls the `fulfillOracleRequest2` function. If you are a node operator, use an [Operator contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/Operator.sol) with this job.
 To test it from a smart contract, see this [Example](/any-api/get-request/examples/array-response).
 
 {/* prettier-ignore */}
diff --git a/src/content/chainlink-nodes/job-specs/direct-request-get-uint256.mdx b/src/content/chainlink-nodes/job-specs/direct-request-get-uint256.mdx
index 40cc056c8a4..03043385fac 100644
--- a/src/content/chainlink-nodes/job-specs/direct-request-get-uint256.mdx
+++ b/src/content/chainlink-nodes/job-specs/direct-request-get-uint256.mdx
@@ -4,7 +4,7 @@ date: Last Modified
 title: "GET > Uint256 Example Job Spec"
 ---
 
-This is an example v2 (TOML) job spec for calling any public API, retrieving a number , removing its decimals then returning _uint256_ in one Chainlink API Call. Note that the job calls the `fulfillOracleRequest2` function. If you are a node operator, use an [Operator contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/Operator.sol) with this job.
+This is an example v2 (TOML) job spec for calling any public API, retrieving a number , removing its decimals then returning _uint256_ in one Chainlink API Call. Note that the job calls the `fulfillOracleRequest2` function. If you are a node operator, use an [Operator contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/Operator.sol) with this job.
 To test it from a smart contract, see this [Example](/any-api/get-request/examples/single-word-response).
 
 ```toml
diff --git a/src/content/chainlink-nodes/job-specs/multi-word-job.mdx b/src/content/chainlink-nodes/job-specs/multi-word-job.mdx
index 87daf3a9f1c..0bf96101844 100644
--- a/src/content/chainlink-nodes/job-specs/multi-word-job.mdx
+++ b/src/content/chainlink-nodes/job-specs/multi-word-job.mdx
@@ -4,7 +4,7 @@ date: Last Modified
 title: "MultiWord Example Job Spec"
 ---
 
-This is an example v2 (TOML) job spec for returning multiple responses in 1 Chainlink API Call.Note that the job calls the `fulfillOracleRequest2` function. If you are a node operator, use an [Operator contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/operatorforwarder/dev/Operator.sol) with this job.
+This is an example v2 (TOML) job spec for returning multiple responses in 1 Chainlink API Call.Note that the job calls the `fulfillOracleRequest2` function. If you are a node operator, use an [Operator contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/operatorforwarder/Operator.sol) with this job.
 To test it from a smart contract, see this [Example](/any-api/get-request/examples/multi-variable-responses).
 
 ```toml
diff --git a/src/content/data-feeds/api-reference.mdx b/src/content/data-feeds/api-reference.mdx
index 4cab210aab8..fcdd7957074 100644
--- a/src/content/data-feeds/api-reference.mdx
+++ b/src/content/data-feeds/api-reference.mdx
@@ -29,7 +29,7 @@ constructor() {
 
 To see examples for how to use this interface, read the [Using Data Feeds](/data-feeds/price-feeds) guide.
 
-You can see the code for the [`AggregatorV3Interface` contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol) on GitHub.
+You can see the code for the [`AggregatorV3Interface` contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol) on GitHub.
 
 ### Functions in AggregatorV3Interface
 
diff --git a/src/content/data-feeds/feed-registry/index.mdx b/src/content/data-feeds/feed-registry/index.mdx
index a5538fb36a5..185cb7046f1 100644
--- a/src/content/data-feeds/feed-registry/index.mdx
+++ b/src/content/data-feeds/feed-registry/index.mdx
@@ -9,7 +9,7 @@ metadata:
 whatsnext:
   {
     "Read the Feed Registry API Reference": "/data-feeds/feed-registry/feed-registry-functions",
-    "See the FeedRegistryInterface contract on GitHub": "https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/interfaces/FeedRegistryInterface.sol",
+    "See the FeedRegistryInterface contract on GitHub": "https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/interfaces/FeedRegistryInterface.sol",
   }
 ---
 
@@ -31,7 +31,7 @@ For a complete list of functions and parameters for the `FeedRegistryInterface`
 
 ## Base and Quote
 
-The Feed Registry fully supports the [`AggregatorV3Interface`](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol) API for multiple feeds. It maps feeds from `base` and `quote` address pairs. To get the latest LINK / USD round data from the registry, call:
+The Feed Registry fully supports the [`AggregatorV3Interface`](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol) API for multiple feeds. It maps feeds from `base` and `quote` address pairs. To get the latest LINK / USD round data from the registry, call:
 
 {/* prettier-ignore */}
 ```solidity
@@ -60,7 +60,7 @@ latestRoundData(0x514910771AF9Ca656af840dff83E8264EcF986CA, 0xEeeeeEeeeEeEeeEeEe
 
 ### Denominations library
 
-A [`Denominations`](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/Denominations.sol) Solidity library is available for you to fetch currency identifiers which lack a canonical Ethereum address:
+A [`Denominations`](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/Denominations.sol) Solidity library is available for you to fetch currency identifiers which lack a canonical Ethereum address:
 
 <CodeSample src="samples/FeedRegistry/Denominations.sol" />
 
@@ -68,7 +68,7 @@ A [`Denominations`](https://github.com/smartcontractkit/chainlink/blob/master/co
 
 ### Solidity
 
-To consume price data from the Feed Registry, your smart contract should reference [`FeedRegistryInterface`](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/interfaces/FeedRegistryInterface.sol), which defines the external functions implemented by the Feed Registry.
+To consume price data from the Feed Registry, your smart contract should reference [`FeedRegistryInterface`](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/interfaces/FeedRegistryInterface.sol), which defines the external functions implemented by the Feed Registry.
 
 <CodeSample src="samples/FeedRegistry/PriceConsumer.sol" />
 
diff --git a/src/content/data-feeds/getting-started.mdx b/src/content/data-feeds/getting-started.mdx
index 8515bd46baf..3c4a121ebef 100644
--- a/src/content/data-feeds/getting-started.mdx
+++ b/src/content/data-feeds/getting-started.mdx
@@ -42,7 +42,7 @@ This example contract obtains the latest price answer from the [BTC / USD feed](
 
 The contract has the following components:
 
-- The `import` line imports an interface named `AggregatorV3Interface`. Interfaces define functions without their implementation, which leaves inheriting contracts to define the actual implementation themselves. In this case, `AggregatorV3Interface` defines that all v3 Aggregators have the function `latestRoundData`. You can [see the complete code](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol) for the `AggregatorV3Interface` on GitHub.
+- The `import` line imports an interface named `AggregatorV3Interface`. Interfaces define functions without their implementation, which leaves inheriting contracts to define the actual implementation themselves. In this case, `AggregatorV3Interface` defines that all v3 Aggregators have the function `latestRoundData`. You can [see the complete code](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol) for the `AggregatorV3Interface` on GitHub.
 
 - The `constructor() {}` initializes an interface object named `dataFeed` that uses `AggregatorV3Interface` and connects specifically to a proxy aggregator contract that is already deployed at `0x1b44F3514812d835EB1BDB0acB33d3fA3351Ee43`. The interface allows your contract to run functions on that deployed aggregator contract.
 
diff --git a/src/content/data-feeds/historical-data.mdx b/src/content/data-feeds/historical-data.mdx
index 77508d2944f..84daabc4b3b 100644
--- a/src/content/data-feeds/historical-data.mdx
+++ b/src/content/data-feeds/historical-data.mdx
@@ -13,7 +13,7 @@ import { HistoricalPrice } from "@features/feeds"
 import { Aside, ClickToZoom, CodeSample, Icon } from "@components"
 import button from "@chainlink/design-system/button.module.css"
 
-The most common use case for Data Feeds is to [Get the Latest Data](/data-feeds/using-data-feeds) from a feed. However, the [AggregatorV3Interface.sol](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol) also has functions to retrieve data of a previous round IDs.
+The most common use case for Data Feeds is to [Get the Latest Data](/data-feeds/using-data-feeds) from a feed. However, the [AggregatorV3Interface.sol](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol) also has functions to retrieve data of a previous round IDs.
 
 There are two parameters that can cause Chainlink nodes to update:
 
@@ -44,18 +44,19 @@ The examples in this document name the aggregator `roundId` as `aggregatorRoundI
 
 ### `roundId` in proxy
 
-Because a proxy has references to current and all previous underlying aggregators, it needs a way to fetch data from the correct aggregator. The `roundId` is computed in the [proxy contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.7/dev/AggregatorProxy.sol) as shown in the following example:
+Because a proxy has references to current and all previous underlying aggregators, it needs a way to fetch data from the correct aggregator. The `roundId` is computed in the [proxy contract](https://github.com/smartcontractkit/chainlink/blob/contracts-v1.0.0/contracts/src/v0.6/AggregatorProxy.sol) as shown in the following example:
 
 {/* prettier-ignore */}
 ```solidity
-roundId = uint80((uint256(phaseId) << 64) | aggregatorRoundId);
+return uint80(uint256(_phase) << PHASE_OFFSET | _originalId);
 ```
 
 where:
 
-- `phaseId` is incremented each time the underlying aggregator implementation is updated. It is used as a key to find the aggregator address.
-- `aggregatorRoundId` is the aggregator `roundId`. The id starts at 1.
-- `roundId` is the computed round id. From the above formula, you can think of it as a large number containing the `phaseId` and the `aggregatorRoundId`.
+- `_phase` is incremented each time the underlying aggregator implementation is updated. It is used as a key to find the aggregator address.
+- `_originalId` is the aggregator `roundId`. The ID starts at 1.
+
+From the above formula, you can think of it as returning a large number containing the `phase` and the aggregator `roundId`.
 
 <Aside type="note" title="Note">
   The example formula above ensures that no matter how many times the underlying aggregator changes, the proxy `roundId`
diff --git a/src/content/data-feeds/index.mdx b/src/content/data-feeds/index.mdx
index 9bcead3b125..ad465f4c17a 100644
--- a/src/content/data-feeds/index.mdx
+++ b/src/content/data-feeds/index.mdx
@@ -62,7 +62,7 @@ See the [Proof of Reserve Contract Addresses](/data-feeds/proof-of-reserve/addre
 
 ### NFT Floor Price Feeds
 
-NFT Floor Price Feeds provide the price of the lowest priced NFT available in a collection. These feeds operate similarly to [Price Feeds](/data-feeds/price-feeds) so you can use the [AggregatorV3Interface.sol](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol) contract to retrieve price answers.
+NFT Floor Price Feeds provide the price of the lowest priced NFT available in a collection. These feeds operate similarly to [Price Feeds](/data-feeds/price-feeds) so you can use the [AggregatorV3Interface.sol](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol) contract to retrieve price answers.
 
 To learn more, see the [NFT Floor Price Feeds](/data-feeds/nft-floor-price) documentation.
 
@@ -86,8 +86,8 @@ To learn how to use L2 sequencer uptime feeds feeds, see the [L2 Sequencer Uptim
 
 Data Feeds are an example of a decentralized oracle network and include the following components:
 
-- **Consumer**: A consumer is an onchain or offchain application that uses Data Feeds. Consumer contracts use the [`AggregatorV3Interface`](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol) to call functions on the proxy contract and retrieve information from the aggregator contract. For a complete list of functions available in the `AggregatorV3Interface`, see the [Data Feeds API Reference](/data-feeds/api-reference/#aggregatorv3interface).
-- **Proxy contract**: Proxy contracts are onchain proxies that point to the aggregator for a particular data feed. Using proxies enables the underlying aggregator to be upgraded without any service interruption to consuming contracts. Proxy contracts can vary from one data feed to another, but the [`AggregatorProxy.sol` contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.7/dev/AggregatorProxy.sol) on Github is a common example.
+- **Consumer**: A consumer is an onchain or offchain application that uses Data Feeds. Consumer contracts use the [`AggregatorV3Interface`](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol) to call functions on the proxy contract and retrieve information from the aggregator contract. For a complete list of functions available in the `AggregatorV3Interface`, see the [Data Feeds API Reference](/data-feeds/api-reference/#aggregatorv3interface).
+- **Proxy contract**: Proxy contracts are onchain proxies that point to the aggregator for a particular data feed. Using proxies enables the underlying aggregator to be upgraded without any service interruption to consuming contracts. Proxy contracts can vary from one data feed to another, but the [`EACAggregatorProxy.sol` contract](https://github.com/smartcontractkit/chainlink/blob/contracts-v1.0.0/contracts/src/v0.6/EACAggregatorProxy.sol) on Github is a common example.
 - **Aggregator contract**: An aggregator is a contract that receives periodic data updates from the oracle network. Aggregators store aggregated data onchain so that consumers can retrieve it and act upon it within the same transaction. For a complete list of functions and variables available on most aggregator contracts, see the [Data Feeds API Reference](/data-feeds/api-reference/#accesscontrolledoffchainaggregator).
 
 To learn how to create a consumer contract that uses an existing data feed, read the [Using Data Feeds](/data-feeds/price-feeds) documentation.
diff --git a/src/content/data-feeds/l2-sequencer-feeds.mdx b/src/content/data-feeds/l2-sequencer-feeds.mdx
index f634e09770f..fbdcb9e1f1c 100644
--- a/src/content/data-feeds/l2-sequencer-feeds.mdx
+++ b/src/content/data-feeds/l2-sequencer-feeds.mdx
@@ -34,10 +34,10 @@ The diagram below shows how these feeds update and how a consumer retrieves the
 
 <ClickToZoom src="/images/data-feed/l2-diagram-arbitrum.webp" />
 
-1. Chainlink nodes trigger an OCR round every 30s and update the sequencer status by calling the `validate` function in the [`ArbitrumValidator` contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/l2ep/dev/arbitrum/ArbitrumValidator.sol) by calling it through the [`ValidatorProxy` contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/ValidatorProxy.sol).
+1. Chainlink nodes trigger an OCR round every 30s and update the sequencer status by calling the `validate` function in the [`ArbitrumValidator` contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/l2ep/dev/arbitrum/ArbitrumValidator.sol) by calling it through the [`ValidatorProxy` contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/ValidatorProxy.sol).
 1. The `ArbitrumValidator` checks to see if the latest update is different from the previous update. If it detects a difference, it places a message in the [Arbitrum inbox contract](https://developer.offchainlabs.com/docs/inside_arbitrum#the-big-picture).
-1. The inbox contract sends the message to the [`ArbitrumSequencerUptimeFeed` contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/l2ep/dev/arbitrum/ArbitrumSequencerUptimeFeed.sol). The message calls the `updateStatus` function in the `ArbitrumSequencerUptimeFeed` contract and updates the latest sequencer status to 0 if the sequencer is up and 1 if it is down. It also records the block timestamp to indicate when the message was sent from the L1 network.
-1. A consumer contract on the L2 network can read these values from the [`ArbitrumUptimeFeedProxy` contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.6/EACAggregatorProxy.sol), which reads values from the `ArbitrumSequencerUptimeFeed` contract.
+1. The inbox contract sends the message to the [`ArbitrumSequencerUptimeFeed` contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/l2ep/dev/arbitrum/ArbitrumSequencerUptimeFeed.sol). The message calls the `updateStatus` function in the `ArbitrumSequencerUptimeFeed` contract and updates the latest sequencer status to 0 if the sequencer is up and 1 if it is down. It also records the block timestamp to indicate when the message was sent from the L1 network.
+1. A consumer contract on the L2 network can read these values from the [`ArbitrumUptimeFeedProxy` contract](https://github.com/smartcontractkit/chainlink/blob/contracts-v1.0.0/contracts/src/v0.6/EACAggregatorProxy.sol), which reads values from the `ArbitrumSequencerUptimeFeed` contract.
 
 ### Handling Arbitrum outages
 
diff --git a/src/content/data-feeds/nft-floor-price/index.mdx b/src/content/data-feeds/nft-floor-price/index.mdx
index 9372b4147ba..dd7c0d2cb18 100644
--- a/src/content/data-feeds/nft-floor-price/index.mdx
+++ b/src/content/data-feeds/nft-floor-price/index.mdx
@@ -22,6 +22,6 @@ Find the list of testnet feeds on the [Contract Addresses](/data-feeds/nft-floor
 
 Read answers from NFT Floor Price Feeds the same way that you read other Data Feeds. Specify the [NFT Floor Price Feed Address](/data-feeds/nft-floor-price/addresses) that you want to read instead of specifying a Price Feed address. See the [Using Data Feeds](/data-feeds/using-data-feeds) page to learn more.
 
-Using Solidity, your smart contract should reference [`AggregatorV3Interface`](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol), which defines the external functions implemented by Data Feeds.
+Using Solidity, your smart contract should reference [`AggregatorV3Interface`](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol), which defines the external functions implemented by Data Feeds.
 
 <CodeSample src="samples/DataFeeds/NFTFloorPriceConsumerV3.sol" />
diff --git a/src/content/data-feeds/proof-of-reserve/index.mdx b/src/content/data-feeds/proof-of-reserve/index.mdx
index fbfe567261e..f02d397787b 100644
--- a/src/content/data-feeds/proof-of-reserve/index.mdx
+++ b/src/content/data-feeds/proof-of-reserve/index.mdx
@@ -44,14 +44,14 @@ Cross-chain reserves are sourced from the network where the reserves are held. C
 
 Cross-chain reserves provide their data using the following methods:
 
-- Wallet address manager: The project uses the [IPoRAddressList](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/interfaces/PoRAddressList.sol) wallet address manager contract and self-reports which addresses they own. Reserve data reported by an asset issuer's self-reported addresses carries additional risks. Chainlink Labs is not responsible for the accuracy of self-reported reserves data. Users must do their own risk assessment for asset issuer risk.
+- Wallet address manager: The project uses the [IPoRAddressList](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/interfaces/PoRAddressList.sol) wallet address manager contract and self-reports which addresses they own. Reserve data reported by an asset issuer's self-reported addresses carries additional risks. Chainlink Labs is not responsible for the accuracy of self-reported reserves data. Users must do their own risk assessment for asset issuer risk.
 - Wallet address: The project reports which addresses they own through a self-hosted API. Reserve data reported by an asset issuer's self-reported addresses carries additional risks. Chainlink Labs is not responsible for the accuracy of self-reported reserves data. Users must do their own risk assessment for asset issuer risk.
 
 ## Using Proof of Reserve Feeds
 
 Read answers from Proof of Reserve Feeds the same way that you read other Data Feeds. Specify the [Proof of Reserve Feed Address](/data-feeds/proof-of-reserve/addresses) that you want to read instead of specifying a Price Feed address. See the [Using Data Feeds](/data-feeds/using-data-feeds) page to learn more.
 
-Using Solidity, your smart contract should reference [`AggregatorV3Interface`](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol), which defines the external functions implemented by Data Feeds.
+Using Solidity, your smart contract should reference [`AggregatorV3Interface`](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol), which defines the external functions implemented by Data Feeds.
 
 <CodeSample src="samples/DataFeeds/ReserveConsumerV3.sol" />
 
diff --git a/src/content/data-feeds/selecting-data-feeds.mdx b/src/content/data-feeds/selecting-data-feeds.mdx
index c555cebaade..08478d2d031 100644
--- a/src/content/data-feeds/selecting-data-feeds.mdx
+++ b/src/content/data-feeds/selecting-data-feeds.mdx
@@ -158,7 +158,6 @@ If your smart contracts use data feeds, assess those data feeds for the followin
 - [Market Failures Resulting from Extreme Events](#market-failures-resulting-from-extreme-events)
 - [Periods of High Network Congestion](#periods-of-high-network-congestion)
 - [Unknown and Known Users](#unknown-and-known-users)
-- [Fast Gas Reliability](#fast-gas-reliability)
 - [DEX volumes](#dex-volumes)
 
 ### Liquidity and its Distribution
@@ -229,10 +228,6 @@ Front running (when a third party benefits from prior access to information abou
 
 To mitigate the risk associated with front running, users building highly latency-dependent applications should assess whether the configuration of data feeds meets their needed specifications for speed and frequency. [Chainlink Data Streams](https://docs.chain.link/data-streams) serve as an alternative solution to Data Feeds for latency-sensitive applications, providing low-latency delivery of market data offchain that can be verified onchain while mitigating front running.
 
-### Fast Gas Reliability
-
-The [Fast Gas Data Feed](https://data.chain.link/ethereum/mainnet/gas/fast-gas-gwei) provides a simple way to determine the price of gas so you can estimate how much gas you need to make a transaction execute quickly. Fast gas prices can be manipulated, so you should design your applications to detect gas price volatility or malicious activity that might affect the costs of your transactions.
-
 ## Exchange Rate Feeds
 
 The architecture of exchange rate feeds differs from that of standard market rate Chainlink Price Feeds.
diff --git a/src/content/data-feeds/using-data-feeds.mdx b/src/content/data-feeds/using-data-feeds.mdx
index a7f9ccc632c..00ffcaeba89 100644
--- a/src/content/data-feeds/using-data-feeds.mdx
+++ b/src/content/data-feeds/using-data-feeds.mdx
@@ -39,7 +39,7 @@ These code examples demonstrate how to deploy a consumer contract onchain that r
 
 ### Solidity
 
-To consume price data, your smart contract should reference [`AggregatorV3Interface`](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol), which defines the external functions implemented by Data Feeds.
+To consume price data, your smart contract should reference [`AggregatorV3Interface`](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol), which defines the external functions implemented by Data Feeds.
 
 <CodeSample src="samples/DataFeeds/DataConsumerV3.sol" />
 
diff --git a/src/content/data-streams/reference/streams-direct-interface-ws.mdx b/src/content/data-streams/reference/streams-direct-interface-ws.mdx
index c1d308d944c..284aebadf00 100644
--- a/src/content/data-streams/reference/streams-direct-interface-ws.mdx
+++ b/src/content/data-streams/reference/streams-direct-interface-ws.mdx
@@ -10,9 +10,9 @@ import DataStreams from "@features/data-streams/common/DataStreams.astro"
 
 ## Domains
 
-| Description                                      | Testnet URL                               | Mainnet URL                    |
-| ------------------------------------------------ | ----------------------------------------- | ------------------------------ |
-| WebSocket endpoint to subscribe to price updates | https://ws.testnet-dataengine.chain.link/ | wss://ws.dataengine.chain.link |
+| Description                                      | Testnet URL                             | Mainnet URL                    |
+| ------------------------------------------------ | --------------------------------------- | ------------------------------ |
+| WebSocket endpoint to subscribe to price updates | wss://ws.testnet-dataengine.chain.link/ | wss://ws.dataengine.chain.link |
 
 ## Authentication
 
@@ -20,9 +20,9 @@ import DataStreams from "@features/data-streams/common/DataStreams.astro"
 
 All routes require the following three headers for user authentication:
 
-| Header                           | Description                                                                                                                                                                      |
-| -------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `Authorization`                   | The user’s unique identifier, provided as a UUID (Universally Unique IDentifier).                                                                                                |
+| Header                             | Description                                                                                                                                                                      |
+| ---------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `Authorization`                    | The user’s unique identifier, provided as a UUID (Universally Unique IDentifier).                                                                                                |
 | `X-Authorization-Timestamp`        | The current timestamp, with precision up to milliseconds. The timestamp must closely synchronize with the server time, allowing a maximum discrepancy of 5 seconds (by default). |
 | `X-Authorization-Signature-SHA256` | The HMAC (Hash-based Message Authentication Code) signature, generated by hashing parts of the request and its metadata using SHA-256 with a shared secret key.                  |
 
diff --git a/src/content/quickstarts/dev3-chainlink-sdk.mdx b/src/content/quickstarts/dev3-chainlink-sdk.mdx
index 700b230e144..0743b625f4a 100644
--- a/src/content/quickstarts/dev3-chainlink-sdk.mdx
+++ b/src/content/quickstarts/dev3-chainlink-sdk.mdx
@@ -72,8 +72,7 @@ Once the SDK is initialized, you can start consuming different feeds as outlined
 {/* prettier-ignore */}
 <TabsContent sharedStore="feedType" client:visible>
   <Fragment slot="tab.1">Price Feeds</Fragment>
-  <Fragment slot="tab.2">NFT Floor Price Feeds</Fragment>
-  <Fragment slot="tab.3">Proof of Reserve Feeds</Fragment>
+  <Fragment slot="tab.2">Proof of Reserve Feeds</Fragment>
   <Fragment slot="panel.1">
   1. Add the following code to your JavaScript or TypeScript file:
       ```ts
@@ -91,8 +90,8 @@ Once the SDK is initialized, you can start consuming different feeds as outlined
   <Fragment slot="panel.2">
   1. Add the following code to your JavaScript or TypeScript file:
       ```ts
-      // Azuki floor price
-      ethSDK.getFromOracle(ethSDK.feeds.COINBASE_AZUKI_FLOOR_PRICE_ETH).then((res) => {
+      // HBTC PoR
+      ethSDK.getFromOracle(ethSDK.feeds.HBTC_POR).then((res) => {
           console.log(res.answer.toString());
       });
       ```
@@ -100,21 +99,7 @@ Once the SDK is initialized, you can start consuming different feeds as outlined
       ```sh
       node index.js
       ```
-  1. The output should be similar to: `3480450640000000000`. Compare this to the [Azuki floor price feed](https://data.chain.link/ethereum/mainnet/nft-floor-prices/coinbase-azuki-floor-price-eth), which returns `Ξ3.4805` at the time of writing.
-  </Fragment>
-  <Fragment slot="panel.3">
-  1. Add the following code to your JavaScript or TypeScript file:
-      ```ts
-      // eFIL reserves
-      ethSDK.getFromOracle(ethSDK.feeds.EFIL_POR).then((res) => {
-          console.log(res.answer.toString());
-      });
-      ```
-  1. Run your file. For example:
-      ```sh
-      node index.js
-      ```
-  1. The output should be similar to: `126365967984000000000000`. Compare this to the [eFIL reserves price feed](https://data.chain.link/ethereum/mainnet/reserves/efil-por), which returns `126,366` at the time of writing.
+  1. The output should be similar to: `970807798330000000000`. Compare this to the [HBTC PoR price feed](https://data.chain.link/feeds/ethereum/mainnet/hbtc-por), which returns `970.81` at the time of writing.
   </Fragment>
 </TabsContent>
 
diff --git a/src/content/quickstarts/eth-balance-monitor.mdx b/src/content/quickstarts/eth-balance-monitor.mdx
index 562fba2cce8..3fe38228b65 100644
--- a/src/content/quickstarts/eth-balance-monitor.mdx
+++ b/src/content/quickstarts/eth-balance-monitor.mdx
@@ -114,7 +114,7 @@ After you are done with this example, you can run the `withdraw` function on you
 
 ## Examine the example code
 
-The [`EthBalanceMonitor` contract](https://github.com/smartcontractkit/documentation/blob/main/public/samples/Automation/tutorials/EthBalanceMonitor.sol) is ownable, pauseable, and compatible with the [`AutomationCompatibleInterface` contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/automation/interfaces/AutomationCompatibleInterface.sol):
+The [`EthBalanceMonitor` contract](https://github.com/smartcontractkit/documentation/blob/main/public/samples/Automation/tutorials/EthBalanceMonitor.sol) is ownable, pauseable, and compatible with the [`AutomationCompatibleInterface` contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/automation/interfaces/AutomationCompatibleInterface.sol):
 
 - **Ownable**: The contract has an owner address, and provides basic authorization control functions. This simplifies the implementation of _user permissions_ and allows for transfer of ownership.
 - **Pauseable**: This feature allows the contract to implement a pause and unpause mechanism that the contract owner can trigger.
diff --git a/src/content/resources/contributing-to-chainlink.mdx b/src/content/resources/contributing-to-chainlink.mdx
index 4a59292598e..952c5214272 100644
--- a/src/content/resources/contributing-to-chainlink.mdx
+++ b/src/content/resources/contributing-to-chainlink.mdx
@@ -6,7 +6,7 @@ title: "Contributing to Chainlink"
 
 import { YouTube } from "@astro-community/astro-embed-youtube"
 
-Chainlink is an open-source project licensed [under the MIT license](https://github.com/smartcontractkit/chainlink/blob/master/LICENSE).
+Chainlink is an open-source project licensed [under the MIT license](https://github.com/smartcontractkit/chainlink/blob/develop/LICENSE).
 
 <YouTube id="https://www.youtube.com/watch?v=nerpcSPN4kE" />
 
diff --git a/src/content/vrf/v1/api-reference.mdx b/src/content/vrf/v1/api-reference.mdx
index d0ec3e28fff..79ccdbf9362 100644
--- a/src/content/vrf/v1/api-reference.mdx
+++ b/src/content/vrf/v1/api-reference.mdx
@@ -11,7 +11,7 @@ import VrfCommon from "@features/vrf/v1/common/VrfCommon.astro"
 
 <VrfCommon />
 
-API reference for [`VRFConsumerBase`](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/VRFConsumerBase.sol).
+API reference for [`VRFConsumerBase`](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/VRFConsumerBase.sol).
 
 ## Index
 
diff --git a/src/content/vrf/v1/examples/get-a-random-number.mdx b/src/content/vrf/v1/examples/get-a-random-number.mdx
index db10dc3034b..bebe9480882 100644
--- a/src/content/vrf/v1/examples/get-a-random-number.mdx
+++ b/src/content/vrf/v1/examples/get-a-random-number.mdx
@@ -16,7 +16,7 @@ This page explains how to get a random number inside a smart contract using Chai
 
 ## Random Number Consumer
 
-Chainlink VRF follows the [Request & Receive Data](/any-api/introduction) cycle. To consume randomness, your contract should inherit from [VRFConsumerBase](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/VRFConsumerBase.sol) and define two required functions:
+Chainlink VRF follows the [Request & Receive Data](/any-api/introduction) cycle. To consume randomness, your contract should inherit from [VRFConsumerBase](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/VRFConsumerBase.sol) and define two required functions:
 
 - `requestRandomness`, which makes the initial request for randomness.
 - `fulfillRandomness`, which is the function that receives and does something with verified randomness.
diff --git a/src/content/vrf/v2-5/arbitrum-cost-estimation.mdx b/src/content/vrf/v2-5/arbitrum-cost-estimation.mdx
index 602b8851303..d4bf8a04327 100644
--- a/src/content/vrf/v2-5/arbitrum-cost-estimation.mdx
+++ b/src/content/vrf/v2-5/arbitrum-cost-estimation.mdx
@@ -108,12 +108,12 @@ This conversion allows us to estimate the L1 callback gas cost and incorporate i
 
 This sample extends the [original Arbitrum gas estimation script](https://github.com/OffchainLabs/arbitrum-tutorials/tree/master/packages/gas-estimation) to estimate gas costs for VRF subscription and direct funding requests on Arbitrum.
 
-The following snippet shows only the VRF variables and calculations that were added to the Arbitrum gas estimation script. To learn more about how Arbitrum gas is calculated, refer to the [Arbitrum gas estimation tutorial](https://developer.arbitrum.io/devs-how-tos/how-to-estimate-gas). To run this code, use the [**full Arbitrum gas estimation script that includes VRF calculations**](https://github.com/smartcontractkit/smart-contract-examples/tree/main/vrf/arbitrum-cost-estimation).
+The following snippet shows only the VRF variables and calculations that were added to the Arbitrum gas estimation script. To learn more about how Arbitrum gas is calculated, refer to the [Arbitrum gas estimation tutorial](https://developer.arbitrum.io/devs-how-tos/how-to-estimate-gas). To run this code, use the [**full Arbitrum gas estimation script that includes VRF calculations**](https://github.com/smartcontractkit/smart-contract-examples/tree/main/vrf-arbitrum-gas-estimation).
 
 ```typescript
 // VRF variables and calculations
 // ---------------------------------
-// Full script: https://github.com/smartcontractkit/smart-contract-examples/tree/main/vrf/arbitrum-cost-estimation
+// Full script: https://github.com/smartcontractkit/smart-contract-examples/tree/main/vrf-arbitrum-gas-estimation
 // ---------------------------------
 // Estimated upper bound of verification gas for VRF subscription.
 // To see an estimate with an average amount of verification gas,
diff --git a/src/content/vrf/v2-5/migration-from-v2.mdx b/src/content/vrf/v2-5/migration-from-v2.mdx
index 8598fdc9c5a..fcd2e9eef49 100644
--- a/src/content/vrf/v2-5/migration-from-v2.mdx
+++ b/src/content/vrf/v2-5/migration-from-v2.mdx
@@ -167,7 +167,7 @@ Use this interface and wrapper:
 
 </Aside>
 
-1.  Import the [`VRFV2PlusWrapperConsumerBase`](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/dev/VRFV2PlusWrapperConsumerBase.sol) contract and remove the v2 `VRFV2WrapperConsumerBase` import.
+1.  Import the [`VRFV2PlusWrapperConsumerBase`](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/dev/VRFV2PlusWrapperConsumerBase.sol) contract and remove the v2 `VRFV2WrapperConsumerBase` import.
 
 1.  Add a `VRFV2PlusWrapperConsumerBase` constructor, passing in the VRF wrapper address for the network you're using. Unlike V2, you don't have to pass the LINK token address to the constructor.
 
diff --git a/src/content/vrf/v2-5/overview/direct-funding.mdx b/src/content/vrf/v2-5/overview/direct-funding.mdx
index 4cf5cbd700b..32b536596bc 100644
--- a/src/content/vrf/v2-5/overview/direct-funding.mdx
+++ b/src/content/vrf/v2-5/overview/direct-funding.mdx
@@ -36,8 +36,8 @@ Two types of accounts exist in the Ethereum ecosystem, and both are used in VRF:
 
 The Chainlink VRF v2.5 solution uses both offchain and onchain components:
 
-- [VRF v2.5 Wrapper (onchain component)](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/dev/VRFV2PlusWrapper.sol): A wrapper for the VRF Coordinator that provides an interface for consuming contracts.
-- [VRF v2.5 Coordinator (onchain component)](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/dev/VRFCoordinatorV2_5.sol): A contract designed to interact with the VRF service. It emits an event when a request for randomness is made, and then verifies the random number and proof of how it was generated by the VRF service.
+- [VRF v2.5 Wrapper (onchain component)](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/dev/VRFV2PlusWrapper.sol): A wrapper for the VRF Coordinator that provides an interface for consuming contracts.
+- [VRF v2.5 Coordinator (onchain component)](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/dev/VRFCoordinatorV2_5.sol): A contract designed to interact with the VRF service. It emits an event when a request for randomness is made, and then verifies the random number and proof of how it was generated by the VRF service.
 - VRF service (offchain component): Listens for requests by subscribing to the VRF Coordinator event logs and calculates a random number based on the block hash and nonce. The VRF service then sends a transaction to the `VRFCoordinator` including the random number and a proof of how it was generated.
 
 ### Set up your contract and request
@@ -61,9 +61,9 @@ After you submit your request, it is processed using the [Request & Receive Data
 
 1. The consuming contract calls the [VRFV2PlusWrapper](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/dev/VRFV2PlusWrapper.sol) `calculateRequestPrice` function to estimate the total transaction cost to fulfill randomness. Learn [how to estimate transaction costs](/vrf/v2-5/billing).
 
-1. The consuming contract calls the [LinkToken](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/shared/token/ERC677/LinkToken.sol) `transferAndCall` function to pay the wrapper with the calculated request price. This method sends LINK tokens and executes the [VRFV2PlusWrapper](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/dev/VRFV2PlusWrapper.sol) `onTokenTransfer` logic.
+1. The consuming contract calls the [LinkToken](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/shared/token/ERC677/LinkToken.sol) `transferAndCall` function to pay the wrapper with the calculated request price. This method sends LINK tokens and executes the [VRFV2PlusWrapper](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/dev/VRFV2PlusWrapper.sol) `onTokenTransfer` logic.
 
-1. The VRFV2PlusWrapper's `onTokenTransfer` logic triggers the [VRF 2.5 Coordinator](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/dev/VRFCoordinatorV2_5.sol) `requestRandomWords` function to request randomness.
+1. The VRFV2PlusWrapper's `onTokenTransfer` logic triggers the [VRF 2.5 Coordinator](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/dev/VRFCoordinatorV2_5.sol) `requestRandomWords` function to request randomness.
 
 1. The VRF coordinator emits an event.
 
diff --git a/src/content/vrf/v2-5/overview/subscription.mdx b/src/content/vrf/v2-5/overview/subscription.mdx
index 9cf8d0a5dc3..2da46ec22f6 100644
--- a/src/content/vrf/v2-5/overview/subscription.mdx
+++ b/src/content/vrf/v2-5/overview/subscription.mdx
@@ -62,7 +62,7 @@ Two types of accounts exist in the Ethereum ecosystem, and both are used in VRF:
 
 VRF v2.5 uses both offchain and onchain components:
 
-- [VRF v2.5 Coordinator (onchain component)](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/dev/VRFCoordinatorV2_5.sol): A contract designed to interact with the VRF service. It emits an event when a request for randomness is made, and then verifies the random number and proof of how it was generated by the VRF service.
+- [VRF v2.5 Coordinator (onchain component)](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/dev/VRFCoordinatorV2_5.sol): A contract designed to interact with the VRF service. It emits an event when a request for randomness is made, and then verifies the random number and proof of how it was generated by the VRF service.
 - VRF service (offchain component): Listens for requests by subscribing to the VRF Coordinator event logs and calculates a random number based on the block hash and nonce. The VRF service then sends a transaction to the `VRFCoordinator` including the random number and a proof of how it was generated.
 
 ### Set up your contract and request
@@ -84,7 +84,6 @@ Set up your consuming contract:
 In VRF 2.5, the request format has changed:
 
 {/* prettier-ignore */}
-
 ```solidity
 uint256 requestID = s_vrfCoordinator.requestRandomWords(VRFV2PlusClient.RandomWordsRequest({
     keyHash: keyHash,
diff --git a/src/content/vrf/v2/direct-funding/examples/get-a-random-number.mdx b/src/content/vrf/v2/direct-funding/examples/get-a-random-number.mdx
index ee5c76feb18..2169ed6889d 100644
--- a/src/content/vrf/v2/direct-funding/examples/get-a-random-number.mdx
+++ b/src/content/vrf/v2/direct-funding/examples/get-a-random-number.mdx
@@ -34,8 +34,8 @@ If you are new to developing smart contracts on Ethereum, see the [Getting Start
 
 For this example, use the [VRFv2DirectFundingConsumer.sol](https://remix.ethereum.org/#url=https://docs.chain.link/samples/VRF/VRFv2DirectFundingConsumer.sol) sample contract. This contract imports the following dependencies:
 
-- `VRFV2WrapperConsumerBase.sol`[(link)](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/VRFV2WrapperConsumerBase.sol)
-- `ConfirmedOwner.sol`[(link)](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/shared/access/ConfirmedOwner.sol)
+- `VRFV2WrapperConsumerBase.sol`[(link)](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/VRFV2WrapperConsumerBase.sol)
+- `ConfirmedOwner.sol`[(link)](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/shared/access/ConfirmedOwner.sol)
 
 The contract also includes pre-configured values for the necessary request parameters such as `callbackGasLimit`, `requestConfirmations`, the number of random words `numWords`, the VRF v2 Wrapper address `wrapperAddress`, and the LINK token address `linkAddress`. You can change these parameters if you want to experiment on different testnets.
 
diff --git a/src/content/vrf/v2/direct-funding/examples/test-locally.mdx b/src/content/vrf/v2/direct-funding/examples/test-locally.mdx
index 2e31aa016b3..8fa3f022254 100644
--- a/src/content/vrf/v2/direct-funding/examples/test-locally.mdx
+++ b/src/content/vrf/v2/direct-funding/examples/test-locally.mdx
@@ -26,17 +26,17 @@ This guide explains how to test Chainlink VRF v2 on a [Remix IDE](https://remix-
 
 Complete the following tasks to test your VRF v2 consumer locally:
 
-1. Deploy the [VRFCoordinatorV2Mock](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/mocks/VRFCoordinatorV2Mock.sol). This contract is a mock of the [VRFCoordinatorV2](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/VRFCoordinatorV2.sol) contract.
-1. Deploy the [MockV3Aggregator](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/tests/MockV3Aggregator.sol) contract.
-1. Deploy the [LinkToken](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/shared/token/ERC677/LinkToken.sol) contract.
-1. Deploy the [VRFV2Wrapper](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/VRFV2Wrapper.sol) contract.
-1. Call the VRFV2Wrapper [setConfig function](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/VRFV2Wrapper.sol#L119) to set wrapper specific parameters.
+1. Deploy the [VRFCoordinatorV2Mock](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/mocks/VRFCoordinatorV2Mock.sol). This contract is a mock of the [VRFCoordinatorV2](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/VRFCoordinatorV2.sol) contract.
+1. Deploy the [MockV3Aggregator](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/tests/MockV3Aggregator.sol) contract.
+1. Deploy the [LinkToken](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/shared/token/ERC677/LinkToken.sol) contract.
+1. Deploy the [VRFV2Wrapper](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/VRFV2Wrapper.sol) contract.
+1. Call the VRFV2Wrapper [setConfig function](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/VRFV2Wrapper.sol#L119) to set wrapper specific parameters.
 1. Fund the VRFv2Wrapper subscription.
-1. Call the VRFCoordinatorV2Mock [addConsumer function](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/mocks/VRFCoordinatorV2Mock.sol#L230) to add the wrapper contract to your subscription.
+1. Call the VRFCoordinatorV2Mock [addConsumer function](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/mocks/VRFCoordinatorV2Mock.sol#L230) to add the wrapper contract to your subscription.
 1. Deploy your VRF consumer contract.
 1. Fund your consumer contract with LINK tokens.
 1. Request random words from your consumer contract.
-1. Call the VRFCoordinatorV2Mock [fulfillRandomWords function](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/mocks/VRFCoordinatorV2Mock.sol#L108) to fulfill your consumer contract request.
+1. Call the VRFCoordinatorV2Mock [fulfillRandomWords function](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/mocks/VRFCoordinatorV2Mock.sol#L108) to fulfill your consumer contract request.
 
 ## Prerequisites
 
diff --git a/src/content/vrf/v2/direct-funding/index.mdx b/src/content/vrf/v2/direct-funding/index.mdx
index 0910a2cb2d7..990635626f4 100644
--- a/src/content/vrf/v2/direct-funding/index.mdx
+++ b/src/content/vrf/v2/direct-funding/index.mdx
@@ -37,19 +37,19 @@ Two types of accounts exist in the Ethereum ecosystem, and both are used in VRF:
 
 The Chainlink VRF v2 solution uses both offchain and onchain components:
 
-- [VRF v2 Wrapper (onchain component)](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/VRFV2Wrapper.sol): A wrapper for the VRF Coordinator that provides an interface for consuming contracts.
-- [VRF v2 Coordinator (onchain component)](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/VRFCoordinatorV2.sol): A contract designed to interact with the VRF service. It emits an event when a request for randomness is made, and then verifies the random number and proof of how it was generated by the VRF service.
+- [VRF v2 Wrapper (onchain component)](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/VRFV2Wrapper.sol): A wrapper for the VRF Coordinator that provides an interface for consuming contracts.
+- [VRF v2 Coordinator (onchain component)](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/VRFCoordinatorV2.sol): A contract designed to interact with the VRF service. It emits an event when a request for randomness is made, and then verifies the random number and proof of how it was generated by the VRF service.
 - VRF service (offchain component): Listens for requests by subscribing to the VRF Coordinator event logs and calculates a random number based on the block hash and nonce. The VRF service then sends a transaction to the `VRFCoordinator` including the random number and a proof of how it was generated.
 
 ### Set up your contract and request
 
 Set up your consuming contract:
 
-1. Your contract must inherit [VRFV2WrapperConsumerBase](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/VRFV2WrapperConsumerBase.sol).
+1. Your contract must inherit [VRFV2WrapperConsumerBase](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/VRFV2WrapperConsumerBase.sol).
 
 1. Your contract must implement the `fulfillRandomWords` function, which is the _callback VRF function_. Here, you add logic to handle the random values after they are returned to your contract.
 
-1. Submit your VRF request by calling the `requestRandomness` function in the [VRFV2WrapperConsumerBase](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/VRFV2WrapperConsumerBase.sol) contract. Include the following parameters in your request:
+1. Submit your VRF request by calling the `requestRandomness` function in the [VRFV2WrapperConsumerBase](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/VRFV2WrapperConsumerBase.sol) contract. Include the following parameters in your request:
 
    - `requestConfirmations`: The number of block confirmations the VRF service will wait to respond. The minimum and maximum confirmations for your network can be found [here](/vrf/v2/direct-funding/supported-networks/#configurations).
    - `callbackGasLimit`: The maximum amount of gas to pay for completing the callback VRF function.
@@ -59,11 +59,11 @@ Set up your consuming contract:
 
 After you submit your request, it is processed using the [Request & Receive Data](#request-and-receive-data) cycle:
 
-1. The consuming contract calls the [VRFV2Wrapper](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/VRFV2Wrapper.sol) `calculateRequestPrice` function to estimate the total transaction cost to fulfill randomness. Learn [how to estimate transaction costs](/vrf/v2/estimating-costs).
+1. The consuming contract calls the [VRFV2Wrapper](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/VRFV2Wrapper.sol) `calculateRequestPrice` function to estimate the total transaction cost to fulfill randomness. Learn [how to estimate transaction costs](/vrf/v2/estimating-costs).
 
-1. The consuming contract calls the [LinkToken](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/shared/token/ERC677/LinkToken.sol) `transferAndCall` function to pay the wrapper with the calculated request price. This method sends LINK tokens and executes the [VRFV2Wrapper](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/VRFV2Wrapper.sol) `onTokenTransfer` logic.
+1. The consuming contract calls the [LinkToken](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/shared/token/ERC677/LinkToken.sol) `transferAndCall` function to pay the wrapper with the calculated request price. This method sends LINK tokens and executes the [VRFV2Wrapper](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/VRFV2Wrapper.sol) `onTokenTransfer` logic.
 
-1. The VRFV2Wrapper's `onTokenTransfer` logic triggers the [VRF Coordinator](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/VRFCoordinatorV2.sol) `requestRandomWords` function to request randomness.
+1. The VRFV2Wrapper's `onTokenTransfer` logic triggers the [VRF Coordinator](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/VRFCoordinatorV2.sol) `requestRandomWords` function to request randomness.
 
 1. The VRF coordinator emits an event.
 
diff --git a/src/content/vrf/v2/direct-funding/migration-from-v1.mdx b/src/content/vrf/v2/direct-funding/migration-from-v1.mdx
index 0bd2c654bec..3122f592b5a 100644
--- a/src/content/vrf/v2/direct-funding/migration-from-v1.mdx
+++ b/src/content/vrf/v2/direct-funding/migration-from-v1.mdx
@@ -22,7 +22,7 @@ The main similarity between VRF v1 and VRF v2 Direct funding method is that cons
 
 To modify your existing smart contract code to work with VRF v2, complete the following changes. See the [Get a Random Number](/vrf/v2/direct-funding/examples/get-a-random-number) guide for an example.
 
-1. Import and inherit the new [`VRFV2WrapperConsumerBase.sol` contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/VRFV2WrapperConsumerBase.sol) and remove the v1 `VRFConsumerBase.sol` import. This contract includes the `fulfillRandomWords` function.
+1. Import and inherit the new [`VRFV2WrapperConsumerBase.sol` contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/VRFV2WrapperConsumerBase.sol) and remove the v1 `VRFConsumerBase.sol` import. This contract includes the `fulfillRandomWords` function.
 
 1. Add a `VRFV2WrapperConsumerBase` constructor as shown in the [Get a Random Number](/vrf/v2/direct-funding/examples/get-a-random-number) example and use the correct VRF v2 Direct funding configuration.
 
diff --git a/src/content/vrf/v2/estimating-costs.mdx b/src/content/vrf/v2/estimating-costs.mdx
index 0cdd84a79ce..b7f88f2e01c 100644
--- a/src/content/vrf/v2/estimating-costs.mdx
+++ b/src/content/vrf/v2/estimating-costs.mdx
@@ -368,12 +368,12 @@ This conversion allows us to estimate the L1 callback gas cost and incorporate i
 
 This sample extends the [original Arbitrum gas estimation script](https://github.com/OffchainLabs/arbitrum-tutorials/tree/master/packages/gas-estimation) to estimate gas costs for VRF subscription and direct funding requests on Arbitrum.
 
-The following snippet shows only the VRF variables and calculations that were added to the Arbitrum gas estimation script. To learn more about how Arbitrum gas is calculated, refer to the [Arbitrum gas estimation tutorial](https://developer.arbitrum.io/devs-how-tos/how-to-estimate-gas). To run this code, use the [**full Arbitrum gas estimation script that includes VRF calculations**](https://github.com/smartcontractkit/smart-contract-examples/tree/main/vrf/arbitrum-cost-estimation).
+The following snippet shows only the VRF variables and calculations that were added to the Arbitrum gas estimation script. To learn more about how Arbitrum gas is calculated, refer to the [Arbitrum gas estimation tutorial](https://developer.arbitrum.io/devs-how-tos/how-to-estimate-gas). To run this code, use the [**full Arbitrum gas estimation script that includes VRF calculations**](https://github.com/smartcontractkit/smart-contract-examples/tree/main/vrf-arbitrum-gas-estimation).
 
 ```typescript
 // VRF variables and calculations
 // ---------------------------------
-// Full script: https://github.com/smartcontractkit/smart-contract-examples/tree/main/vrf/arbitrum-cost-estimation
+// Full script: https://github.com/smartcontractkit/smart-contract-examples/tree/main/vrf-arbitrum-gas-estimation
 // ---------------------------------
 // Estimated upper bound of verification gas for VRF subscription.
 // To see an estimate with an average amount of verification gas,
diff --git a/src/content/vrf/v2/getting-started.mdx b/src/content/vrf/v2/getting-started.mdx
index 2a4ed87449a..5e1b5fcfefc 100644
--- a/src/content/vrf/v2/getting-started.mdx
+++ b/src/content/vrf/v2/getting-started.mdx
@@ -72,8 +72,8 @@ For this example, create a new subscription on the Sepolia testnet as explained
 
 Chainlink maintains a [library of contracts](https://github.com/smartcontractkit/chainlink/tree/master/contracts) that make consuming data from oracles easier. For Chainlink VRF, you will use:
 
-- [`VRFConsumerBaseV2`](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/VRFConsumerBaseV2.sol) that must be imported and extended from the contract that you create.
-- [`VRFCoordinatorV2Interface`](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/interfaces/VRFCoordinatorV2Interface.sol) that must be imported to communicate with the VRF coordinator.
+- [`VRFConsumerBaseV2`](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/VRFConsumerBaseV2.sol) that must be imported and extended from the contract that you create.
+- [`VRFCoordinatorV2Interface`](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/interfaces/VRFCoordinatorV2Interface.sol) that must be imported to communicate with the VRF coordinator.
 
 {/* prettier-ignore */}
 ```solidity
diff --git a/src/content/vrf/v2/subscription/examples/get-a-random-number.mdx b/src/content/vrf/v2/subscription/examples/get-a-random-number.mdx
index 9f00b624e65..702b1de2fa0 100644
--- a/src/content/vrf/v2/subscription/examples/get-a-random-number.mdx
+++ b/src/content/vrf/v2/subscription/examples/get-a-random-number.mdx
@@ -68,9 +68,9 @@ Now that you have a funded subscription account and your subscription ID, [creat
 
 For this example, use the [VRFv2Consumer.sol](https://remix.ethereum.org/#url=https://docs.chain.link/samples/VRF/VRFv2Consumer.sol) sample contract. This contract imports the following dependencies:
 
-- `VRFConsumerBaseV2.sol`[(link)](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/VRFConsumerBaseV2.sol)
-- `VRFCoordinatorV2Interface.sol`[(link)](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/interfaces/VRFCoordinatorV2Interface.sol)
-- `ConfirmedOwner.sol`[(link)](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/shared/access/ConfirmedOwner.sol)
+- `VRFConsumerBaseV2.sol`[(link)](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/VRFConsumerBaseV2.sol)
+- `VRFCoordinatorV2Interface.sol`[(link)](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/interfaces/VRFCoordinatorV2Interface.sol)
+- `ConfirmedOwner.sol`[(link)](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/shared/access/ConfirmedOwner.sol)
 
 The contract also includes pre-configured values for the necessary request parameters such as `vrfCoordinator` address, gas lane `keyHash`, `callbackGasLimit`, `requestConfirmations` and number of random words `numWords`. You can change these parameters if you want to experiment on different testnets, but for this example you only need to specify `subscriptionId` when you deploy the contract.
 
diff --git a/src/content/vrf/v2/subscription/examples/programmatic-subscription.mdx b/src/content/vrf/v2/subscription/examples/programmatic-subscription.mdx
index 7d502e91727..f8c9e8dc8d6 100644
--- a/src/content/vrf/v2/subscription/examples/programmatic-subscription.mdx
+++ b/src/content/vrf/v2/subscription/examples/programmatic-subscription.mdx
@@ -25,7 +25,7 @@ You can view and monitor your subscriptions in the [Subscription Manager](/vrf/v
 
 ## Modifying subscriptions and configurations
 
-Subscription configurations do not have to be static. You can change your subscription configuration dynamically by calling the following functions using the [VRFCoordinatorV2Interface](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/interfaces/VRFCoordinatorV2Interface.sol):
+Subscription configurations do not have to be static. You can change your subscription configuration dynamically by calling the following functions using the [VRFCoordinatorV2Interface](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/interfaces/VRFCoordinatorV2Interface.sol):
 
 - Change the list of approved subscription consumers with:
   - `addConsumer(uint64 subId, address consumer)`.
diff --git a/src/content/vrf/v2/subscription/examples/test-locally.mdx b/src/content/vrf/v2/subscription/examples/test-locally.mdx
index 3ba0b16d50c..7dbc3b969f0 100644
--- a/src/content/vrf/v2/subscription/examples/test-locally.mdx
+++ b/src/content/vrf/v2/subscription/examples/test-locally.mdx
@@ -26,13 +26,13 @@ This guide explains how to test Chainlink VRF v2 on a [Remix IDE](https://remix-
 
 Complete the following tasks to test your VRF v2 consumer locally:
 
-1. Deploy the [VRFCoordinatorV2Mock](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/mocks/VRFCoordinatorV2Mock.sol). This contract is a mock of the [VRFCoordinatorV2](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/VRFCoordinatorV2.sol) contract.
-1. Call the VRFCoordinatorV2Mock [createSubscription function](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/mocks/VRFCoordinatorV2Mock.sol#L194) to create a new subscription.
-1. Call the VRFCoordinatorV2Mock [fundSubscription function](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/mocks/VRFCoordinatorV2Mock.sol#L156) to fund your newly created subscription. **Note**: You can fund with an arbitrary amount.
+1. Deploy the [VRFCoordinatorV2Mock](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/mocks/VRFCoordinatorV2Mock.sol). This contract is a mock of the [VRFCoordinatorV2](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/VRFCoordinatorV2.sol) contract.
+1. Call the VRFCoordinatorV2Mock [createSubscription function](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/mocks/VRFCoordinatorV2Mock.sol#L194) to create a new subscription.
+1. Call the VRFCoordinatorV2Mock [fundSubscription function](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/mocks/VRFCoordinatorV2Mock.sol#L156) to fund your newly created subscription. **Note**: You can fund with an arbitrary amount.
 1. Deploy your VRF consumer contract.
-1. Call the VRFCoordinatorV2Mock [addConsumer function](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/mocks/VRFCoordinatorV2Mock.sol#L230) to add your consumer contract to your subscription.
+1. Call the VRFCoordinatorV2Mock [addConsumer function](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/mocks/VRFCoordinatorV2Mock.sol#L230) to add your consumer contract to your subscription.
 1. Request random words from your consumer contract.
-1. Call the VRFCoordinatorV2Mock [fulfillRandomWords function](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/mocks/VRFCoordinatorV2Mock.sol#L108) to fulfill your consumer contract request.
+1. Call the VRFCoordinatorV2Mock [fulfillRandomWords function](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/mocks/VRFCoordinatorV2Mock.sol#L108) to fulfill your consumer contract request.
 
 ## Testing
 
diff --git a/src/content/vrf/v2/subscription/index.mdx b/src/content/vrf/v2/subscription/index.mdx
index 6aa1358befb..4f117df053d 100644
--- a/src/content/vrf/v2/subscription/index.mdx
+++ b/src/content/vrf/v2/subscription/index.mdx
@@ -64,18 +64,18 @@ Two types of accounts exist in the Ethereum ecosystem, and both are used in VRF:
 
 The Chainlink VRF v2 solution uses both offchain and onchain components:
 
-- [VRF v2 Coordinator (onchain component)](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/VRFCoordinatorV2.sol): A contract designed to interact with the VRF service. It emits an event when a request for randomness is made, and then verifies the random number and proof of how it was generated by the VRF service.
+- [VRF v2 Coordinator (onchain component)](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/VRFCoordinatorV2.sol): A contract designed to interact with the VRF service. It emits an event when a request for randomness is made, and then verifies the random number and proof of how it was generated by the VRF service.
 - VRF service (offchain component): Listens for requests by subscribing to the VRF Coordinator event logs and calculates a random number based on the block hash and nonce. The VRF service then sends a transaction to the `VRFCoordinator` including the random number and a proof of how it was generated.
 
 ### Set up your contract and request
 
 Set up your consuming contract:
 
-1. Your contract must inherit [VRFConsumerBaseV2](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/VRFConsumerBaseV2.sol).
+1. Your contract must inherit [VRFConsumerBaseV2](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/VRFConsumerBaseV2.sol).
 
 1. Your contract must implement the `fulfillRandomWords` function, which is the _callback VRF function_. Here, you add logic to handle the random values after they are returned to your contract.
 
-1. Submit your VRF request by calling `requestRandomWords` of the [VRF Coordinator](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/VRFCoordinatorV2.sol). Include the following parameters in your request:
+1. Submit your VRF request by calling `requestRandomWords` of the [VRF Coordinator](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/VRFCoordinatorV2.sol). Include the following parameters in your request:
 
    - `keyHash`: Identifier that maps to a job and a private key on the VRF service and that represents a specified gas lane. If your request is urgent, specify a gas lane with a higher gas price limit. The configuration for your network can be found [here](/vrf/v2/subscription/supported-networks/#configurations).
    - `s_subscriptionId`: The subscription ID that the consuming contract is registered to. LINK funds are deducted from this subscription.
diff --git a/src/content/vrf/v2/subscription/migration-from-v1.mdx b/src/content/vrf/v2/subscription/migration-from-v1.mdx
index eadb1cbd8ec..fd547b60016 100644
--- a/src/content/vrf/v2/subscription/migration-from-v1.mdx
+++ b/src/content/vrf/v2/subscription/migration-from-v1.mdx
@@ -38,9 +38,9 @@ To modify your existing smart contract code to work with VRF v2, complete the fo
      <a href="https://vrf.chain.link">Open the Subscription Manager</a>
    </div>
 
-1. Import the new [`VRFConsumerBaseV2.sol` contract](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/VRFConsumerBaseV2.sol) and remove the v1 `VRFConsumerBase.sol` import. This contract includes the `fulfillRandomWords` function.
+1. Import the new [`VRFConsumerBaseV2.sol` contract](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/VRFConsumerBaseV2.sol) and remove the v1 `VRFConsumerBase.sol` import. This contract includes the `fulfillRandomWords` function.
 
-1. Import the [`VRFCoordinatorV2Interface.sol` interface](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/vrf/interfaces/VRFCoordinatorV2Interface.sol). This interface includes the new `requestRandomWords` function.
+1. Import the [`VRFCoordinatorV2Interface.sol` interface](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/vrf/interfaces/VRFCoordinatorV2Interface.sol). This interface includes the new `requestRandomWords` function.
 
 1. Add a `VRFConsumerBaseV2` constructor as shown in the [Get a Random Number](/vrf/v2/subscription/examples/get-a-random-number) example.
 
diff --git a/src/features/chainlink-automation/common/iLogAutomation.mdx b/src/features/chainlink-automation/common/iLogAutomation.mdx
index 72bf4142e70..c122659b356 100644
--- a/src/features/chainlink-automation/common/iLogAutomation.mdx
+++ b/src/features/chainlink-automation/common/iLogAutomation.mdx
@@ -1,6 +1,6 @@
 import { CodeSample } from "@components"
 
-To use log triggers, you will need to implement the [`ILogAutomation.sol`](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/automation/interfaces/ILogAutomation.sol) interface in your smart contract. Click on the functions below to understand the parameters:
+To use log triggers, you will need to implement the [`ILogAutomation.sol`](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/automation/interfaces/ILogAutomation.sol) interface in your smart contract. Click on the functions below to understand the parameters:
 
 | Function Name   | Description                                                                           |
 | --------------- | ------------------------------------------------------------------------------------- |
diff --git a/src/features/chainlink-functions/common/AutomatedFunctionsConsumer.mdx b/src/features/chainlink-functions/common/AutomatedFunctionsConsumer.mdx
index 55651c57c8f..e8b490c43df 100644
--- a/src/features/chainlink-functions/common/AutomatedFunctionsConsumer.mdx
+++ b/src/features/chainlink-functions/common/AutomatedFunctionsConsumer.mdx
@@ -2,7 +2,7 @@ import { CodeSample } from "@components"
 
 <CodeSample src="samples/ChainlinkFunctions/AutomatedFunctionsConsumerExample.sol" />
 
-- To write an automated Chainlink Functions consumer contract, your contract must import [FunctionsClient.sol](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/functions/v1_0_0/FunctionsClient.sol). You can read the API reference of [FunctionsClient](/chainlink-functions/api-reference/functions-client).
+- To write an automated Chainlink Functions consumer contract, your contract must import [FunctionsClient.sol](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/functions/v1_0_0/FunctionsClient.sol). You can read the API reference of [FunctionsClient](/chainlink-functions/api-reference/functions-client).
 
   The contract is available in an NPM package, so you can import it from within your project.
 
diff --git a/src/features/chainlink-functions/common/CustomAutomatedFunctionsConsumer.mdx b/src/features/chainlink-functions/common/CustomAutomatedFunctionsConsumer.mdx
index 9dabd48f7df..a29fe17f257 100644
--- a/src/features/chainlink-functions/common/CustomAutomatedFunctionsConsumer.mdx
+++ b/src/features/chainlink-functions/common/CustomAutomatedFunctionsConsumer.mdx
@@ -2,7 +2,7 @@ import { CodeSample } from "@components"
 
 <CodeSample src="samples/ChainlinkFunctions/CustomAutomatedFunctionsConsumerExample.sol" />
 
-- To write an automated Chainlink Functions consumer contract, your contract must import [FunctionsClient.sol](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/functions/v1_0_0/FunctionsClient.sol). You can read the API reference of [FunctionsClient](/chainlink-functions/api-reference/functions-client).
+- To write an automated Chainlink Functions consumer contract, your contract must import [FunctionsClient.sol](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/functions/v1_0_0/FunctionsClient.sol). You can read the API reference of [FunctionsClient](/chainlink-functions/api-reference/functions-client).
 
   The contract is available in an NPM package, so you can import it from within your project.
 
@@ -10,7 +10,7 @@ import { CodeSample } from "@components"
   import {FunctionsClient} from "@chainlink/contracts/src/v0.8/functions/v1_0_0/FunctionsClient.sol";
   ```
 
-- To write a compatible Automations contract, your contract must import [AutomationCompatibleInterface.sol](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/automation/AutomationCompatible.sol).
+- To write a compatible Automations contract, your contract must import [AutomationCompatibleInterface.sol](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/automation/AutomationCompatible.sol).
 
   The contract is available in an NPM package, so you can import it from within your project.
 
diff --git a/src/features/chainlink-functions/common/FunctionsConsumer.mdx b/src/features/chainlink-functions/common/FunctionsConsumer.mdx
index 572bb810afe..6f1a40601d0 100644
--- a/src/features/chainlink-functions/common/FunctionsConsumer.mdx
+++ b/src/features/chainlink-functions/common/FunctionsConsumer.mdx
@@ -2,7 +2,7 @@ import { CodeSample } from "@components"
 
 <CodeSample src="samples/ChainlinkFunctions/FunctionsConsumerExample.sol" />
 
-- To write a Chainlink Functions consumer contract, your contract must import [FunctionsClient.sol](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/functions/v1_0_0/FunctionsClient.sol) and [FunctionsRequest.sol](https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/functions/v1_0_0/libraries/FunctionsRequest.sol). You can read the API references: [FunctionsClient](/chainlink-functions/api-reference/functions-client) and [FunctionsRequest](/chainlink-functions/api-reference/functions-request).
+- To write a Chainlink Functions consumer contract, your contract must import [FunctionsClient.sol](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/functions/v1_0_0/FunctionsClient.sol) and [FunctionsRequest.sol](https://github.com/smartcontractkit/chainlink/blob/develop/contracts/src/v0.8/functions/v1_0_0/libraries/FunctionsRequest.sol). You can read the API references: [FunctionsClient](/chainlink-functions/api-reference/functions-client) and [FunctionsRequest](/chainlink-functions/api-reference/functions-request).
 
   These contracts are available in an NPM package, so you can import them from within your project.
 
diff --git a/src/scripts/link-check/ignoredfiles-external.txt b/src/scripts/link-check/ignoredfiles-external.txt
index 3b56b4a8662..8bf77f36900 100644
--- a/src/scripts/link-check/ignoredfiles-external.txt
+++ b/src/scripts/link-check/ignoredfiles-external.txt
@@ -20,4 +20,14 @@ https://support.metamask.io/hc/en-us/articles/360015489331-How-to-import-an-acco
 https://support.metamask.io/hc/en-us/articles/360022895972
 https://support.metamask.io/hc/en-us/articles/360043227612-How-to-add-a-custom-network-RPC#h_01G63GGJ83DGDRCS2ZWXM37CV5
 https://help.phantom.app/hc/en-us/articles/4406527601811-How-to-migrate-from-Sollet
-https://github.com/smartcontractkit/chainlink/issues?q=is%3Aissue+label%3A%22good+first+issue%22
\ No newline at end of file
+https://github.com/smartcontractkit/chainlink/issues?q=is%3Aissue+label%3A%22good+first+issue%22
+https://solscan.io/
+https://www.covalenthq.com/
+https://sepolia.dev
+https://sepolia.dev/
+
+# Others
+https://api.testnet-dataengine.chain.link/
+https://api.dataengine.chain.link
+wss://ws.testnet-dataengine.chain.link/
+wss://ws.dataengine.chain.link
\ No newline at end of file