Merge branch 'master' into 2093-epic-chain-deployed-ui-project-docume…

…ntation

docs/1.concepts/3.advanced/indexers.md

@@ -88,4 +88,4 @@ We hope this article gives you an understanding of the Indexer concept. Also, we
 ## What's next?
 We encourage you to learn more about the [Lake Indexer project](/build/data-infrastructure/lake-framework/near-lake). Please, proceed to [Tutorials](/build/data-infrastructure/lake-framework/near-lake-state-changes-indexer) section to learn how to build an indexer on practice.
 
-Alternatively, there are a few other third-party indexers that are tightly integrated with the NEAR ecosystem. You can review all of your data sourcing options (including The Graph, Pagoda, Pipespeak, and SubQuery) under [data tools](/concepts/data-flow/data-storage#data-tools).
+Alternatively, there are a few other third-party indexers that are tightly integrated with the NEAR ecosystem. You can review all of your data sourcing options (including The Graph, Pagoda, Pikespeak, and SubQuery) under [data tools](/concepts/data-flow/data-storage#data-tools).

docs/1.concepts/abstraction/chain-signatures.md

@@ -12,10 +12,6 @@ This unlocks the next level of blockchain interoperability by giving ownership o
 ![chain-signatures](/docs/assets/welcome-pages/chain-signatures-overview.png)
 _Diagram of a chain signature in NEAR_
 
-:::caution
-This technology is currently in `alpha` and should only be used in a `testnet` environment.
-:::
-
 ---
 
 ## How It Works
@@ -72,10 +68,10 @@ The essence of Multi-Party Computation (MPC) is to enable independent parties to
 
 NEAR's MPC service is comprised of several independent nodes, **none of which can sign by itself**, but instead create **signature-shares** that are **aggregated through multiple rounds** to **jointly** sign a transaction.
 
-This service continuously listens for signature requests (i.e. users calling the `sign` method on the `multichain` smart contract) and when a call is detected the MPC service:
+This service continuously listens for signature requests (i.e. users calling the `sign` method on the `v1.signer` smart contract) and when a call is detected the MPC service:
 
   1. Asks its nodes to jointly derive a signature for the `payload` using the account identified by the `path`
-  2. Once complete, call the `multichain` contract to store the resulting `Signature`
+  2. Once complete, call the `v1.signer` contract to store the resulting `Signature`
 
 :::info A Custom MPC Service
 Generally, MPC signing services work by sharing a master key, which needs to be re-created each time a node joins or leaves.

docs/1.concepts/web3/blockchain.md

@@ -153,7 +153,7 @@ There are a lot of blockchains out there and it might be hard to choose the most
 
 Historically, the first blockchain to introduce smart contracts was Ethereum. However, as the number of users grew, transaction speed and cost skyrocketed, and it became apparent that it couldn't handle the demand. So, a number of [scaling solutions](https://ethereum.org/en/developers/docs/scaling/) appeared - [layer 2 chains](https://ethereum.org/en/developers/docs/scaling/#layer-2-scaling), [sidechains](https://ethereum.org/en/developers/docs/scaling/sidechains/), and [plasma chains](https://ethereum.org/en/developers/docs/scaling/plasma/). However, they all use some kind of workarounds with their own unique drawbacks. Ethereum tries to fix the core problem and redesign its network - like switching to a Proof-of-stake consensus, which is ongoing for quite a long time, but exact timeline when all of the problems will be fixed is very unclear.
 
-Meanwhile, a new generation of blockchains started to appear. They learned from the Etherium mistakes, and designed them from ground-up to be fast, cheap and scalable. 
+Meanwhile, a new generation of blockchains started to appear. They learned from the Ethereum mistakes, and designed them from ground-up to be fast, cheap and scalable. 
 Choosing the right one is by no means an easy task, but for us we found the [NEAR](https://near.org/) blockchain to be an ideal solution, because of the following properties:
 - Transactions are cheap and very fast.
 - Designed to be extremely scalable from the beginning. This means we can count that transaction cost and speed will remain stable in the future.

docs/1.concepts/web3/near.md

@@ -148,7 +148,7 @@ As an alternative to building your own indexer with a database and an API server
 
 By now, we should be familiar with necessary concepts to start developing WEB 3.0 applications, so let’s explore the development tools available.
 
-First of all, we need a development and testing environment. Of course, we could theoraticaly perform development and testing on the main blockchain network, but this would not be cheap. For this reason, NEAR provides [several networks](../../1.concepts/basics/networks.md) that can be used during development:
+First of all, we need a development and testing environment. Of course, we could theoretically perform development and testing on the main blockchain network, but this would not be cheap. For this reason, NEAR provides [several networks](../../1.concepts/basics/networks.md) that can be used during development:
 - testnet - public NEAR network which is identical to mainnet and can be used for free.
 - localnet - you can deploy your personal NEAR network on your own environment. Because it’s owned by you, data and code can be kept private during development. More info on how you can run your own node can be [found here](https://near-nodes.io/validator/running-a-node). Alternatively, you can bootstrap an entire testing infrastructure in Docker on your local machine using Kurtosis - [guide is here](../../2.build/2.smart-contracts/testing/kurtosis-localnet.md).
 - workspaces - you can start your own local network to perform e2e testing. More info [here](../../2.build/2.smart-contracts/testing/integration-test.md).

docs/1.concepts/web3/nfts.md

@@ -325,7 +325,7 @@ In the blockchain world, creation of new NFTs is usually called minting. And as
 
 
 
-* Users can mint them directly. This can be done by either allowing creation of NFTs from scratch, or by using more complex processes, like breeding or upgrading. The most famous example of such process is breeding in [CrytoKitties](https://www.cryptokitties.co/) game - new NFTs are created by combining existing ones. With this approach users usually have to pay to cover the storage and gas cost of NFTs creation.
+* Users can mint them directly. This can be done by either allowing creation of NFTs from scratch, or by using more complex processes, like breeding or upgrading. The most famous example of such process is breeding in [CryptoKitties](https://www.cryptokitties.co/) game - new NFTs are created by combining existing ones. With this approach users usually have to pay to cover the storage and gas cost of NFTs creation.
 * NFTs can be distributed by the developer to a set of users - it is usually called [NFTs airdrop](https://www.investopedia.com/terms/a/airdrop-cryptocurrency.asp). Most often this is used as a marketing strategy to kickstart NFTs usage in applications. Storage and gas costs in this case are covered by developers.
 * NFTs can be bought on a market or obtained from the lootbox. Depending on an exact strategy, costs can either be paid by a user or by developer. Also, in this case NFTs sometimes can be minted on-demand, to avoid paying upfront costs.
 
@@ -516,7 +516,7 @@ Implementing an own Marketplace contract is more involved since there is no stan
 * [Basic marketplace example](../../3.tutorials/nfts/8-marketplace.md)
 * [Paras ](https://paras.id/)marketplace contract - [source](https://github.com/ParasHQ/paras-marketplace-contract/tree/master/paras-marketplace-contract/src). 
 
-As for third-party solutions, the most complete one is [Mintibase](https://www.mintbase.io/), which provides a full suite of components for NFTs integration - including contracts, indexer, API and a web client:
+As for third-party solutions, the most complete one is [Mintbase](https://www.mintbase.io/), which provides a full suite of components for NFTs integration - including contracts, indexer, API and a web client:
 
 
 

docs/2.build/1.chain-abstraction/chain-signatures.md → docs/2.build/1.chain-abstraction/chain-signatures/chain-signatures.md

@@ -31,33 +31,37 @@ There are five steps to create a Chain Signature:
 
 1. [Deriving the Foreign Address](#1-deriving-the-foreign-address) - Construct the address that will be controlled on the target blockchain
 2. [Creating a Transaction](#2-creating-the-transaction) - Create the transaction or message to be signed
-3. [Requesting a Signature](#3-requesting-the-signature) - Call the NEAR `multichain` contract requesting it to sign the transaction
+3. [Requesting a Signature](#3-requesting-the-signature) - Call the NEAR `v1.signer` contract requesting it to sign the transaction
 4. [Reconstructing the Signature](#4-reconstructing-the-signature) - Reconstruct the signature from the MPC service's response
 5. [Relaying the Signed Transaction](#5-relaying-the-signature) - Send the signed transaction to the destination chain for execution
 
 ![chain-signatures](/docs/assets/welcome-pages/chain-signatures-overview.png)
 _Diagram of a chain signature in NEAR_
 
-:::info MPC testnet contracts
+:::info MPC Contracts
 
 If you want to try things out, these are the smart contracts available on `testnet`:
 
 - `v1.signer-prod.testnet`: [MPC signer](https://github.com/near/mpc/tree/v0.2.0/contract) contract, latest release, made up of 8 MPC nodes
-- `canhazgas.testnet`: [Multichain Gas Station](multichain-gas-relayer/gas-station.md) contract
-- `nft.kagi.testnet`: [NFT Chain Key](nft-keys.md) contract
+- `canhazgas.testnet`: [Multichain Gas Station](../multichain-gas-relayer/gas-station.md) contract
 
 :::
 
+:::info MPC mainnet contracts
+
+- `v1.signer`: [MPC signer](https://github.com/near/mpc/tree/v0.2.0/contract) contract, latest release, made up of 8 MPC nodes
+- `canhazgas.near`: [Multichain Gas Station](../multichain-gas-relayer/gas-station.md) contract
+:::
+
 ---
 
 ## 1. Deriving the Foreign Address
 
-Chain Signatures use [`derivation paths`](../../1.concepts/abstraction/chain-signatures.md#one-account-multiple-chains) to represent accounts on the target blockchain. The external address to be controlled can be deterministically derived from:
+Chain Signatures use [`derivation paths`](../../../1.concepts/abstraction/chain-signatures.md#one-account-multiple-chains) to represent accounts on the target blockchain. The external address to be controlled can be deterministically derived from:
 
 - The NEAR address (e.g., `example.near`, `example.testnet`, etc.)
 - A derivation path (a string such as `ethereum-1`, `ethereum-2`, etc.)
-- The MPC service's public key
-  - `secp256k1:4NfTiv3UsGahebgTaHyD9vF8KYKMBnfd6kh94mK6xv8fGBiJB8TBtFMP5WWXz6B89Ac1fbpzPwAvoyQebemHFwx3`
+- The MPC service's public key (see the tip bellow for the MPC service public keys)
 
 We provide code to derive the address, as it's a complex process that involves multiple steps of hashing and encoding:
 
@@ -76,21 +80,22 @@ We provide code to derive the address, as it's a complex process that involves m
 
 </Tabs>
 
-:::info
+:::tip
 
-The same NEAR account and path will always produce the same address on the target blockchain.
+We recommend hardcoding the derivation paths in your application to ensure the signature request is made to the correct account
 
-- `example.near` + `ethereum-1` = `0x1b48b83a308ea4beb845db088180dc3389f8aa3b`
-- `example.near` + `ethereum-2` = `0x99c5d3025dc736541f2d97c3ef3c90de4d221315`
+- **v1.signer-prod.testnet** (testnet): `secp256k1:4NfTiv3UsGahebgTaHyD9vF8KYKMBnfd6kh94mK6xv8fGBiJB8TBtFMP5WWXz6B89Ac1fbpzPwAvoyQebemHFwx3`
+
+- **v1.signer** (mainnet): `secp256k1:3tFRbMqmoa6AAALMrEFAYCEoHcqKxeW38YptwowBVBtXK1vo36HDbUWuR6EZmoK4JcH6HDkNMGGqP1ouV7VZUWya`
 
 :::
 
-:::tip
+:::info
 
-We recommend hardcoding the derivation paths in your application to ensure the signature request is made to the correct account
+The same NEAR account and path will always produce the same address on the target blockchain.
 
-#### v1.signer-prod.testnet
-`secp256k1:4NfTiv3UsGahebgTaHyD9vF8KYKMBnfd6kh94mK6xv8fGBiJB8TBtFMP5WWXz6B89Ac1fbpzPwAvoyQebemHFwx3`
+- `example.near` + `ethereum-1` = `0x1b48b83a308ea4beb845db088180dc3389f8aa3b`
+- `example.near` + `ethereum-2` = `0x99c5d3025dc736541f2d97c3ef3c90de4d221315`
 
 :::
 

docs/2.build/1.chain-abstraction/chain-signatures/getting-started.md

@@ -0,0 +1,99 @@
+---
+id: getting-started
+title: Getting Started with Chain Signatures
+---
+
+Chain Signatures is a groundbreaking technology built on NEAR that enables all accounts, including smart contracts, to sign and execute transactions across multiple blockchains.  
+
+![img](https://pages.near.org/wp-content/uploads/2024/02/acct-abstraction-blog-1.png)
+
+This innovation leverages Multi-Party Computation (MPC) and a distributed network of node operators to create joint signatures from arbitrary payloads, allowing NEAR users to control external blockchain accounts.
+
+Chain Signatures enhances blockchain interoperability, giving ownership of diverse assets, cross-chain accounts, and data to a single NEAR account.
+
+---
+
+## How does it work?
+
+When a NEAR account - could be a user or a **smart contract** - wants to interact with a foreign blockchain, it just need to follow four simple steps.
+
+#### 1. Deriving Foreign Addresses
+
+Chain Signatures uses [derivation paths](../../../1.concepts/abstraction/chain-signatures.md#derivation-paths-one-account-multiple-chains) to represent accounts on foreign blockchains
+
+The NEAR account’s name and the derivation path are used to mathematically derive a unique address for the user on the foreign blockchain
+
+<details>
+
+<summary> Derivation Paths </summary>
+
+A NEAR account will always derive the same address on the foreign blockchain using the same derivation path
+
+Notice that, since the foreign address is derived from the NEAR account name, it is not possible for another NEAR account to control the same address
+
+</details>
+
+
+#### 2. Creating the Transaction
+
+The client constructs the foreign transaction to be signed, which varies depending on the target blockchain
+
+#### 3. Requesting the Signature
+
+A NEAR account or contract calls the sign method of the MPC smart contract ([v1.signer](https://nearblocks.io/address/v1.signer)) to sign the transaction and waits while our MPC service generates the signature
+
+#### 4. Relaying the Signature  
+
+Once the signature is ready, the client reconstructs the signed transaction using the signature and broadcasts it to the destination blockchain
+
+:::tip
+
+Using Chain Signatures, developers can build cross-chain DeFi applications with seamless user experiences, eliminating the need for traditional bridges. This process eliminates the need for traditional bridges and enables developers to build innovative cross-chain DeFi applications with seamless user experiences.
+
+:::
+
+---
+
+## Use Cases
+
+Chain Signatures can be used to build a wide range of applications that leverage blockchain interoperability. Here are some examples:
+
+1. **DeFi on Bitcoin (and other chain without smart contracts)**  
+   * Chain signatures allow NEAR smart contract to program assets on Bitcoin  
+   * Build lending, swaps, runes launchpads, passkey-based Bitcoin wallets, and more  
+2. **Chain agnostic applications**  
+   * Since chain signatures can sign transactions for all blockchains, developers can support every single chain with just one smart contract  
+   * Multichain DEXs, lending protocols, oracles, derivatives, and more  
+3. **Multichain account abstraction**   
+   * Users can control assets on all chains with just their NEAR account, and can utilize account abstraction features on any chain including passkeys, key rotation, etc  
+   * Using the multichain gas relayer, users can pay for gas fees on any chain using USDC  
+4. **Privacy**  
+   * Chain signatures can be used to encrypt and decrypt information in a programmatic way  
+   * This enables privacy applications, and even decrypting information based on ownership of assets/NFTs
+
+---
+
+## How to Get Started?
+
+1. **Familiarize Yourself with Chain Signatures:**  
+   * Understand the [basics of Chain Signatures](https://docs.near.org/concepts/abstraction/chain-signatures) and how they simplify blockchain interactions.  
+   * Review the technical [explainer](https://near.org/blog/unlocking-web3-usability-with-account-aggregation).  
+2. **Explore the Use Cases:**  
+   * Review [examples of use cases for Chain Signatures](https://pages.near.org/blog/unlocking-multichain-web3-with-near-chain-signatures/), such as Multichain DAO, Multichain NFT Minter, and Bitcoin Runes Airdrop.  
+3. **Access Resources and Documentation:**  
+   * Visit the [Chain Signatures documentation](https://docs.near.org/build/chain-abstraction/chain-signatures) for detailed technical information and code snippets.  
+   * Check out the [Linktree for Chain Signatures](https://linktr.ee/chainsignatures) for various resources, including demos and tutorials.  
+4. **Try the Demos:**  
+   * Use the [command-line-based demo](https://github.com/near-examples/chainsig-script) to derive accounts and send transactions on Bitcoin, Ethereum, Doge, and Ripple.  
+   * Check out the [web app demo](https://github.com/near-examples/near-multichain/tree/main).  
+5. **Engage with the Community:**  
+   * Join the [Chain Abstraction developers’ channel on Telegram](https://t.me/chain\_abstraction) to connect with other developers and get support.
+
+---
+
+## Where to Learn More?
+
+To dive deeper into Chain Signatures and its applications, you can explore the following resources:
+
+- **Technical Blogs and Deep Dives:** Read [high-level use cases](https://pages.near.org/blog/unlocking-multichain-web3-with-near-chain-signatures) and technical [explainer](https://near.org/blog/unlocking-web3-usability-with-account-aggregation) posts on the NEAR blog
+* **Community and Support:** Engage with the NEAR community on social media platforms like Twitter and participate in discussions to stay updated on the latest developments

docs/2.build/1.chain-abstraction/fastauth-sdk.md

@@ -75,7 +75,7 @@ service cloud.firestore {
 - Press the gear button next to "Project Overview", and go to "Project settings"
 - Under "Your apps", click on the `</>` button
 - Set the app nickname as `issuer-gcp` and hit "Register app"
-- You should see the code needed for initilization and authentication of Firestore, such as:
+- You should see the code needed for initialization and authentication of Firestore, such as:
 ```js
 // Import the functions you need from the SDKs you need
 import { initializeApp } from "firebase/app";
@@ -253,7 +253,7 @@ const onCLick = () => selector.then((selector: any) => selector.wallet('fast-aut
         }),);
 ```
 
-Wehenever the user tries to login, call `onClick`.
+Whenever the user tries to login, call `onClick`.
 
 ### Getting added to the MPC recovery service
 

docs/2.build/1.chain-abstraction/meta-transactions.md

@@ -86,7 +86,7 @@ In this method we are creating an arbitrary smart contract call, instantiating a
 
 As mentioned in the above note in order to be able to relay on the client side it's necessary to have access to signing transactions directly on the client. Luckily leveraging the near biometric library it's possible to do so in a non custodial way.
 
-By calling this method and passing in the URL for the account creation endpoint (mentioned in the server section) as well as the `accoundId` everything is handled under the hood to successfully create an account.
+By calling this method and passing in the URL for the account creation endpoint (mentioned in the server section) as well as the `accountId` everything is handled under the hood to successfully create an account.
 
 <Github language='typescript' url='https://github.com/SurgeCode/near-relay/blob/main/example/src/app/page.tsx' start='17' end='23'/>
 

docs/2.build/1.chain-abstraction/multichain-gas-relayer/gas-station.md

@@ -119,7 +119,7 @@ Users who wish to get transactions signed and relayed by this contract and its a
 
 If you want to try things out, this smart contract is available on:
 - testnet: `canhazgas.testnet`
-- mainnet: `TBD`
+- mainnet: `canhazgas.near`
 
 :::