diff --git a/SUMMARY.md b/SUMMARY.md
new file mode 100644
index 0000000..d7f6e39
--- /dev/null
+++ b/SUMMARY.md
@@ -0,0 +1,115 @@
+# Table of contents
+
+* [Request Network Docs](README.md)
+
+## Request Network API
+
+* [Create and Pay Requests](request-network-api/create-and-pay-requests.md)
+* [Crosschain Payments](request-network-api/crosschain-payments.md)
+* [EasyInvoice: API Demo App](request-network-api/easyinvoice-api-demo-app.md)
+* [API Portal: Manage API Keys and Webhooks](request-network-api/api-portal-manage-api-keys-and-webhooks/README.md)
+ * [Manage API Keys and Webhooks programmatically](request-network-api/api-portal-manage-api-keys-and-webhooks/manage-api-keys-and-webhooks-programmatically.md)
+* [Full API Reference](https://api.request.network/open-api)
+
+## General
+
+* [Lifecycle of a Request](general/lifecycle-of-a-request.md)
+* [Request Scan](general/request-scan.md)
+* [Supported Chains](general/supported-chains/README.md)
+ * [Smart Contract Addresses](general/supported-chains/smart-contract-addresses.md)
+* [Request Network Token List](general/request-network-token-list.md)
+
+## Advanced
+
+* [Request Network SDK](advanced/request-network-sdk/README.md)
+ * [Get Started](advanced/request-network-sdk/get-started/README.md)
+ * [Quickstart - Browser](advanced/request-network-sdk/get-started/quickstart-browser.md)
+ * [Quickstart - Node.js](advanced/request-network-sdk/get-started/quickstart-node.js.md)
+ * [Installation](advanced/request-network-sdk/get-started/installation.md)
+ * [SDK Injector](advanced/request-network-sdk/get-started/sdk-injector.md)
+ * [Request Node Gateways](advanced/request-network-sdk/get-started/request-node-gateways.md)
+ * [SDK Demo Apps](advanced/request-network-sdk/sdk-demo-apps/README.md)
+ * [Request Invoicing](advanced/request-network-sdk/sdk-demo-apps/request-invoicing/README.md)
+ * [Pay from Safe Multisig](advanced/request-network-sdk/sdk-demo-apps/request-invoicing/pay-from-safe-multisig.md)
+ * [Request Checkout](advanced/request-network-sdk/sdk-demo-apps/request-checkout.md)
+ * [Components](advanced/request-network-sdk/sdk-demo-apps/components/README.md)
+ * [Create Invoice Form](advanced/request-network-sdk/sdk-demo-apps/components/create-invoice-form.md)
+ * [Invoice Dashboard](advanced/request-network-sdk/sdk-demo-apps/components/invoice-dashboard.md)
+ * [Payment Widget](advanced/request-network-sdk/sdk-demo-apps/components/payment-widget.md)
+ * [Add Stakeholder](advanced/request-network-sdk/sdk-demo-apps/components/add-stakeholder.md)
+ * [SDK Guides](advanced/request-network-sdk/sdk-guides/README.md)
+ * [Request Client](advanced/request-network-sdk/sdk-guides/request-client/README.md)
+ * [Configure the Request Client](advanced/request-network-sdk/sdk-guides/request-client/configure-the-request-client.md)
+ * [Updating a Request](advanced/request-network-sdk/sdk-guides/request-client/updating-a-request.md)
+ * [Payment Reference](advanced/request-network-sdk/sdk-guides/request-client/payment-reference.md)
+ * [Compute a Request ID without creating the request](advanced/request-network-sdk/sdk-guides/request-client/retrieve-a-request.md)
+ * [Use your own signature mechanism](advanced/request-network-sdk/sdk-guides/request-client/use-your-own-signature-mechanism.md)
+ * [Support a new currency](advanced/request-network-sdk/sdk-guides/request-client/support-a-new-currency.md)
+ * [In-Memory Requests](advanced/request-network-sdk/sdk-guides/request-client/in-memory-requests.md)
+ * [Encryption and Decryption](advanced/request-network-sdk/sdk-guides/encryption-and-decryption/README.md)
+ * [Encrypt with a wallet signature using Lit Protocol](advanced/request-network-sdk/sdk-guides/encryption-and-decryption/handle-encryption-with-a-web3-wallet.md)
+ * [Encrypt with an Ethereum private key](advanced/request-network-sdk/sdk-guides/encryption-and-decryption/handling-encryption-with-the-js-library.md)
+ * [Share an encrypted request](advanced/request-network-sdk/sdk-guides/encryption-and-decryption/share-an-encrypted-request.md)
+ * [Payment](advanced/request-network-sdk/sdk-guides/payment/README.md)
+ * [Detect a payment](advanced/request-network-sdk/sdk-guides/payment/detect-a-payment.md)
+ * [Native Payment](advanced/request-network-sdk/sdk-guides/payment/native-payment.md)
+ * [Conversion Payment](advanced/request-network-sdk/sdk-guides/payment/conversion-request.md)
+ * [Declarative Payment](advanced/request-network-sdk/sdk-guides/payment/declarative-request.md)
+ * [Configuring Payment Fees](advanced/request-network-sdk/sdk-guides/payment/configuring-payment-fees.md)
+ * [Single Request Forwarder](advanced/request-network-sdk/sdk-guides/payment/single-request-forwarder.md)
+ * [Batch Payment](advanced/request-network-sdk/sdk-guides/payment/batch-payment.md)
+ * [Swap-to-Pay Payment](advanced/request-network-sdk/sdk-guides/payment/swap-to-pay-request.md)
+ * [Swap-to-Conversion Payment](advanced/request-network-sdk/sdk-guides/payment/swap-to-conversion-request.md)
+ * [Transferable Receivable Payment](advanced/request-network-sdk/sdk-guides/payment/transferable-receivable-payment.md)
+ * [Meta Payments](advanced/request-network-sdk/sdk-guides/payment/meta-payments.md)
+ * [Escrow Payment](advanced/request-network-sdk/sdk-guides/payment/escrow-request.md)
+ * [Streaming Payment](advanced/request-network-sdk/sdk-guides/payment/streaming-request.md)
+ * [Pay through a proxy-contract with a multisig](advanced/request-network-sdk/sdk-guides/payment/pay-through-a-proxy-contract-with-a-multisig.md)
+ * [Hinkal Private Payments](advanced/request-network-sdk/sdk-guides/payment/hinkal-private-payments.md)
+ * [Mobile using Expo](advanced/request-network-sdk/sdk-guides/mobile-using-expo.md)
+ * [SDK Reference](advanced/request-network-sdk/sdk-api-reference/README.md)
+ * [request-client.js](advanced/request-network-sdk/sdk-api-reference/request-client.js/README.md)
+ * [RequestNetwork](advanced/request-network-sdk/sdk-api-reference/request-client.js/requestnetwork/README.md)
+ * [createRequest()](advanced/request-network-sdk/sdk-api-reference/request-client.js/requestnetwork/createrequest.md)
+ * [computeRequestId()](advanced/request-network-sdk/sdk-api-reference/request-client.js/requestnetwork/computerequestid.md)
+ * [fromRequestId()](advanced/request-network-sdk/sdk-api-reference/request-client.js/requestnetwork/fromrequestid.md)
+ * [fromIdentity()](advanced/request-network-sdk/sdk-api-reference/request-client.js/requestnetwork/fromidentity.md)
+ * [fromTopic()](advanced/request-network-sdk/sdk-api-reference/request-client.js/requestnetwork/fromtopic.md)
+ * [Request](advanced/request-network-sdk/sdk-api-reference/request-client.js/request/README.md)
+ * [waitForConfirmation()](advanced/request-network-sdk/sdk-api-reference/request-client.js/request/waitforconfirmation.md)
+ * [getData()](advanced/request-network-sdk/sdk-api-reference/request-client.js/request/getdata.md)
+ * [refresh()](advanced/request-network-sdk/sdk-api-reference/request-client.js/request/refresh.md)
+ * [cancel()](advanced/request-network-sdk/sdk-api-reference/request-client.js/request/cancel.md)
+ * [accept()](advanced/request-network-sdk/sdk-api-reference/request-client.js/request/accept.md)
+ * [increaseExpectedAmountRequest()](advanced/request-network-sdk/sdk-api-reference/request-client.js/request/increaseexpectedamountrequest.md)
+ * [reduceExpectedAmountRequest()](advanced/request-network-sdk/sdk-api-reference/request-client.js/request/reduceexpectedamountrequest.md)
+ * [IIdentity](advanced/request-network-sdk/sdk-api-reference/request-client.js/iidentity.md)
+ * [IRequestDataWithEvents](advanced/request-network-sdk/sdk-api-reference/request-client.js/irequestdatawithevents.md)
+ * [PaymentReferenceCalculator](advanced/request-network-sdk/sdk-api-reference/request-client.js/paymentreferencecalculator.md)
+ * [payment-processor](advanced/request-network-sdk/sdk-api-reference/payment-processor/README.md)
+ * [payRequest()](advanced/request-network-sdk/sdk-api-reference/payment-processor/payrequest.md)
+ * [web3-signature](advanced/request-network-sdk/sdk-api-reference/web3-signature/README.md)
+ * [Web3SignatureProvider](advanced/request-network-sdk/sdk-api-reference/web3-signature/web3signatureprovider.md)
+ * [epk-signature](advanced/request-network-sdk/sdk-api-reference/epk-signature/README.md)
+ * [EthereumPrivateKeySignatureProvider](advanced/request-network-sdk/sdk-api-reference/epk-signature/ethereumprivatekeysignatureprovider.md)
+ * [epk-decryption](advanced/request-network-sdk/sdk-api-reference/epk-decryption/README.md)
+ * [EthereumPrivateKeyDecryptionProvider](advanced/request-network-sdk/sdk-api-reference/epk-decryption/ethereumprivatekeydecryptionprovider.md)
+* [Protocol Overview](advanced/protocol-overview/README.md)
+ * [SDK and Request Node Overview](advanced/protocol-overview/request-client-and-request-node.md)
+ * [Payment Networks](advanced/protocol-overview/how-payment-networks-work.md)
+ * [Private Requests using Encryption](advanced/protocol-overview/private-requests-using-encryption.md)
+ * [Smart Contracts Overview](advanced/protocol-overview/contracts.md)
+* [Internal SDK Architecture](advanced/introduction-to-the-request-protocol/README.md)
+ * [Request Logic](advanced/introduction-to-the-request-protocol/request-logic.md)
+ * [Advanced Logic](advanced/introduction-to-the-request-protocol/advanced-logic.md)
+ * [Transaction](advanced/introduction-to-the-request-protocol/transaction.md)
+ * [Data-access](advanced/introduction-to-the-request-protocol/data-access.md)
+ * [Storage](advanced/introduction-to-the-request-protocol/storage.md)
+ * [Data flow](advanced/introduction-to-the-request-protocol/data-flow.md)
+ * [Request IPFS network](advanced/introduction-to-the-request-protocol/request-ipfs-network.md)
+
+***
+
+* [FAQ](faq.md)
+* [Glossary](glossary.md)
+* [Contributing](https://github.com/RequestNetwork/requestNetwork/blob/master/CONTRIBUTING.md)
diff --git a/advanced/introduction-to-the-request-protocol/README.md b/advanced/introduction-to-the-request-protocol/README.md
new file mode 100644
index 0000000..4a6548f
--- /dev/null
+++ b/advanced/introduction-to-the-request-protocol/README.md
@@ -0,0 +1,30 @@
+# Internal SDK Architecture
+
+Request is an open database for any type of payment request - from business invoices to reimbursements between friends. It aims to support products at any scale from startups to large organizations, from the private to the public sector.
+
+The Request Protocol is the core of Request. It's the bottom layer that defines and handles the data of a request and persists it to a distributed ledger to make Request open, trustless, secure, and resilient.
+
+This section is aimed at helping you understand how the protocol is structured, how it works and meets its requirements. It is particularly useful if you want to propose changes or implement them yourself.
+
+## Overview
+
+The Request Protocol has one fundamental purpose: **to persist, on a distributed ledger, data representing requests and to be able to retrieve these data efficiently**.
+
+To achieve this, the Request Protocol follows the layered architecture pattern. Each layer is responsible for a specific task and a specific level of abstraction. This layered architecture is highly extensible and hopefully easy to understand.
+
+The protocol is composed of four layers:
+
+* Request logic
+* Transaction
+* Data Access
+* Storage
+
+
Layers of the Request Protocol, each layer is described in the next section.
+
+This layered architecture allows package reusability and makes the protocol more upgradeable. For example, our current implementation uses Ethereum and IPFS. Still, suppose Arweave turns out to be a better solution for storing data in a decentralized database than IPFS. In that case, we can create a new storage layer that uses Arweave and make the data-access layer using this new package instead.
+
+### Interface vs implementation
+
+The protocol follows a defined interface; each layer has to implement a specific interface. The interfaces for each layer can be found in the Types package of Request Network repository: [https://github.com/RequestNetwork/requestNetwork/tree/master/packages/types](https://github.com/RequestNetwork/requestNetwork/tree/master/packages/types).
+
+The following pages present the first implementation of the protocol used for the released version of Request V2 on mainnet.
diff --git a/advanced/introduction-to-the-request-protocol/advanced-logic.md b/advanced/introduction-to-the-request-protocol/advanced-logic.md
new file mode 100644
index 0000000..7a26fac
--- /dev/null
+++ b/advanced/introduction-to-the-request-protocol/advanced-logic.md
@@ -0,0 +1,11 @@
+# Advanced Logic
+
+Simplicity is one of the most important characteristics we want to achieve in the Protocol. This is why the actions available in Request Logic are the minimal set of actions needed for any kind of request for payment. In the same way, the basic request state is universally common to any request, every request has a payee (a recipient), a currency (what requested), an expected amount (how much requested) and a basic state (accepted, canceled). To enable more advanced features for the users, we conceived Advanced Logic.
+
+Advanced Logic is a package that allows the user to define extensions that can be added to the request. An extension is an isolated context inside the request that contains his actions and his state. For example, the extension `content-data` allows the user to add metadata to a request (e.g. the additional data needed for an invoice). The Advanced Logic layer is also where the payment networks allowing payment detection are implemented.
+
+Similar to Request Logic, a specific extension can define different actions related to it. There is the Create action of the extension and, eventually different update actions. The extension is initialized at the same time as the request, and any action of the Request Logic can add extension data. There is a specific action, `AddExtensionData`, in Request Logic, only intended to add extension data to the request with no other side-effect.
+
+
Example of a request with extension data: the payee creates a request with content data and declarative payment information, the payer accepts the request and declares a sent payment in the same time, and finally, the payee declares the received payment
+
+The specification for each extension can be found at this link: [https://github.com/RequestNetwork/requestNetwork/tree/master/packages/advanced-logic/specs](https://github.com/RequestNetwork/requestNetwork/tree/master/packages/advanced-logic/specs)
diff --git a/advanced/introduction-to-the-request-protocol/data-access.md b/advanced/introduction-to-the-request-protocol/data-access.md
new file mode 100644
index 0000000..3ec9c52
--- /dev/null
+++ b/advanced/introduction-to-the-request-protocol/data-access.md
@@ -0,0 +1,25 @@
+# Data-access
+
+Data-Access is the layer that organizes the data in the correct format before having them stored in the storage layer. This layer is similar as the persistence layer in the classical layered architecture pattern.
+
+[https://github.com/RequestNetwork/requestNetwork/tree/master/packages/data-access](https://github.com/RequestNetwork/requestNetwork/tree/master/packages/data-access)
+
+#### Blocks
+
+Heavy communication with the Storage layer can be costly. For example, for a solution using Ethereum, every Ethereum transactions cost some gas.
+
+Data-Access layer will gather transactions and batch them into blocks. This solution allows for less communication with the Storage layer. In this case, it will allow consuming less gas for Ethereum transactions.
+
+#### Local cache for accessing transaction
+
+Data-Access is also responsible for other side tasks:
+
+* Indexing transactions to allow retrieval
+* Accessing transactions through a local cache
+* Synchronizing with the storage
+
+The storage phase is only complete when indexing has completed. Because this indexing is an Ethereum transaction, you cannot know how long it will take.
+
+It is because when a block is created or read from the storage, the transactions inside it will be indexed and kept in a local cache. When a user wants to get information about a request, Data-Access will directly fetch them from this local cache.
+
+Data-Access stays synchronized with the storage layer. For example, it pulls for new blocks, added by other users, in the storage every 10 seconds.
diff --git a/advanced/introduction-to-the-request-protocol/data-flow.md b/advanced/introduction-to-the-request-protocol/data-flow.md
new file mode 100644
index 0000000..37cb346
--- /dev/null
+++ b/advanced/introduction-to-the-request-protocol/data-flow.md
@@ -0,0 +1,59 @@
+# Data flow
+
+This page presents the flow of data that occurs when some actions are performed in the protocol.
+
+### Creating and updating requests
+
+The next schemas show the data flow that happens when a user performs an `accept` action on a request.
+
+#### Request Logic
+
+
Request Logic flow
+
+
Request Logic flow with extension data
+
+#### Transaction
+
+
Transaction flow without encryption
+
+
Transaction flow with encryption with two stakeholders
+
+#### Data-access
+
+
Data-access flow. In this example, several transactions are batched into the block. This feature is not yet implemented.
+
+#### Storage
+
+
A new block is added to the storage
+
+### Reading requests
+
+The next schemas show the data flow when the user wants to read the content of a request.
+
+In this case, the user calls this function of Request Logic: `getRequestFromId(0xaaa)` that reads the request with the request id: 0xaaa
+
+#### Storage
+
+There is a permanent data flow between Data Access and Storage layers.
+
+For performance purposes, Data Access will periodically synchronize with the current state of Storage. When a new, not synchronized block is detected, the block content will be dispatched into the Data Access cache.
+
+
Flow for Data Access synchronization
+
+#### Data-access
+
+
Flow from Data-Access. When a user wants to read a request, Data-Access will read its cache without any communication with the storage layer
+
+#### Transaction
+
+
Flow from Transaction layer. If the request is encrypted, the transactions are decrypted in this layer
+
+#### Request Logic
+
+
Request Logic flow. Request Logic will compute the state of the request based on the list of actions. In this case, the increaseExpectedAmount action has been signed by the payer
+
+Some actions from the Transaction layer can be invalid; this is the role of Request Logic to filter them to give the consistent state of the request to the user.
+
+For example, only the payer of the request can increase the expected amount of it. If the action `increaseExpectedAmount` is signed by the payee therefore, the action is ignored.
+
+
In this example, the increaseExpectedAmount is signed by the payee; therefore, invalid. The expectedAmount of the request keeps its initial value: 5
diff --git a/advanced/introduction-to-the-request-protocol/request-ipfs-network.md b/advanced/introduction-to-the-request-protocol/request-ipfs-network.md
new file mode 100644
index 0000000..807551e
--- /dev/null
+++ b/advanced/introduction-to-the-request-protocol/request-ipfs-network.md
@@ -0,0 +1,78 @@
+# Request IPFS network
+
+### Why Request uses IPFS?
+
+Request uses IPFS to store transaction data in a decentralized way. Transactions are actions done on a request, for example: create, accept, reject...
+
+When files are stored in IPFS, they are kept locally on the IPFS node, and are accessible by any node connected to the network. IPFS creates a unique hash used as an identifier to access a file. We store this hash on the Request smart contract to have a trustless list of transactions.
+
+### Why Request uses a dedicated IPFS network?
+
+The main IPFS network has tens of thousands of nodes and many files. All of the Request transactions are a tiny fraction of the IPFS network. To find a transaction file, the Request Node IPFS has to [traverse many nodes](https://medium.com/textileio/how-the-ipfs-dht-works-47af8bfd3c6a) on the network. Content retrieval is currently relatively slow on IPFS.
+
+By creating a dedicated IPFS network for Request, our network is isolated from the rest of the IPFS network. All the Request IPFS nodes will only communicate with other Request Nodes. By keeping the network small, we can make sure most nodes are connected between themselves, and asking for files can be done directly to a node instead of through a traversal.
+
+This is a big advantage for us because our nodes' end goal is different from that of a normal IPFS node: all the IPFS nodes used by a Request Node should have all the files on the network. This makes the DHT pointless, and the most critical factor in discovery time becomes how many nodes every node is connected to.
+
+These are the main reason why we created the Request IPFS network.
+
+### The Request IPFS Network
+
+IPFS has a feature called **private network**. It allows IPFS nodes that share a private key to communicate only among themselves and keep their files private from the open IPFS network. We use this feature to create an IPFS network separate from the open one, but we keep this key public. This way, we have a separate public network from the open network.
+
+We also changed some default IPFS configurations on our network, to improve performance and responsiveness. The main change we did is disabling the DHT, so instead of traversing the network to find a file, the nodes will only ask to their neighbor nodes for those files. Since on our network every node is supposed to have every transaction file, those responses tend to be a lot faster (on most of our test cases the response time went from seconds to a few hundred milliseconds).
+
+### Run our IPFS node Docker image
+
+We distribute a Docker image of our configured IPFS node. To run it, you can use the command:
+
+```bash
+docker run -p 5001:5001 -p 4001:4001 requestnetwork/request-ipfs
+```
+
+#### Configure your IPFS node to use the Request IPFS network
+
+There are two easy ways to connect an IPFS node to the Request Network:
+
+* Use the [requestnetwork/request-ipfs](https://hub.docker.com/r/requestnetwork/request-ipfs) docker image to run your IPFS. It comes pre-configured and you just need to run it.
+* [Use the `init-ipfs`](https://github.com/RequestNetwork/requestNetwork-private/blob/development/packages/ethereum-storage/scripts/init-ipfs.js) script available from the [Request Node package](https://github.com/RequestNetwork/requestNetwork-private/tree/development/packages/request-node) or the [Ethereum Storage package](https://github.com/RequestNetwork/requestNetwork-private/tree/development/packages/ethereum-storage).
+
+```bash
+yarn init-ipfs
+```
+
+#### Setting up your IFPS by hand
+
+If you want to set up your IPFS node yourself, here is the information you would need:
+
+**The swarm key**
+
+you should put this file at your IPFS path (usually in $IPFS\_PATH)
+
+**swarm.key** file content:
+
+```
+/key/swarm/psk/1.0.0/
+/base16/
+5f3af0599d991e5eb4c37da2472aa299759ee3350ba26c125d0c7579dd04dd52
+```
+
+**The configurations**
+
+```bash
+# Initialize IPFS
+ipfs init
+
+# Setup the Request IPFS Network bootstraps
+ipfs bootstrap rm --all
+ipfs bootstrap add /dns4/ipfs-bootstrap.request.network/tcp/4001/ipfs/QmaSrBXFBaupfeGMTuigswtKtsthbVaSonurjTV967Fdxx
+ipfs bootstrap add /dns4/ipfs-bootstrap-2.request.network/tcp/4001/ipfs/QmYdcSoVNU1axgSnkRAyHtwsKiSvFHXeVvRonGCAV9LVEj
+ipfs bootstrap add /dns4/ipfs-2.request.network/tcp/4001/ipfs/QmPBPgTDVjveRu6KjGVMYixkCSgGtVyV8aUe6wGQeLZFVd
+ipfs bootstrap add /dns4/ipfs-survival.request.network/tcp/4001/ipfs/Qmb6a5DH45k8JwLdLVZUhRhv1rnANpsbXjtsH41esGhNCh
+
+# Disable the DHT
+ipfs config Routing.Type none
+
+# Environment variable to forbid IPFS to connect to the open IPFS network
+export LIBP2P_FORCE_PNET=1
+```
diff --git a/advanced/introduction-to-the-request-protocol/request-logic.md b/advanced/introduction-to-the-request-protocol/request-logic.md
new file mode 100644
index 0000000..ff4f4d5
--- /dev/null
+++ b/advanced/introduction-to-the-request-protocol/request-logic.md
@@ -0,0 +1,45 @@
+# Request Logic
+
+This layer is responsible for the business logic of Request. This is where we define the data structure of a request.
+
+This layer has three responsibilities:
+
+* It defines the properties of the requests and the actions performed on them.
+* It's responsible for the signature of the actions performed to ensure the request stakeholder identities.
+* It manages extensions that can be created to extend the features of the Request Protocol through the Advanced Logic package.
+
+[https://github.com/RequestNetwork/requestNetwork/tree/master/packages/request-logic](https://github.com/RequestNetwork/requestNetwork/tree/master/packages/request-logic)
+
+#### Actions
+
+Actions are the essential elements that compose a request. From this layer's point of view, a request is simply a list of different actions.
+
+
Example of a request in Request Logic represented by a list of actions
+
+* The payee creates the request requesting 1 ETH to the payer
+* The payer accepts the request
+* The payer increases the expected amount of the request by 1 ETH (the expected amount of the request can only be increased by the payer and decreased by the payee)
+
+Given the list of these actions, we can interpret the state of the request. The example above describes a request that has been accepted by the payer where he will have to pay 2 ETH to the payee.
+
+Note that the hash of the action determines the request Id. Therefore, this action doesn't specify the request Id since it doesn't exist yet. The update actions (`accept` and `increaseExpectedAmount`) specify the request Id in their data.
+
+There are two kinds of action:
+
+* Create: This action is not related to an existing request, it will create a new one
+* Update: All other actions, it will update the state of an existing request
+
+#### Signature
+
+In addition to providing the structure to form an action composing a request, the request logic layer is also responsible for signing the action.
+
+To abstract the signing process from the layer (and eventually be able to use it in other packages), the signing process is done through external packages named signature providers.
+
+The protocol repository currently contains two signature provider packages:
+
+* [epk-signature](https://github.com/RequestNetwork/requestNetwork/tree/master/packages/epk-signature)
+* [web3-signature](https://github.com/RequestNetwork/requestNetwork/tree/master/packages/web3-signature)
+
+Both packages use the Elliptic Curve Digital Signature Algorithm (ECDSA) used in Ethereum. web3-signature will connect to Metamask to ask users to sign requests. epk-signature uses private keys that are stored in the clear and managed manually.
+
+The `web3-signature` provider should be used to create a fully-decentralized solution where the users manage their own private keys. The `epk-signature` provider is used to manage the private keys on behalf of the users. It's never a good idea to let users handle plain private keys.
diff --git a/advanced/introduction-to-the-request-protocol/storage.md b/advanced/introduction-to-the-request-protocol/storage.md
new file mode 100644
index 0000000..f5bccd0
--- /dev/null
+++ b/advanced/introduction-to-the-request-protocol/storage.md
@@ -0,0 +1,38 @@
+# Storage
+
+Storage defines where the data are stored. How to store these data and how to retrieve them.
+
+The currently used package, named `ethereum-storage`, uses IPFS to store the data immutably and uses the Ethereum network to persist the IPFS hash of the data and make them permanently available to everyone.
+
+[https://github.com/RequestNetwork/requestNetwork/tree/master/packages/ethereum-storage](https://github.com/RequestNetwork/requestNetwork/tree/master/packages/ethereum-storage)
+
+The storage of data implementation is:
+
+* Open: Anyone should be able to access the data (though it can be encrypted)
+* Decentralized: The database is trustless; we don’t have to refer to a third party to trust the data
+* Resilient: The database should always be available, nobody should be able to shutdown it alone
+
+#### IPFS
+
+The interplanetary file system (IPFS) is a decentralized network to store and share files: [https://ipfs.io](https://ipfs.io/)
+
+One of the advantages of IPFS as a storage solution is that it is content addressable. When a file is deleted, if someone reuploads the file, anybody will be able to access it with the same path. For a specific block of data, we will get a specific hash; the hash is persisted on Ethereum to ensure requests immutability.
+
+#### Ethereum
+
+We use Ethereum to store IPFS hashes. The hashes are stored as event logs of a specific smart contract to stay at a minimal cost.
+
+The Ethereum smart contracts are also used to enforce the fee cost of storing a block to Request. The user will store the file's size in addition to the hash. A fee related to this hash will be paid in Ether when storing the hash.
+
+For our solution, we use additional smart contracts for fee verification. Using external smart contracts allows us to implement different fee rules in the future. More information can be found in the ethereum-storage repository.
+
+The RequestHashStorage smart contract address can be found on [GitHub](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/RequestHashStorage/index.ts)
+
+```json
+ "xdai": {
+ "address": "0x2256938E8225a998C498bf86B43c1768EE14b90B"
+},
+"sepolia": {
+ "address": "0xd6c085A4D14e9e171f4aF58F7F48bd81173f167E"
+}
+```
diff --git a/advanced/introduction-to-the-request-protocol/transaction.md b/advanced/introduction-to-the-request-protocol/transaction.md
new file mode 100644
index 0000000..57650a2
--- /dev/null
+++ b/advanced/introduction-to-the-request-protocol/transaction.md
@@ -0,0 +1,28 @@
+# Transaction
+
+The transaction layer is responsible for converting actions into a channel of transactions and vice versa. It also optionally encrypts and decrypts those transactions such that only stakeholders of the request can read them.
+
+[https://github.com/RequestNetwork/requestNetwork/tree/master/packages/transaction-manager](https://github.com/RequestNetwork/requestNetwork/tree/master/packages/transaction-manager)
+
+#### Encryption
+
+Transactions can be stored in the clear, unencrypted, meaning that anyone can read the request. \
+\
+Transactions can also be encrypted, such that only stakeholders of the request can read them. Any number of stakeholders can be included in the creation of an encrypted request. Request uses an encryption scheme nearly identical to [HTTPS](https://www.freecodecamp.org/news/https-explained-with-carrier-pigeons-7029d2193351/). It uses a symmetric key (usually referred to as the "channel key") to encrypt and decrypt the transaction channel content, and asymmetric keys to encrypt and decrypt copies of the symmetric key.
+
+* A unique channel key that is shared with all the stakeholders
+* A set of public and private key pairs, each pair controlled by a single stakeholder
+
+The channel key uses Advanced Encryption Standard (AES), a symmetric encryption technology; this means the same key is used to encrypt and decrypt.
+
+The public and private key pairs use Elliptic Curve Integrated Encryption Scheme (ECIES), an asymmetric encryption technology where the public key encrypts and the private key decrypts.
+
+Every transaction of the same request is encrypted with the same channel key. The encrypted transactions form the channel (hence the name channel key).
+
+The channel key is encrypted with each stakeholder's public key. This way, every stakeholder can decrypt the channel key and in turn, decrypt the transactions in the channel.
+
+This design using both symmetric and asymmetric encryption allows the transaction data _once_ and only the channel key needs to be duplicated, once for each stakeholder.
+
+See the details of encrypted request creation in [handling-encryption-with-the-js-library.md](../request-network-sdk/sdk-guides/encryption-and-decryption/handling-encryption-with-the-js-library.md "mention")
+
+
+
+{% hint style="warning" %}
+This page is missing the RequestToken, DAIbasedREQBurner, lockForREQBurn, ChainlinkConversionPath contracts
+{% endhint %}
+
+## Contracts Overview
+
+Request Network smart contracts are available [here](https://github.com/RequestNetwork/requestNetwork/tree/master/packages/smart-contracts/src/contracts).
+
+## Contracts type
+
+There are three types of contracts
+
+* **Storage** - These store [Content Identifiers (CIDs)](https://docs.ipfs.tech/concepts/content-addressing/) for Requests stored in IPFS.
+* **Payments** - These process various payment types, also known as [Payment Networks](how-payment-networks-work.md), and are deployed across many [Supported Chains](../../general/supported-chains/).
+* **REQ Token and Burn Mechanism** - These lock, bridge, and burn REQ tokens each time a Request is stored.
+
+### Storage
+
+#### [RequestOpenHashSubmitter](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/RequestOpenHashSubmitter.sol)
+
+Declares data hashes and collects the fees.
+
+After a request has been sent to IPFS, the hash is declared to the whole request network system through the RequestHashStorage.
+
+Anyone can submit hashes.
+
+#### [StorageFeeCollector](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/StorageFeeCollector.sol)
+
+Manages the fees for the creation of a request.
+
+#### [RequestHashStorage](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/RequestHashStorage.sol)
+
+This contract is the entry point to retrieve all the hashes of the request network system.
+
+### Payments
+
+#### [ERC20FeeProxy](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20FeeProxy.sol)
+
+Performs an ERC20 token transfer with a payment reference and a transfer to a second address for the payment of a fee.
+
+#### [ERC20Proxy](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20Proxy.sol)
+
+Performs an ERC20 token transfer with a payment reference and a transfer to a second address.
+
+#### [EthereumFeeProxy](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumFeeProxy.sol)
+
+This contract performs an Ethereum transfer with a Fee sent to a third address and stores a reference.
+
+#### [EthereumProxy](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumProxy.sol)
+
+This contract performs an Ethereum transfer sent to a third address and stores a reference.
+
+#### [ERC20EscrowToPay](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20EscrowToPay.sol)
+
+This contract allows users to lock funds in an escrow and perform payments in ERC20. It contains a refund and emergency feature to unlock funds if needed.
+
+#### [BatchConversionPayments](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/BatchConversionPayments.sol)
+
+This contract makes multiple conversion payments with a payment references, in one transaction.
+
+#### [BatchNoConversionPayments](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/BatchNoConversionPayments.sol)
+
+This contract makes multiple payments with payment references, in one transaction.
+
+This contract makes multiple payments with references, in one transaction, without conversion.
+
+#### [ERC20SwapToPay](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToPay.sol)
+
+This contract swaps ERC20 tokens before paying a request such that the payer sends currency A, but payee receives currency B.
+
+{% hint style="info" %}
+**Swap-to-Pay is different from Conversion.** For details see [#difference-between-conversion-swap-to-pay-and-swap-to-conversion](how-payment-networks-work.md#difference-between-conversion-swap-to-pay-and-swap-to-conversion "mention")
+{% endhint %}
+
+#### [ERC20ConversionProxy](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/Erc20ConversionProxy.sol)
+
+This contract uses a chainlink price feed to pay a request denominated in one currency (usually a fiat currency like USD) but paid in an on-chain currency. This variant supports ERC20 payments.
+
+#### [ETHConversionProxy](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthConversionProxy.sol)
+
+This contract uses a chainlink price feed to pay a request denominated in one currency (usually a fiat currency like USD) but paid in an on-chain currency. This variant supports native currency payments.
+
+#### [ERC20SwapToConversion](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToConversion.sol)
+
+This contract combines "conversion" and "swap-to-pay". It executes an ERC20 swap before paying a request denominated in one currency (usually a fiat currency like USD) but paid in an on-chain currency. This variant supports ERC20 payments.
+
+#### [ERC20TransferableReceivable](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20TransferableReceivable.sol)
+
+This contract allows minting requests as NFTs thus allowing them to be transferred. The owner of the request NFT receives the payment.
+
+#### [**ERC20SingleRequestProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SingleRequestProxy.sol)
+
+A contract that allows payment through the [#erc20feeproxy](contracts.md#erc20feeproxy "mention") without having to make a function call.
+
+#### [**EthereumSingleRequestProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumSingleRequestProxy.sol)
+
+A contract that allows payment through [#ethereumfeeproxy](contracts.md#ethereumfeeproxy "mention") without having to make a function call.
+
+#### [**SingleRequestProxyFactory**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/SingleRequestProxyFactory.sol)
+
+A factory smart contract responsible for deploying [#erc20singlerequestproxy](contracts.md#erc20singlerequestproxy "mention") and [#ethereumsinglerequestproxy](contracts.md#ethereumsinglerequestproxy "mention") contracts.
diff --git a/advanced/protocol-overview/how-payment-networks-work.md b/advanced/protocol-overview/how-payment-networks-work.md
new file mode 100644
index 0000000..b085aea
--- /dev/null
+++ b/advanced/protocol-overview/how-payment-networks-work.md
@@ -0,0 +1,371 @@
+---
+description: Rules for how a payment should be processed and detected
+---
+
+# Payment Networks
+
+A payment network is a set of rules defining how a payment should be processed and detected for a Request. It specifies:
+
+1. Information required at request creation to enable payment detection
+2. The payment method
+3. The process for determining the balance (amount paid)
+
+## Reference-based Payment Networks (Recommended)
+
+Reference-based payment networks use a [payment reference](../request-network-sdk/sdk-guides/request-client/payment-reference.md) to link payments to the corresponding Request. They process payments via payment proxy smart contracts deployed across a wide variety of supported chains. These contracts serve two key functions:
+
+1. They forward the payment to the payment recipient's address.
+2. They emit an event containing the payment amount and the payment reference.
+
+The payment reference is a unique identifier derived from the Request ID and payment recipient address. This derivation happens off-chain, not in the smart contract itself.
+
+It's important to note that the payment recipient's address can be different from the payee's identity address that typically signs to create the request.
+
+The payment proxy smart contracts do not perform error checking. It is the responsibility of the application using the Request Network to craft the payment transaction with the correct amount and payment reference.
+
+A payment subgraph indexes events from the payment proxy smart contracts, enabling efficient payment detection and balance calculation for each request.
+
+Please note that Reference-based payment networks inherit from the declarative payment network. This means that all reference-based requests can also be paid using declarative payments, providing flexibility in payment methods.
+
+### ERC20 Fee Proxy Contract
+
+This payment network is used for direct ERC20 token payments.
+
+Example of creating a request with an ERC20 Fee Proxy Contract payment network:
+
+```typescript
+const erc20Request = await requestNetwork.createRequest({
+ paymentNetwork: {
+ id: Types.Extension.PAYMENT_NETWORK_ID.ERC20_FEE_PROXY_CONTRACT,
+ parameters: {
+ paymentNetworkName: 'sepolia',
+ paymentAddress: paymentRecipientAddress,
+ feeAddress: feeRecipient,
+ feeAmount: '0',
+ },
+ },
+ requestInfo: {
+ currency: {
+ type: RequestLogicTypes.CURRENCY.ERC20,
+ value: '0xdAC17F958D2ee523a2206206994597C13D831ec7', // USDT on Ethereum
+ network: 'mainnet'
+ },
+ expectedAmount: '1000000', // 1 USDT (6 decimals)
+ payee: payeeIdentity,
+ payer: payerIdentity,
+ },
+ signer: payeeIdentity,
+});
+```
+
+For details on how to use the ERC20 Fee Proxy, see the [quickstart-browser.md](../request-network-sdk/get-started/quickstart-browser.md "mention") or [quickstart-node.js.md](../request-network-sdk/get-started/quickstart-node.js.md "mention")
+
+### ETH Fee Proxy Contract ("Native Payment")
+
+This payment network is used for direct ETH (or native token) payments on Ethereum and EVM-compatible chains.
+
+Example of creating a request with an ETH Fee Proxy Contract payment network:
+
+```typescript
+const nativeRequest = await requestNetwork.createRequest({
+ paymentNetwork: {
+ id: Types.Extension.PAYMENT_NETWORK_ID.ETH_FEE_PROXY_CONTRACT,
+ parameters: {
+ paymentNetworkName: 'mainnet',
+ paymentAddress: paymentRecipientAddress,
+ feeAddress: feeRecipient,
+ feeAmount: '1000000000000000', // 0.001 ETH fee
+ },
+ },
+ requestInfo: {
+ currency: {
+ type: RequestLogicTypes.CURRENCY.ETH,
+ value: 'ETH',
+ network: 'mainnet'
+ },
+ expectedAmount: '1000000000000000000', // 1 ETH (18 decimals)
+ payee: payeeIdentity,
+ payer: payerIdentity,
+ },
+ signer: payeeIdentity,
+});
+```
+
+This payment network allows for native token payments with an optional fee mechanism. It's suitable for ETH payments on Ethereum mainnet, or native token payments on other EVM-compatible chains like Polygon's MATIC or Binance Smart Chain's BNB.
+
+For details on how to use the ETH Fee Proxy, see [native-payment.md](../request-network-sdk/sdk-guides/payment/native-payment.md "mention")
+
+### Any-to-ERC20 Proxy Contract "ERC20 Conversion Payments"
+
+This payment network allows for "ERC20 Conversion Payments", where the payment currency is an ERC20 token that is different from the request currency. This is most commonly used to denominate the request in fiat like USD but settle the payment in ERC20 tokens like USDC or USDT. This is useful for accounting because most people use fiat currency as their unit of account.
+
+Key features:
+
+* Supports payments in any ERC20 token for requests created in various currencies
+* Uses on-chain oracles for real-time currency conversion
+* Includes a fee mechanism similar to the ERC20 Fee Proxy Contract
+
+Example of creating a request with an Any-to-ERC20 Proxy Contract payment network:
+
+```typescript
+const erc20ConversionRequest = await requestNetwork.createRequest({
+ paymentNetwork: {
+ id: Types.Extension.PAYMENT_NETWORK_ID.ANY_TO_ERC20_PROXY,
+ parameters: {
+ paymentNetworkName: 'mainnet',
+ paymentAddress: paymentRecipientAddress,
+ feeAddress: feeRecipient,
+ feeAmount: '100', // Fee in request currency
+ acceptedTokens: ['0x6B175474E89094C44Da98b954EedeAC495271d0F'], // DAI address
+ maxRateTimespan: 1800, // 30 minutes
+ },
+ },
+ requestInfo: {
+ currency: {
+ type: RequestLogicTypes.CURRENCY.ISO4217,
+ value: 'USD'
+ },
+ expectedAmount: '1000000', // 1000.00 USD (2 decimals)
+ payee: payeeIdentity,
+ payer: payerIdentity,
+ },
+ signer: payeeIdentity,
+});
+```
+
+In this example, the request is created in USD, but can be paid using DAI (or any other specified ERC20 token). The conversion rate is determined at the time of payment using on-chain oracles.
+
+{% hint style="warning" %}
+**Conversion is different from Swap-to-Pay.** For details see [#difference-between-conversion-swap-to-pay-and-swap-to-conversion](how-payment-networks-work.md#difference-between-conversion-swap-to-pay-and-swap-to-conversion "mention")
+{% endhint %}
+
+For details on how to use the Any-to-ERC20 Conversion Proxy Contract, see [conversion-request.md](../request-network-sdk/sdk-guides/payment/conversion-request.md "mention")
+
+### Any-to-ETH Proxy Contract "Native Conversion Payments"
+
+This payment network allows for "Native Conversion Payments", where the payment currency is ETH (or native token) for requests denominated in other currencies, usually fiat. This is most commonly used to denominate the request in fiat like USD but settle the payment in native tokens like ETH on Ethereum or POL on Polygon PoS. This is useful for accounting because most people use fiat currency as their unit of account.
+
+Key features:
+
+* Supports payments in ETH (or native token) for requests created in various currencies
+* Uses on-chain oracles for real-time currency conversion
+* Includes a fee mechanism similar to the ETH Fee Proxy Contract
+
+Example of creating a request with an Any-to-ETH Proxy Contract payment network:
+
+```typescript
+const nativeConversionRequest = await requestNetwork.createRequest({
+ paymentNetwork: {
+ id: Types.Extension.PAYMENT_NETWORK_ID.ANY_TO_ETH_PROXY,
+ parameters: {
+ paymentNetworkName: 'mainnet',
+ paymentAddress: paymentRecipientAddress,
+ feeAddress: feeRecipient,
+ feeAmount: '100', // Fee in request currency
+ maxRateTimespan: 1800, // 30 minutes
+ },
+ },
+ requestInfo: {
+ currency: {
+ type: RequestLogicTypes.CURRENCY.ISO4217,
+ value: 'USD'
+ },
+ expectedAmount: '1000000', // 1000.00 USD (2 decimals)
+ payee: payeeIdentity,
+ payer: payerIdentity,
+ },
+ signer: payeeIdentity,
+});
+```
+
+In this example, the request is created in USD but can be paid using ETH. The conversion rate is determined at the time of payment using on-chain oracles.
+
+{% hint style="warning" %}
+**Conversion is different from Swap-to-Pay.** For details see [#difference-between-conversion-swap-to-pay-and-swap-to-conversion](how-payment-networks-work.md#difference-between-conversion-swap-to-pay-and-swap-to-conversion "mention")
+{% endhint %}
+
+For details on how to use the Any-to-ETH Proxy Contract, see [conversion-request.md](../request-network-sdk/sdk-guides/payment/conversion-request.md "mention")
+
+### ERC20 Transferable Receivable
+
+ERC20 Transferable Receivable allows requests to be minted as NFTs that can be transferred or sold. When the payment is processed, the owner of the NFT receives the payment.
+
+Example of creating an ERC20 Transferable Receivable request:
+
+```typescript
+const transferableRequest = await requestNetwork.createRequest({
+ paymentNetwork: {
+ id: Types.Extension.PAYMENT_NETWORK_ID.ERC20_TRANSFERABLE_RECEIVABLE,
+ parameters: {
+ paymentAddress: paymentRecipientAddress,
+ feeAddress: feeRecipient,
+ feeAmount: '0',
+ network: 'mainnet',
+ },
+ },
+ requestInfo: {
+ currency: {
+ type: RequestLogicTypes.CURRENCY.ERC20,
+ value: erc20TokenAddress,
+ network: 'mainnet'
+ },
+ expectedAmount: '1000000000000000000', // 1 token with 18 decimals
+ payee: payeeIdentity,
+ payer: payerIdentity,
+ },
+ signer: payeeIdentity,
+});
+```
+
+For details on how to use ERC20 Transferable Receivables, see [transferable-receivable-payment.md](../request-network-sdk/sdk-guides/payment/transferable-receivable-payment.md "mention")
+
+## Declarative Payment Network
+
+The declarative payment network allows for manual declaration of payments and refunds. It's particularly useful for currencies or payment methods not directly supported by Request Network like traditional finance payment rails, unsupported web3 payment protocols, and unsupported chains like Solana or Tron.
+
+Example of creating a request with a declarative payment network:
+
+```typescript
+const request = await requestNetwork.createRequest({
+ paymentNetwork: {
+ id: Types.Extension.PAYMENT_NETWORK_ID.DECLARATIVE,
+ parameters: {
+ paymentInfo: {
+ IBAN: 'FR7630006000011234567890189',
+ BIC: 'BNPAFRPP'
+ },
+ },
+ },
+ requestInfo: {
+ currency: {
+ type: RequestLogicTypes.CURRENCY.ISO4217,
+ value: 'EUR'
+ },
+ expectedAmount: '100000', // 1000.00 EUR (2 decimals)
+ payee: payeeIdentity,
+ payer: payerIdentity,
+ },
+ signer: payeeIdentity,
+});
+```
+
+For details on how to use Declarative Payments, See [declarative-request.md](../request-network-sdk/sdk-guides/payment/declarative-request.md "mention")
+
+### Meta Payment Network
+
+The Meta Payment Network allows you to specify multiple potential payment networks for a single request. The payment can be settled by any one of the sub-payment networks.
+
+For details on how to use Meta Payment Network, see [meta-payments.md](../request-network-sdk/sdk-guides/payment/meta-payments.md "mention")
+
+### ERC777 Stream Payment Network "Streaming Payment"
+
+ERC777 Streaming Payment routes payments through the ERC20 Fee Proxy payment network, allowing for continuous, streaming payments.
+
+Example of creating an ERC777 Streaming Payment request:
+
+```typescript
+const streamingRequest = await requestNetwork.createRequest({
+ paymentNetwork: {
+ id: Types.Extension.PAYMENT_NETWORK_ID.ERC777_STREAM,
+ parameters: {
+ paymentAddress: paymentRecipientAddress,
+ feeAddress: feeRecipient,
+ feeAmount: '0',
+ network: 'mainnet',
+ tokenAddress: erc777TokenAddress,
+ },
+ },
+ requestInfo: {
+ currency: {
+ type: RequestLogicTypes.CURRENCY.ERC777,
+ value: erc777TokenAddress,
+ network: 'mainnet'
+ },
+ expectedAmount: '1000000000000000000', // 1 token with 18 decimals
+ payee: payeeIdentity,
+ payer: payerIdentity,
+ },
+ signer: payeeIdentity,
+});
+```
+
+For details on how to use the ERC777 Stream Payment Network, see [streaming-request.md](../request-network-sdk/sdk-guides/payment/streaming-request.md "mention")
+
+## Other Payment Networks
+
+### Address-based Payment Networks (Not Recommended)
+
+These networks require a unique payment recipient address for each request. The balance is computed from all inbound transfers to this address. This method is not recommended due to its limitations and potential for errors.
+
+### ETH Input Data Payment Network (Deprecated)
+
+This network used the `call data` field of Ethereum transactions to tag and detect payments. It has been deprecated in favor of the other reference-based payment networks that use payment proxy smart contracts.
+
+### ERC20 Proxy and Ethereum Proxy (Superseded)
+
+These payment networks have been superseded by the ERC20 Fee Proxy and ETH Fee Proxy networks respectively. The only difference is that the ERC20 Proxy and Ethereum Proxy don't include the service fee mechanism. For most use cases, it's recommended to use the Fee Proxy versions with the fee set to 0 if no fee is required.
+
+## Advanced Payment Types
+
+Advanced payment types are built on top of payment networks and provide additional functionality or flexibility.
+
+The Advanced Payment Types are \*not\* Payment Networks. You cannot create a request with one of these payment types in the `paymentNetwork` property.
+
+Here are some of the advanced payment types available:
+
+### Batch Payments
+
+Batch payments allow you to pay multiple requests in the same transaction. This is supported for the following payment networks:
+
+* ERC20 Fee Proxy
+* ETH Fee Proxy
+* Any-to-ERC20 Proxy "ERC20 Conversion Payments"
+* Any-to-ETH Proxy "ETH Conversion Payments"
+* ERC20 Proxy networks
+
+See [batch-payment.md](../request-network-sdk/sdk-guides/payment/batch-payment.md "mention") for additional details.
+
+### ERC20 Swap-to-Pay Payments
+
+Swap-to-Pay payments execute a swap immediately before routing the payment through the ERC20 Fee Proxy payment network.
+
+{% hint style="info" %}
+**Swap-to-Pay is different from Conversion.** For details see [#difference-between-conversion-swap-to-pay-and-swap-to-conversion](how-payment-networks-work.md#difference-between-conversion-swap-to-pay-and-swap-to-conversion "mention")
+{% endhint %}
+
+See [swap-to-pay-request.md](../request-network-sdk/sdk-guides/payment/swap-to-pay-request.md "mention") for additional details
+
+### ERC20 Swap-to-Conversion
+
+Swap-to-Conversion is the combination of Conversion and Swap-to-Pay.
+
+Swap-to-Conversion executes a swap in Uniswap V2 immediately before routing the payment through the Any-to-ERC20 Payment Network.
+
+See [swap-to-conversion-request.md](../request-network-sdk/sdk-guides/payment/swap-to-conversion-request.md "mention") for additional details.
+
+{% hint style="info" %}
+**Swap-to-Pay is different from Conversion.** For details see [#difference-between-conversion-swap-to-pay-and-swap-to-conversion](how-payment-networks-work.md#difference-between-conversion-swap-to-pay-and-swap-to-conversion "mention")
+{% endhint %}
+
+### ERC20 Escrow Payment
+
+ERC20 Escrow Payment allows for escrow functionality in payments.
+
+{% hint style="warning" %}
+The Request Network Escrow lacks arbitration and is susceptible to deadlock in the case of a dispute.
+{% endhint %}
+
+See [escrow-request.md](../request-network-sdk/sdk-guides/payment/escrow-request.md "mention") for additional details.
+
+### Difference between Conversion, Swap-to-Pay, and Swap-to-Conversion
+
+Conversion is different from Swap-to-pay.
+
+* In a conversion payment, the request is denominated in currency A, the payer sends currency B and the payee receives currency B.
+* In a Swap-to-pay payment, the request is denominated in currency A, the payer sends currency B and the payee receives currency A.
+
+They can be combined into Swap-to-Conversion.
+
+* In a swap-to-conversion payment, the request is denominated in currency A, the payer sends currency B and the payee receives currency C.
+
+For more detailed information on specific payment networks or to contribute new implementations, please refer to our [GitHub repository](https://github.com/RequestNetwork/requestNetwork) or join our [Discord community](https://request.network/discord).
diff --git a/advanced/protocol-overview/private-requests-using-encryption.md b/advanced/protocol-overview/private-requests-using-encryption.md
new file mode 100644
index 0000000..e6bd5b2
--- /dev/null
+++ b/advanced/protocol-overview/private-requests-using-encryption.md
@@ -0,0 +1,35 @@
+---
+layout:
+ title:
+ visible: true
+ description:
+ visible: true
+ tableOfContents:
+ visible: true
+ outline:
+ visible: true
+ pagination:
+ visible: true
+---
+
+# Private Requests using Encryption
+
+The Request Network protocol persists request contents on IPFS. When privacy is required, the SDK supports the creation and subsequent reading of encrypted requests.
+
+This is achieved by combining public key (asymmetric) & AES (symmetric) encryption.
+
+## Encryption
+
+
Request encryption overview
+
+The "request contents" are encrypted with a random AES key. This key is then encrypted with the public key of each stakeholder of the request. The stakeholders are the users and platforms who require access to the request contents. The encrypted request contents and the encrypted AES keys are then persisted to IPFS.
+
+## Decryption
+
+
Request decryption overview
+
+The user retrieves the encrypted request content and the encrypted AES keys. They decrypt the AES key using their private key. Then they decrypt the request content using the AES key.
+
+## Similarity to HTTPS
+
+The privacy and encryption mechanism used by Request Network has many similarities to HTTPS. If you're not familiar with HTTPS, we recommend reading [HTTPS explained with carrier pigeons](https://www.freecodecamp.org/news/https-explained-with-carrier-pigeons-7029d2193351/)
diff --git a/advanced/protocol-overview/request-client-and-request-node.md b/advanced/protocol-overview/request-client-and-request-node.md
new file mode 100644
index 0000000..acdd3e0
--- /dev/null
+++ b/advanced/protocol-overview/request-client-and-request-node.md
@@ -0,0 +1,29 @@
+# SDK and Request Node Overview
+
+## Request Network SDK
+
+The **Request Network SDK** is the set of software packages for interacting with the Request Network. The [packages](../request-network-sdk/get-started/installation.md#external-packages) can be installed via npm and allow developers to:
+
+* Create new requests
+* Update requests
+* Pay requests
+* Retrieve requests
+* Detecting payments
+
+## Request Node
+
+The **Request Node** is a software bundle that provides a gateway to the various layers of the Request Network Protocol:
+
+* [IPFS](https://developers.cloudflare.com/web3/ipfs-gateway/concepts/ipfs/) persists the request content
+* Smart contracts persist the unique IPFS [CID](https://developers.cloudflare.com/web3/ipfs-gateway/concepts/ipfs/#content-identifiers) on-chain
+* [The Graph](https://thegraph.com/docs/en/about/) indexes smart contract events
+
+This Request Node acts as a relay server which helps reduce friction and costs for the end user. The user signs the request contents, but the node funds the fees required to persist the contents in the various protocol layers.
+
+The Request Network Foundation operates several [Request Nodes](https://docs.request.network/get-started/request-node-gateways) which builders can use to quickly test the protocol. However, for production, we advise you to run your own node which can be installed via either [npm](https://www.npmjs.com/package/@requestnetwork/request-node) or [docker](https://hub.docker.com/r/requestnetwork/request-node).
+
+## Interaction between SDK and Request Node
+
+Shown below is a diagram that depicts how the SDK and Node interact with the protocol.
+
+
Interacting with Request Network via a Request Node
diff --git a/advanced/request-network-sdk/README.md b/advanced/request-network-sdk/README.md
new file mode 100644
index 0000000..ce95285
--- /dev/null
+++ b/advanced/request-network-sdk/README.md
@@ -0,0 +1,2 @@
+# Request Network SDK
+
diff --git a/advanced/request-network-sdk/get-started/README.md b/advanced/request-network-sdk/get-started/README.md
new file mode 100644
index 0000000..fc82f20
--- /dev/null
+++ b/advanced/request-network-sdk/get-started/README.md
@@ -0,0 +1,2 @@
+# Get Started
+
diff --git a/advanced/request-network-sdk/get-started/installation.md b/advanced/request-network-sdk/get-started/installation.md
new file mode 100644
index 0000000..dbf410e
--- /dev/null
+++ b/advanced/request-network-sdk/get-started/installation.md
@@ -0,0 +1,46 @@
+# Installation
+
+The best way to access Request Network is using the Request Network SDK with a Request Node. In this way, the Request Node operator pays the protocol fee for creating requests and reduces the number of transactions signed by the end user resulting in a better user experience.
+
+The Request Network SDK is split into multiple packages so that Builders can pick and choose the features they need.
+
+## SDK Packages
+
+These are the packages that we think would be most commonly used by Builders to build applications.
+
+
A dialog box for granting third-party access to an encrypted invoice created via Request Finance
+
+## Import the packages
+
+The Request Client library can be imported as ES6 or CommonJS modules.
+
+{% tabs %}
+{% tab title="ES6" %}
+
import { RequestNetwork } from '@requestnetwork/request-client.js';
+import { Web3SignatureProvider } from '@requestnetwork/web3-signature';
+import { payRequest } from '@requestnetwork/payment-processor';
+
+{% endtab %}
+
+{% tab title="CommonJS" %}
+```tsx
+const { RequestNetwork } = require('@requestnetwork/request-client.js');
+const { Web3SignatureProvider } = require('@requestnetwork/web3-signature');
+const { payRequest } = require("@requestnetwork/payment-processor");
+```
+{% endtab %}
+{% endtabs %}
+
+## Internal SDK Packages
+
+These packages are published publicly but contain functions that are considered internal to the [SDK Packages](installation.md#sdk-packages). It is less likely that a Builder would need to use these packages.
+
+
Collection of tools shared between the @requestnetwork packages
diff --git a/advanced/request-network-sdk/get-started/quickstart-browser.md b/advanced/request-network-sdk/get-started/quickstart-browser.md
new file mode 100644
index 0000000..7d89cca
--- /dev/null
+++ b/advanced/request-network-sdk/get-started/quickstart-browser.md
@@ -0,0 +1,408 @@
+# Quickstart - Browser
+
+This page will introduce the primary operations provided by Request Network’s SDK while using the `Web3SignatureProvider` to sign requests with a private key stored inside a wallet.
+
+This approach works well for Browser environments _with_ access to a web3 wallet.
+
+{% hint style="info" %}
+You will learn:
+
+* How to create a request
+* How to update a request (coming soon...)
+* How to pay a request
+* How to detect a payment
+* How to retrieve a user’s requests
+{% endhint %}
+
+## Create a request
+
+To create an unencrypted ERC-20 request, first connect to an `ethers` v5 `Provider` and `Signer` or `wagmi` / `viem` `WalletClient.`
+
+{% hint style="warning" %}
+Unfortunately, the Request Network SDK does not yet support ethers v6.
+{% endhint %}
+
+{% tabs %}
+{% tab title="ethers v5" %}
+{% code fullWidth="false" %}
+```typescript
+import { providers } from "ethers";
+
+let provider;
+if (process.env.WEB3_PROVIDER_URL === undefined) {
+ // Connect to Metamask and other injected wallets
+ provider = new providers.Web3Provider(window.ethereum);
+} else {
+ // Connect to your own Ethereum node or 3rd party node provider
+ provider = new providers.JsonRpcProvider(process.env.WEB3_PROVIDER_URL);
+}
+// getDefaultProvider() won't work because it doesn't include a Signer.
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="wagmi" %}
+```typescript
+import { useWalletClient } from "wagmi";
+
+const { data: walletClient } = useWalletClient();
+```
+{% endtab %}
+
+{% tab title="viem" %}
+Very similar to wagmi, but without using hooks. Construct your own `WalletClient` object.
+{% endtab %}
+{% endtabs %}
+
+Then, construct a `Web3SignatureProvider`, passing in the `ethers` `Provider` or `viem` `WalletClient.`
+
+```typescript
+import { Web3SignatureProvider } from "@requestnetwork/web3-signature";
+
+const web3SignatureProvider = new Web3SignatureProvider(provider);
+```
+
+Then, construct a `RequestNetwork`, passing in the:
+
+* Request Node URL. In this example, we use the Sepolia Request Node Gateway.
+* `Web3SignatureProvider` constructed in the previous step.
+
+```typescript
+import { RequestNetwork } from "@requestnetwork/request-client.js"
+
+const requestClient = new RequestNetwork({
+ nodeConnectionConfig: {
+ baseURL: "https://sepolia.gateway.request.network/",
+ },
+ signatureProvider: web3SignatureProvider,
+});
+```
+
+Then, prepare the Request creation parameters:
+
+```typescript
+import { Types, Utils } from "@requestnetwork/request-client.js";
+
+const payeeIdentity = '0x7eB023BFbAeE228de6DC5B92D0BeEB1eDb1Fd567';
+const payerIdentity = '0x519145B771a6e450461af89980e5C17Ff6Fd8A92';
+const paymentRecipient = payeeIdentity;
+const feeRecipient = '0x0000000000000000000000000000000000000000';
+
+const requestCreateParameters = {
+ requestInfo: {
+
+ // The currency in which the request is denominated
+ currency: {
+ type: Types.RequestLogic.CURRENCY.ERC20,
+ value: '0x370DE27fdb7D1Ff1e1BaA7D11c5820a324Cf623C',
+ network: 'sepolia',
+ },
+
+ // The expected amount as a string, in parsed units, respecting `decimals`
+ // Consider using `parseUnits()` from ethers or viem
+ expectedAmount: '1000000000000000000',
+
+ // The payee identity. Not necessarily the same as the payment recipient.
+ payee: {
+ type: Types.Identity.TYPE.ETHEREUM_ADDRESS,
+ value: payeeIdentity,
+ },
+
+ // The payer identity. If omitted, any identity can pay the request.
+ payer: {
+ type: Types.Identity.TYPE.ETHEREUM_ADDRESS,
+ value: payerIdentity,
+ },
+
+ // The request creation timestamp.
+ timestamp: Utils.getCurrentTimestampInSecond(),
+ },
+
+ // The paymentNetwork is the method of payment and related details.
+ paymentNetwork: {
+ id: Types.Extension.PAYMENT_NETWORK_ID.ERC20_FEE_PROXY_CONTRACT,
+ parameters: {
+ paymentNetworkName: 'sepolia',
+ paymentAddress: payeeIdentity,
+ feeAddress: feeRecipient,
+ feeAmount: '0',
+ },
+ },
+
+ // The contentData can contain anything.
+ // Consider using rnf_invoice format from @requestnetwork/data-format
+ contentData: {
+ reason: '🍕',
+ dueDate: '2023.06.16',
+ },
+
+ // The identity that signs the request, either payee or payer identity.
+ signer: {
+ type: Types.Identity.TYPE.ETHEREUM_ADDRESS,
+ value: payeeIdentity,
+ },
+};
+```
+
+Then, call `createRequest()` to prepare a `Request` object.
+
+```typescript
+const request = await requestClient.createRequest(requestCreateParameters);
+```
+
+Finally, call `request.waitForConfirmation()` to wait until:
+
+* The request contents are persisted in IPFS
+* The Content-addressable ID (CID) is stored on-chain
+* The resulting on-chain event is indexed by the storage subgraph.
+
+```typescript
+const confirmedRequestData = await request.waitForConfirmation();
+```
+
+### CodeSandBox: Create a request
+
+{% embed url="https://codesandbox.io/p/sandbox/create-a-request-shffng?file=/app/page.tsx:43,1" fullWidth="true" %}
+[https://codesandbox.io/p/sandbox/create-a-request-shffng?file=/app/page.tsx:43,1](https://codesandbox.io/p/sandbox/create-a-request-shffng?file=/app/page.tsx:43,1)
+{% endembed %}
+
+## Pay a request
+
+First, construct a `RequestNetwork` object and connect it to a Request Node. In this example, we use the Sepolia Request Node Gateway:
+
+{% hint style="info" %}
+Note that paying a request doesn't require a `SignatureProvider` be passed into the `RequestNetwork` object.
+{% endhint %}
+
+
+
+Then, in the case of an ERC-20 request, check that the payer has granted sufficient approval using `hasErc20Approval()`. If not, submit an approval transaction using `approveErc20`. Wait for an appropriate number of block confirmations. On Sepolia or Ethereum, 2 block confirmations should suffice. Other chains may require more.
+
+```typescript
+import { approveErc20, hasErc20Approval } from "@requestnetwork/payment-processor";
+
+const _hasErc20Approval = await hasErc20Approval(
+ requestData,
+ payerAddress,
+ provider
+);
+if (!_hasErc20Approval) {
+ const approvalTx = await approveErc20(requestData, signer);
+ await approvalTx.wait(2);
+}
+```
+
+Finally, pay the request using `payRequest()`
+
+
+
+You can detect that the payment was successful by polling the request and waiting until the request balance is greater than or equal to the expected amount.
+
+```typescript
+const request = await requestClient.fromRequestId(requestData.requestId);
+let requestData = request.getData();
+
+while (requestData.balance?.balance < requestData.expectedAmount) {
+ requestData = await request.refresh();
+ await new Promise((resolve) => setTimeout(resolve, 1000));
+}
+```
+
+### CodeSandBox: Create and pay a request and detect a payment
+
+{% embed url="https://codesandbox.io/p/sandbox/pay-a-request-dn7kcf?file=/app/page.tsx:71,1" fullWidth="true" %}
+[https://codesandbox.io/p/sandbox/pay-a-request-dn7kcf?file=/app/page.tsx:71,1](https://codesandbox.io/p/sandbox/pay-a-request-dn7kcf?file=/app/page.tsx:71,1)
+{% endembed %}
+
+### Video: Create and pay a request and detect a payment
+
+{% embed url="https://www.loom.com/share/1839cf3e79784dc4a6e641903b4f10d2?sid=8caf4cdb-04fe-4753-ab99-b97926c36f20" fullWidth="true" %}
+
+## Retrieve a user's requests
+
+First, construct a `RequestNetwork` object and connect it to a Request Node. In this example, we use the Sepolia Request Node Gateway:
+
+
+
+Then, call `fromIdentity()` to get an array of `Request` objects or `fromRequestId()` to get a single `Request` object. This function retrieves the `Request`s stored in IPFS and queries on-chain events to determine the balances paid so far. Finally, call `getData()` on each `Request` to get the request contents.
+
+{% tabs %}
+{% tab title="fromIdentity()" %}
+{% code fullWidth="true" %}
+```javascript
+const identityAddress = "0x519145B771a6e450461af89980e5C17Ff6Fd8A92";
+const requests = await requestClient.fromIdentity({
+ type: Types.Identity.TYPE.ETHEREUM_ADDRESS,
+ value: identityAddress,
+});
+const requestDatas = requests.map((request) => request.getData());
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="fromRequestId()" %}
+
+{% endtab %}
+{% endtabs %}
+
+### CodeSandBox: Retrieve a user's requests
+
+{% embed url="https://codesandbox.io/p/sandbox/retrieve-a-users-requests-mqrjqy?file=/app/page.tsx:10,1" fullWidth="true" %}
+[https://codesandbox.io/p/sandbox/retrieve-a-users-requests-mqrjqy?file=/app/page.tsx:10,1](https://codesandbox.io/p/sandbox/retrieve-a-users-requests-mqrjqy?file=/app/page.tsx:10,1)
+{% endembed %}
+
+### Video: Retrieve a user's requests
+
+{% embed url="https://www.loom.com/share/ea76747fd3c14b6b88f916d9edce7bb5?sid=68bfb08e-48c5-4817-95d3-8eb45688978b" fullWidth="true" %}
diff --git a/advanced/request-network-sdk/get-started/quickstart-node.js.md b/advanced/request-network-sdk/get-started/quickstart-node.js.md
new file mode 100644
index 0000000..a1ed903
--- /dev/null
+++ b/advanced/request-network-sdk/get-started/quickstart-node.js.md
@@ -0,0 +1,273 @@
+# Quickstart - Node.js
+
+This page will introduce the primary operations provided by Request Network’s SDK while using the `EthereumPrivateKeySignatureProvider` to sign requests with a private key that is managed outside of a wallet.
+
+This approach works well for Node.js environments _without_ access to a Web3 wallet.
+
+{% hint style="info" %}
+You will learn:
+
+* How to create a request
+* How to update a request (coming soon...)
+* How to pay a request
+* How to detect a payment
+* How to retrieve a user’s requests
+{% endhint %}
+
+## Repository
+
+All of the following examples can be found in this repository [https://github.com/RequestNetwork/quickstart-node.js](https://github.com/RequestNetwork/quickstart-node.js)
+
+## Create a request
+
+To create an unencrypted ERC-20 request, first construct an `EthereumPrivateKeySignatureProvider` with a private key.
+
+```javascript
+const {
+ EthereumPrivateKeySignatureProvider,
+} = require("@requestnetwork/epk-signature");
+const { Types } = require("@requestnetwork/request-client.js");
+
+const epkSignatureProvider = new EthereumPrivateKeySignatureProvider({
+ method: Types.Signature.METHOD.ECDSA,
+ privateKey: process.env.PAYEE_PRIVATE_KEY, // Must include 0x prefix
+});
+```
+
+Then, first construct a `RequestNetwork`, passing in the:
+
+* Request Node URL. In this example, we use the Sepolia Request Node Gateway.
+* `EthereumPrivateKeySignatureProvider` constructed in the previous step.
+
+```javascript
+const { RequestNetwork } = require("@requestnetwork/request-client.js")
+
+const requestClient = new RequestNetwork({
+ nodeConnectionConfig: {
+ baseURL: "https://sepolia.gateway.request.network/",
+ },
+ signatureProvider: epkSignatureProvider,
+});
+```
+
+Prepare the Request creation parameters:
+
+```javascript
+const { Types, Utils } = require("@requestnetwork/request-client.js");
+
+const payeeIdentity = '0x7eB023BFbAeE228de6DC5B92D0BeEB1eDb1Fd567';
+const payerIdentity = '0x519145B771a6e450461af89980e5C17Ff6Fd8A92';
+const paymentRecipient = payeeIdentity;
+const feeRecipient = '0x0000000000000000000000000000000000000000';
+
+const requestCreateParameters = {
+ requestInfo: {
+
+ // The currency in which the request is denominated
+ currency: {
+ type: Types.RequestLogic.CURRENCY.ERC20,
+ value: '0x370DE27fdb7D1Ff1e1BaA7D11c5820a324Cf623C',
+ network: 'sepolia',
+ },
+
+ // The expected amount as a string, in parsed units, respecting `decimals`
+ // Consider using `parseUnits()` from ethers or viem
+ expectedAmount: '1000000000000000000',
+
+ // The payee identity. Not necessarily the same as the payment recipient.
+ payee: {
+ type: Types.Identity.TYPE.ETHEREUM_ADDRESS,
+ value: payeeIdentity,
+ },
+
+ // The payer identity. If omitted, any identity can pay the request.
+ payer: {
+ type: Types.Identity.TYPE.ETHEREUM_ADDRESS,
+ value: payerIdentity,
+ },
+
+ // The request creation timestamp.
+ timestamp: Utils.getCurrentTimestampInSecond(),
+ },
+
+ // The paymentNetwork is the method of payment and related details.
+ paymentNetwork: {
+ id: Types.Extension.PAYMENT_NETWORK_ID.ERC20_FEE_PROXY_CONTRACT,
+ parameters: {
+ paymentNetworkName: 'sepolia',
+ paymentAddress: payeeIdentity,
+ feeAddress: feeRecipient,
+ feeAmount: '0',
+ },
+ },
+
+ // The contentData can contain anything.
+ // Consider using rnf_invoice format from @requestnetwork/data-format
+ contentData: {
+ reason: '🍕',
+ dueDate: '2023.06.16',
+ },
+
+ // The identity that signs the request, either payee or payer identity.
+ signer: {
+ type: Types.Identity.TYPE.ETHEREUM_ADDRESS,
+ value: payeeIdentity,
+ },
+};
+```
+
+Then, call `createRequest()` to create the request and `waitForConfirmation()` to wait until the request is persisted in IPFS and the CID hash is stored on-chain.
+
+```javascript
+const request = await requestClient.createRequest(requestCreateParameters);
+const confirmedRequestData = await request.waitForConfirmation();
+```
+
+Altogether it looks like this:
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/quickstart-node-js/blob/main/src/createRequest.js" %}
+
+## Pay a request / Detect a payment
+
+First, construct a `RequestNetwork` object and connect it to a Request Node. In this example, we use the Sepolia Request Node Gateway:
+
+
+
+Then, retrieve the request and get the request data. Take note of the current request balance, to be used later for payment detection.
+
+```javascript
+const request = await requestClient.fromRequestId(
+ '019830e9ec0439e53ec41fc627fd1d0293ec4bc61c2a647673ec5aaaa0e6338855',
+);
+const requestData = request.getData();
+```
+
+Then, construct an `ethers` v5 `Provider` and `Wallet` using a private key. These allow you to read and write to the chain, respectively.
+
+{% hint style="warning" %}
+Unfortunately, the Request Network SDK does not yet support ethers v6.
+{% endhint %}
+
+{% tabs %}
+{% tab title="ethers v5" %}
+```javascript
+const { providers, Wallet } = require("ethers");
+
+const provider = new providers.JsonRpcProvider(
+ process.env.JSON_RPC_PROVIDER_URL,
+);
+const payerWallet = new Wallet(
+ process.env.PAYER_PRIVATE_KEY, // Must include 0x prefix
+ provider,
+);
+```
+{% endtab %}
+
+{% tab title="viem" %}
+Coming soon. Probably involves `publicClientToProvider()` and `walletClientToSigner()`.
+{% endtab %}
+{% endtabs %}
+
+Then, check that the payer has sufficient funds using `hasSufficientFunds()`
+
+
+
+Then, in the case of an ERC-20 request, check that the payer has granted sufficient approval using `hasErc20Approval()`. If not, submit an approval transaction using `approveErc20`. Wait for an appropriate number of block confirmations. On Sepolia or Ethereum, 2 block confirmations should suffice. Other chains may require more.
+
+```javascript
+const {
+ approveErc20,
+ hasErc20Approval,
+} = require("@requestnetwork/payment-processor);
+
+const _hasErc20Approval = await hasErc20Approval(
+ requestData,
+ payerAddress,
+ provider
+);
+if (!_hasErc20Approval) {
+ const approvalTx = await approveErc20(requestData, signer);
+ await approvalTx.wait(2);
+}
+```
+
+Finally, pay the request using `payRequest()`
+
+
+
+Detect that the payment was successful by polling the request and waiting until the request balance is greater than or equal to the expected amount.
+
+```javascript
+const request = await requestClient.fromRequestId(requestData.requestId);
+let requestData = request.getData();
+
+while (requestData.balance?.balance < requestData.expectedAmount) {
+ requestData = await request.refresh();
+ await new Promise((resolve) => setTimeout(resolve, 1000));
+}
+```
+
+Altogether it looks like this:
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/quickstart-node-js/blob/main/src/payRequest.js" %}
+
+## Retrieve a user's requests
+
+First, construct a `RequestNetwork` object and connect it to a Request Node. In this example, we use the Sepolia Request Node Gateway:
+
+
+
+Then, call `fromIdentity()` to get an array of `Request` objects or `fromRequestId()` to get a single `Request` object. This function retrieves the `Request`s stored in IPFS and queries on-chain events to determine the balances paid so far. Finally, call `getData()` on each `Request` to get the request contents.
+
+{% tabs %}
+{% tab title="fromIdentity()" %}
+{% code fullWidth="true" %}
+```javascript
+const identityAddress = "0x519145B771a6e450461af89980e5C17Ff6Fd8A92";
+const requests = await requestClient.fromIdentity({
+ type: Types.Identity.TYPE.ETHEREUM_ADDRESS,
+ value: identityAddress,
+});
+const requestDatas = requests.map((request) => request.getData());
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="fromRequestId()" %}
+
+{% endtab %}
+{% endtabs %}
+
+Altogether it looks like this:
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/quickstart-node-js/blob/main/src/retrieveRequest.js" %}
diff --git a/advanced/request-network-sdk/get-started/request-node-gateways.md b/advanced/request-network-sdk/get-started/request-node-gateways.md
new file mode 100644
index 0000000..3eeac07
--- /dev/null
+++ b/advanced/request-network-sdk/get-started/request-node-gateways.md
@@ -0,0 +1,5 @@
+# Request Node Gateways
+
+The Request Network Foundation operates several Request Node "Gateways" that are free for anyone to use. These gateways offer endpoints for creating and retrieving requests. They also pay the protocol fee for creating requests, about USD $0.10 per request, paid in XDAI.
+
+
+
+The Request Network Injector CLI simplifies the integration process by automatically injecting pre-built, customizable functions into your project. This tool allows new and experienced builders to quickly integrate the Request Network Protocol into their applications with minimal setup.
+
+## Features
+
+* Automatic injection of essential Request Network functions
+* Support for both TypeScript and JavaScript projects
+* Customizable function selection
+* Automatic package installation
+* Support for various package managers (npm, yarn, pnpm, bun)
+
+\
+How it works
+------------
+
+1. The CLI analyzes your project structure
+2. You select the functions you want to inject
+3. You choose your preferred language (TypeScript or JavaScript)
+4. The tool injects the selected functions into your project
+5. Necessary dependencies are automatically installed
+
+## Demo Video
+
+{% embed url="https://www.youtube.com/watch?v=8MJzP1bBvaU" %}
+Request Injector Demo Video
+{% endembed %}
diff --git a/advanced/request-network-sdk/sdk-api-reference/README.md b/advanced/request-network-sdk/sdk-api-reference/README.md
new file mode 100644
index 0000000..851afc8
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-api-reference/README.md
@@ -0,0 +1,2 @@
+# SDK Reference
+
diff --git a/advanced/request-network-sdk/sdk-api-reference/epk-decryption/README.md b/advanced/request-network-sdk/sdk-api-reference/epk-decryption/README.md
new file mode 100644
index 0000000..6a2d573
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-api-reference/epk-decryption/README.md
@@ -0,0 +1,7 @@
+# epk-decryption
+
+## Install
+
+```bash
+npm install @requestnetwork/epk-decryption
+```
diff --git a/advanced/request-network-sdk/sdk-api-reference/epk-decryption/ethereumprivatekeydecryptionprovider.md b/advanced/request-network-sdk/sdk-api-reference/epk-decryption/ethereumprivatekeydecryptionprovider.md
new file mode 100644
index 0000000..2b0c6eb
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-api-reference/epk-decryption/ethereumprivatekeydecryptionprovider.md
@@ -0,0 +1,25 @@
+# EthereumPrivateKeyDecryptionProvider
+
+## Description
+
+Decrypt using a private key outside of a wallet
+
+## Usage
+
+```typescript
+import { EthereumPrivateKeyDecryptionProvider } from "@requestnetwork/epk-decryption";
+```
+
+## Constructor Parameters
+
+
+
+## Returns
+
+Promise\
+
+This is what ethers returns after submitting a transaction.
+
+## Types and Interfaces
+
+### IConversionPaymentSettings
+
+
Name
Type
Required?
Description
currency
ICurrency
true
The currency in which the payment is made, not the currency in which the request is denominated.
maxToSpend
ethers.BigNumberish
true
The maximum input currency to spend on conversion payments. Protects the user from rapidly changing exchange rates.
currencyManager
ICurrencyManager
true
A Currency manager handles a list of currencies and provides utility to retrieve and change format
+
diff --git a/advanced/request-network-sdk/sdk-api-reference/request-client.js/iidentity.md b/advanced/request-network-sdk/sdk-api-reference/request-client.js/iidentity.md
new file mode 100644
index 0000000..54c267f
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-api-reference/request-client.js/iidentity.md
@@ -0,0 +1,18 @@
+# IIdentity
+
+## Description
+
+An identity object that is used to uniquely identify a stakeholder in a request. Today, a stakeholder's `IIdentity` is expressed as an Ethereum address, but it is conceivable that future implementations may include alternative identity formats, perhaps W3C DIDs.
+
+Examples of `IIdentity` are: payee, payer, signer, creator, and any 3rd party that can view an encrypted request's contents.
+
+{% hint style="warning" %}
+The `payee` identity and `payer` identity are NOT necessarily the same as the payment recipient (`paymentAddress` in the [PaymentNetworkCreateParameters](requestnetwork/createrequest.md#paymentnetworkcreateparameters)) or the payment sender (`from` address in the payment-subgraph). Conceptually, the `payee` and `payer` identities are used only for notifications and access control, NOT payment routing.
+{% endhint %}
+
+
It is not possible to create or update a request using an IIdentity of this type. This type was added to support creating/updating requests using multisig wallets via EIP-1271 but this feature has not yet been implemented.
+
diff --git a/advanced/request-network-sdk/sdk-api-reference/request-client.js/irequestdatawithevents.md b/advanced/request-network-sdk/sdk-api-reference/request-client.js/irequestdatawithevents.md
new file mode 100644
index 0000000..310ea89
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-api-reference/request-client.js/irequestdatawithevents.md
@@ -0,0 +1,47 @@
+# IRequestDataWithEvents
+
+## Description
+
+The request contents. Returned by [waitForConfirmation()](request/waitforconfirmation.md), [getData()](request/getdata.md) and many other methods.
+
+## Instance Methods
+
+
diff --git a/advanced/request-network-sdk/sdk-api-reference/request-client.js/paymentreferencecalculator.md b/advanced/request-network-sdk/sdk-api-reference/request-client.js/paymentreferencecalculator.md
new file mode 100644
index 0000000..0ba8cbb
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-api-reference/request-client.js/paymentreferencecalculator.md
@@ -0,0 +1,32 @@
+# PaymentReferenceCalculator
+
+## Description
+
+Compute the payment reference, the last 8 bytes of a salted hash of the request ID.
+
+```typescript
+last8Bytes(hash(lowercase(requestId + salt + address)))
+```
+
+The payment reference is the parameter that ties the request to events emitted by on-chain payments via Request Network payment smart contracts.
+
+## Usage
+
+```typescript
+import { PaymentReferenceCalculator } from "@requestnetwork/request-client.js";
+```
+
+## Static method: calculate()
+
+### Parameters
+
+
Name
Type
Required
Description
requestId
string
true
The ID of the request
salt
string
true
The salt of the request
address
string
true
Payment recipient address
+
+### Returns
+
+string
+
+### Implementation
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/requestNetwork/blob/master/packages/payment-detection/src/payment-reference-calculator.ts" %}
+
diff --git a/advanced/request-network-sdk/sdk-api-reference/request-client.js/request/README.md b/advanced/request-network-sdk/sdk-api-reference/request-client.js/request/README.md
new file mode 100644
index 0000000..b60a23e
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-api-reference/request-client.js/request/README.md
@@ -0,0 +1,13 @@
+# Request
+
+## Description
+
+An object used to interact with requests. Returned by [createRequest()](../requestnetwork/createrequest.md) and \_createEncryptedRequest()
+
+## Properties
+
+
requestId
string
The ID of the request. Hash derived from the request contents. Stored alongside the request contents so can be used to look up a request.
diff --git a/advanced/request-network-sdk/sdk-api-reference/web3-signature/web3signatureprovider.md b/advanced/request-network-sdk/sdk-api-reference/web3-signature/web3signatureprovider.md
new file mode 100644
index 0000000..ce86b88
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-api-reference/web3-signature/web3signatureprovider.md
@@ -0,0 +1,16 @@
+# Web3SignatureProvider
+
+## Description
+
+Sign using a private key inside of a wallet
+
+## Usage
+
+```typescript
+import { Web3SignatureProvider } from "@requestnetwork/web3-signature";
+```
+
+## Constructor Paramters
+
+
Name
Type
Required?
Description
web3Provider
ethers.Provider
true
An ethers v5 Provider or viem WalletClient
+
diff --git a/advanced/request-network-sdk/sdk-demo-apps/README.md b/advanced/request-network-sdk/sdk-demo-apps/README.md
new file mode 100644
index 0000000..5f904fb
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-demo-apps/README.md
@@ -0,0 +1,17 @@
+---
+description: Examples to quickly integrate Request Network
+---
+
+# SDK Demo Apps
+
+The Request Network Templates are examples of how to integrate the Request Network [components](components/ "mention") into various web frameworks.
+
+{% hint style="info" %}
+The Request Network Components are built using Svelte but compiled to [Web Components](https://developer.mozilla.org/en-US/docs/Web/API/Web_components) making them usable in any web environment, regardless of the framework.
+{% endhint %}
+
+## Use a Template
+
+The Request Network Templates are distributed as "Template Repositories" in Github. The Github Docs explain how to [Create a new repository from a template repository](https://docs.github.com/en/repositories/creating-and-managing-repositories/creating-a-repository-from-a-template).
+
+
diff --git a/advanced/request-network-sdk/sdk-demo-apps/components/README.md b/advanced/request-network-sdk/sdk-demo-apps/components/README.md
new file mode 100644
index 0000000..5617191
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-demo-apps/components/README.md
@@ -0,0 +1,6 @@
+---
+description: Web Components for integrating Request Network. Usable in any framework.
+---
+
+# Components
+
diff --git a/advanced/request-network-sdk/sdk-demo-apps/components/add-stakeholder.md b/advanced/request-network-sdk/sdk-demo-apps/components/add-stakeholder.md
new file mode 100644
index 0000000..89b78e8
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-demo-apps/components/add-stakeholder.md
@@ -0,0 +1,67 @@
+---
+description: >-
+ A dialog box for granting third-party access to an encrypted invoice created
+ via Request Finance
+---
+
+# Add Stakeholder
+
+The `add-stakeholder` component allows Builders to quickly integrate the [Request Finance Add Stakeholder](https://docs.request.finance/faq#i-am-integrating-the-request-network.-can-i-get-access-to-users-data-on-request-finance) widget into their applications.
+
+The Request Finance Add Stakeholder widget provides a dialog box for end-users to grant third-party access to one of their encrypted payment requests created via Request Finance. Then, under the hood, Request Finance calls `request.addStakeholders()` to add the third party as a stakeholder to the encrypted payment request.
+
+{% hint style="info" %}
+Access is granted on a per-request basis. Once we prove market demand for this feature, we hope that Request Finance will improve its widget to allow granting access to multiple requests at a time.
+{% endhint %}
+
+The template comes in the form of a [Web Component](https://www.webcomponents.org/introduction#how-do-i-use-a-web-component-) and a native [Svelte](https://svelte.dev/) component, provided by the [@requestnetwork/add-stakeholder](https://www.npmjs.com/package/@requestnetwork/add-stakeholder) package. The Web Component can be used anywhere including, but not limited to, React, Next.js, Vue, Svelte, or as a browser script.
+
+## Installation
+
+```bash
+npm install @requestnetwork/add-stakeholder
+```
+
+## Usage
+
+### Web Component in React, Next.js, or Vue
+
+```jsx
+import '@requestnetwork/add-stakeholder'
+
+export default function App() {
+ return (
+
+ )
+}
+```
+
+### Native Svelte component
+
+```javascript
+import { AddStakeholder } from '@requestnetwork/add-stakeholder'
+```
+
+```html
+
+```
+
+### Web Component in Svelte
+
+```javascript
+import '@requestnetwork/add-stakeholder'
+```
+
+```html
+
+```
+
+### Web Component in Browser
+
+```html
+
+
+
+
+
+```
diff --git a/advanced/request-network-sdk/sdk-demo-apps/components/create-invoice-form.md b/advanced/request-network-sdk/sdk-demo-apps/components/create-invoice-form.md
new file mode 100644
index 0000000..7c2e867
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-demo-apps/components/create-invoice-form.md
@@ -0,0 +1,90 @@
+---
+description: A form for creating invoices in Request Network
+---
+
+# Create Invoice Form
+
+
Screenshot of @requestnetwork/create-invoice-form 0.2.0
+
+The Create Invoice Form allows end-users to create an invoice using the Request Network. It is built using [Svelte](https://svelte.dev/) but compiled to a [Web Component](https://developer.mozilla.org/en-US/docs/Web/API/Web_components), making it usable in any web environment, regardless of the framework.
+
+## Installation
+
+To install the component, use npm:
+
+```bash
+npm install @requestnetwork/create-invoice-form
+```
+
+## Usage
+
+### Usage in React and Next.js
+
+Follow the instructions below to add the Create Invoice Form to a React or Next.js app. For a video explaining how to integrate, see the [#request-invoicing-integration-video](../#request-invoicing-integration-video "mention")
+
+#### [**create-invoice.tsx**](https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/pages/create-invoice.tsx)
+
+Configure the Create Invoice Form web component by creating a reference to it, setting its properties, and passing the reference as a prop.
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/pages/create-invoice.tsx" %}
+
+#### [wagmiConfig.ts](https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/utils/wagmiConfig.ts)
+
+#### The web component supports any wallet connector module built on top of [wagmi](https://wagmi.sh/). This provides the flexibility to use any wagmi-compatible wallet connector, such as [RainbowKit](https://www.rainbowkit.com/docs/introduction#industry-standards).
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/utils/wagmiConfig.ts" %}
+
+#### [initializeRN.ts](https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/utils/initializeRN.ts)
+
+Initialize the `RequestNetwork` object using an Ethers `Signer` or Viem `WalletClient`.
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/utils/initializeRN.ts" %}
+
+#### [config.ts](https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/utils/config.ts)
+
+Use the config object to pass additional configuration options. Please replace the `builderId` with your own, arbitrarily chosen ID. This is used to track how many invoices your application creates.
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/utils/config.ts" %}
+
+#### [context.tsx](https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/utils/context.tsx)
+
+Use a context provider to reinitialize the Request Network instance when the wallet changes.
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/utils/context.tsx" %}
+
+#### [currencies.ts](https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/utils/currencies.ts)
+
+A list of custom currencies to extend the default currency list.
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/utils/currencies.ts" %}
+
+#### [types.d.ts](https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/types.d.ts)
+
+Specify types to avoid TypeScript errors.
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/types.d.ts" %}
+
+## Props
+
+| Prop | Type | Description |
+| ----------------------- | --------------------------------------------------------------------------- | ------------------------------------------------------- |
+| config | IConfig | Additional configuration parameters |
+| config.builderId | string | Unique builder ID, arbitrarily chosen, used for metrics |
+| config.dashboardLink | string | Path to dashboard page |
+| config.logo | string | Path to logo file |
+| config.colors.main | string | Hex color code for primary buttons and labels |
+| config.colors.secondary | string | Hex color code for for borders and accents |
+| requestNetwork | [RequestNetwork](../../sdk-api-reference/request-client.js/requestnetwork/) | The RequestNetwork instance |
+| wagmiConfig | WagmiConfig | Wallet connector config |
+| currencies | Currency\[] | A list of custom currencies |
+
+
+
+## Next Steps
+
+{% content-ref url="../../get-started/quickstart-browser.md" %}
+[quickstart-browser.md](../../get-started/quickstart-browser.md)
+{% endcontent-ref %}
+
diff --git a/advanced/request-network-sdk/sdk-demo-apps/components/invoice-dashboard.md b/advanced/request-network-sdk/sdk-demo-apps/components/invoice-dashboard.md
new file mode 100644
index 0000000..5a6274e
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-demo-apps/components/invoice-dashboard.md
@@ -0,0 +1,93 @@
+---
+description: A dashboard for viewing and paying invoices in Request Network
+layout:
+ title:
+ visible: true
+ description:
+ visible: true
+ tableOfContents:
+ visible: true
+ outline:
+ visible: true
+ pagination:
+ visible: true
+---
+
+# Invoice Dashboard
+
+
Screenshot of @requestnetwork/invoice-dashboard 0.3.0
+
+The Invoice Dashboard component allows end-users to view and pay an invoice in Request Network. It is built using [Svelte](https://svelte.dev/) but compiled to a [Web Component](https://developer.mozilla.org/en-US/docs/Web/API/Web_components), making it usable in any web environment, regardless of the framework.
+
+## Installation
+
+To install the component, use npm:
+
+```bash
+npm install @requestnetwork/invoice-dashboard
+```
+
+## Usage
+
+### Usage in React and Next.js
+
+Follow the instructions below to add the Invoice Dashboard to a React or Next.js app.
+
+#### [**invoice-dashboard.tsx**](https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/pages/index.tsx)
+
+Configure the invoice dashboard web component by creating a reference to it, setting its properties, and passing the reference as a prop.
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/pages/index.tsx" %}
+
+#### [wagmiConfig.ts](https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/utils/wagmiConfig.ts)
+
+#### The web component supports any wallet connector module built on top of [wagmi](https://wagmi.sh/). This provides the flexibility to use any wagmi-compatible wallet connector, such as [RainbowKit](https://www.rainbowkit.com/docs/introduction#industry-standards).
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/utils/wagmiConfig.ts" %}
+
+#### [initializeRN.ts](https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/utils/initializeRN.ts)
+
+Initialize the `RequestNetwork` object using an Ethers `Signer` or Viem `WalletClient`.
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/utils/initializeRN.ts" %}
+
+#### [config.ts](https://github.com/RequestNetwork/invoicing-template/blob/main/utils/config.ts)
+
+Use the config object to pass additional configuration options. Please replace the `builderId` with your own, arbitrarily chosen ID. This is used to track how many invoices your application creates.
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/utils/config.ts" %}
+
+#### [context.tsx](https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/utils/context.tsx)
+
+Use a context provider to reinitialize the Request Network instance when the wallet changes.
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/utils/context.tsx" %}
+
+#### [currencies.ts](https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/utils/currencies.ts)
+
+A list of custom currencies to extend the default currency list.
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/utils/currencies.ts" %}
+
+#### [types.d.ts](https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/types.d.ts)
+
+Specify types to avoid TypeScript errors.
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/invoicing-template/blob/01e44755b274d17c0718ca03f077d68a9fe8baec/types.d.ts" %}
+
+## Props
+
+| Prop | Type | Description |
+| ----------------------- | --------------------------------------------------------------------------- | ------------------------------------------------------- |
+| config | IConfig | Additional configuration parameters |
+| config.builderId | string | Unique builder ID, arbitrarily chosen, used for metrics |
+| config.dashboardLink | string | Path to dashboard page |
+| config.logo | string | Path to logo file |
+| config.colors.main | string | Color used for primary buttons and labels |
+| config.colors.secondary | string | Color used for borders and accents |
+| requestNetwork | [RequestNetwork](../../sdk-api-reference/request-client.js/requestnetwork/) | The RequestNetwork instance |
+| wagmiConfig | WagmiConfig | Wallet connector config |
+| currencies | Currency\[] | A list of custom currencies |
+
diff --git a/advanced/request-network-sdk/sdk-demo-apps/components/payment-widget.md b/advanced/request-network-sdk/sdk-demo-apps/components/payment-widget.md
new file mode 100644
index 0000000..271fb85
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-demo-apps/components/payment-widget.md
@@ -0,0 +1,76 @@
+---
+description: A widget that allows builders to accept crypto payments.
+---
+
+# Payment Widget
+
+
Screenshot of @requestnetwork/payment-widget@0.1.0
+
+The Payment Widget allows builders to accept crypto payments on their websites with minimal integration. It is built using [Svelte](https://svelte.dev/) but complied into a [Web Component](https://developer.mozilla.org/en-US/docs/Web/API/Web_components), making it usable in any web environment, regardless of the framework.
+
+
+
+## Installation
+
+```bash
+npm install @requestnetwork/payment-widget
+```
+
+## Usage
+
+### Usage in React and Next.js
+
+```tsx
+import PaymentWidget from "@requestnetwork/payment-widget/react";
+
+export default function PaymentPage() {
+ return (
+ {
+ console.log(request);
+ }}
+ onError={(error) => {
+ console.error(error);
+ }}
+ />
+ );
+}
+```
+
+
+
+## Props
+
+| Prop | Type | Description |
+| ----------------------- | ----------------- | -------------------------------------------------------------------------------------------------- |
+| amountInUSD | number | The total of the purchase in US Dollars |
+| sellerAddress | string | Address that would accept the payments |
+| supportedCurrencies | string\[] | An array of currency IDS that are supported by the seller |
+| sellerInfo.logo | string | (Optional) Seller logo |
+| sellerInfo | SellerInfo | (Optional) Information about the seller |
+| sellerInfo.name | string | (Optional) Seller name |
+| productInfo | ProductInfo | (Optional) Information about the product |
+| productInfo.name | string | (Optional) Name of the product |
+| productInfo.description | string | (Optional) Description of the product |
+| productInfo.image | string | (Optional) Product image |
+| persistRequest | boolean | (Optional) Defaults to true, when set to false the request data is not persisted to the blockchain |
+| showRNBranding | boolean | (Optional) Defaults to true, when set to false the "Powered by Request Network" banner is hidden |
+| builderId | string | (Optional) An ID added to request to identify request created by builder |
+| onPaymentSuccess | (request) => void | (Optional) Event that returns the Request data once the payment is successful. |
+| onError | (error) => void | (Optional) Event that returns the error when something goes wrong. |
+
diff --git a/advanced/request-network-sdk/sdk-demo-apps/request-checkout.md b/advanced/request-network-sdk/sdk-demo-apps/request-checkout.md
new file mode 100644
index 0000000..317e9ee
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-demo-apps/request-checkout.md
@@ -0,0 +1,47 @@
+# Request Checkout
+
+The playground for adding crypto payments to any website, build using [payment-widget.md](components/payment-widget.md "mention").
+
+
+
+### Request Invoicing Demo Video
+
+{% embed url="https://www.youtube.com/watch?v=FC6oJR5aKOQ" fullWidth="false" %}
+A video showing the Request Invoicing template where you can create, pay, and list all your requests.
+{% endembed %}
+
+## Features
+
+| Feature | Status |
+| ------------------------------------------------------------------------------------------------------------------------------------- | -------------------- |
+| ERC20 Payments | :white\_check\_mark: |
+| Native Token Payments | :white\_check\_mark: |
+| Conversion Payments | :white\_check\_mark: |
+| [rnf\_invoice format](https://github.com/RequestNetwork/requestNetwork/tree/master/packages/data-format/src/format/rnf_invoice) 0.3.0 | :white\_check\_mark: |
+| Configure Logo and Colors | :white\_check\_mark: |
+| Inject your own custom currency list | :white\_check\_mark: |
+| Download Invoice as PDF | :white\_check\_mark: |
+
+## Chains and Currencies
+
+
Currency Selectors from the Request Invoicing app
+
+### Payment Currencies
+
+| Chain | Currencies |
+| --------- | ------------------------- |
+| Ethereum | ETH, USDC, USDT, DAI, REQ |
+| Polygon | MATIC, USDC, USDT, DAI |
+| BNB Chain | DAI, BUSD |
+| Gnosis | USDC |
+| Optimism | ETH, USDC, USDT, DAI |
+| Base | ETH, USDC |
+| Sepolia | ETH, USDC, USDT, FAU |
+
+### Invoice Currencies
+
+Invoices can be denominated in the following fiat currencies, in addition to the [#payment-currencies](./#payment-currencies "mention")listed above.
+
+* USD
+* EUR
+* CNY
+* GBP
+* JPY
+
+### Request Invoicing Integration Video
+
+{% embed url="https://www.youtube.com/watch?v=dYlSVr94Ohg" %}
+A video showing how to integrate the Request Invoicing web components into a Next.js application.
+{% endembed %}
diff --git a/advanced/request-network-sdk/sdk-demo-apps/request-invoicing/pay-from-safe-multisig.md b/advanced/request-network-sdk/sdk-demo-apps/request-invoicing/pay-from-safe-multisig.md
new file mode 100644
index 0000000..7fa3fcc
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-demo-apps/request-invoicing/pay-from-safe-multisig.md
@@ -0,0 +1,18 @@
+---
+description: Instructions to pay a request from a Safe Multisig
+---
+
+# Pay from Safe Multisig
+
+The Request Network Templates and Example Apps support paying a request from a Safe multisig wallet.
+
+* When connecting your wallet, select **WalletConnect.**
+* Copy the **WalletConnect Pairing Code.**
+
+
+
+* Click the **WalletConnect** button on the Safe top-navigation bar and paste the **Pairing Code** into the resulting dialog.
+
+
+
+
diff --git a/advanced/request-network-sdk/sdk-guides/README.md b/advanced/request-network-sdk/sdk-guides/README.md
new file mode 100644
index 0000000..78a3b7d
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/README.md
@@ -0,0 +1,2 @@
+# SDK Guides
+
diff --git a/advanced/request-network-sdk/sdk-guides/encryption-and-decryption/README.md b/advanced/request-network-sdk/sdk-guides/encryption-and-decryption/README.md
new file mode 100644
index 0000000..2c6c520
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/encryption-and-decryption/README.md
@@ -0,0 +1,2 @@
+# Encryption and Decryption
+
diff --git a/advanced/request-network-sdk/sdk-guides/encryption-and-decryption/handle-encryption-with-a-web3-wallet.md b/advanced/request-network-sdk/sdk-guides/encryption-and-decryption/handle-encryption-with-a-web3-wallet.md
new file mode 100644
index 0000000..6b5fd49
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/encryption-and-decryption/handle-encryption-with-a-web3-wallet.md
@@ -0,0 +1,239 @@
+# Encrypt with a wallet signature using Lit Protocol
+
+This document outlines how to encrypt and decrypt requests using Lit Protocol. Encryption and decryption are performed using the end-user's wallet signatures, ensuring only they can access the data. Neither Request Network nor Lit Protocol can access the data without consent from the user.
+
+This allows the end-user to own their data without requiring them to know about or manage their public key, as is the case when they [handling-encryption-with-the-js-library.md](handling-encryption-with-the-js-library.md "mention").
+
+Encryption with Lit Protocol supports the Add Stakeholder feature for adding view access to a 3rd party other than the payee or payer.
+
+The LitCipherProvider is suitable for both frontend and backend use.
+
+## Introduction
+
+This implementation utilizes a two-step encryption process to secure sensitive data within requests:
+
+1. Symmetric Encryption: The data is first encrypted using a randomly generated symmetric key (e.g., AES-256). This provides efficient encryption for larger data payloads.
+2. Asymmetric Encryption with Lit Protocol: The symmetric key is then encrypted using Lit Protocol's decentralized key management network. Only authorized parties (payer and payee) can access the symmetric key and decrypt the data.
+
+{% hint style="info" %}
+For a deeper introduction to Encryption and Decryption in Request Network, see [private-requests-using-encryption.md](../../../protocol-overview/private-requests-using-encryption.md "mention")
+{% endhint %}
+
+## Benefits
+
+* Ease-of-use: Encrypt using a signature instead of a public key.
+* Efficiency: Symmetric encryption is efficient for large data, while Lit Protocol secures the key.
+* Decentralized Access Control: Lit Protocol ensures that only authorized parties can decrypt the data.
+
+## Architecture
+
+The system consists of three main components:
+
+* Request Network: Handles the creation, storage, and lifecycle of payment requests on the blockchain.
+* Lit Protocol: Provides a decentralized key management network and encryption capabilities.
+* Wallet Addresses: Used as the primary identifiers for access control in Lit Protocol.
+
+
+
+## Workflow
+
+### Encryption Process
+
+1. Request Creation: The payer creates a request object using the Request Network SDK.
+2. Symmetric Key Generation: A unique symmetric key is randomly generated.
+3. Data Encryption: The payee and payer encrypt the sensitive data within the request using the generated symmetric key.
+4. Encrypt Symmetric Key with Lit:
+ * Define Access Control Conditions: The payee and payer define access control conditions using Lit Actions, specifying that only the Ethereum addresses of the payer and payee can decrypt the symmetric key.
+ * Encrypt with Lit: The payee and payer encrypt the symmetric key using Lit's `encryptString` function, leveraging their wallet to sign the encryption.
+5. Store Encrypted Data: The payee and payer store the following on the Request Network:
+ * Encrypted request data
+ * Lit access control conditions
+ * Encrypted symmetric key
+
+### Decryption Process
+
+1. Retrieve Request: The payer and payee retrieve the following request data from the Request Network:
+ 1. Encrypted request data
+ 2. Lit access control conditions
+ 3. Encrypted symmetric key
+2. Decrypt Symmetric Key with Lit: The payer and payee use Lit's `decryptString` function with their wallet to decrypt the encrypted symmetric key. Lit Protocol verifies the payer's and payee's addresses against access control conditions. If authorized, the symmetric key is decrypted.
+3. Decrypt Data: The payer and payee use the decrypted symmetric key to decrypt the sensitive data.
+
+## Installation
+
+```bash
+npm install @requestnetwork/lit-protocol-cipher @requestnetwork/request-client.js ethers@5.7.2
+```
+
+## Usage
+
+```typescript
+import { LitProtocolCipherProvider } from '@requestnetwork/lit-protocol-cipher';
+import { RequestNetwork, Types } from '@requestnetwork/request-client.js';
+import { LitNodeClient } from '@lit-protocol/lit-node-client';
+
+// Node connection configuration
+const nodeConnectionConfig = {
+ baseURL: 'https://req-node.request.network',
+ connectionTimeout: 10000,
+ retry: {
+ retries: 3
+ }
+};
+
+// Initialize Lit Node Client
+const litClient = new LitNodeClient({
+ litNetwork: 'datil',
+ debug: false
+});
+
+// Initialize the Lit Provider
+const litProvider = new LitProtocolCipherProvider(
+ litClient,
+ nodeConnectionConfig,
+ 'ethereum' // optional chain parameter
+);
+
+// Connect to Lit Network
+await litProvider.initializeClient();
+
+// Initialize wallet and get session signatures
+const wallet = new Wallet('your-private-key');
+const address = await wallet.getAddress();
+
+// Get session signatures
+await litProvider.getSessionSignatures(wallet, address);
+
+// Enable decryption
+litProvider.enableDecryption(true);
+
+// Initialize Request Network
+const requestNetwork = new RequestNetwork({
+ cipherProvider: litProvider,
+ signatureProvider: new Web3SignatureProvider(wallet),
+ nodeConnectionConfig
+});
+```
+
+#### Creating Encrypted Requests
+
+```typescript
+const payeeIdentity = {
+ type: Types.Identity.TYPE.ETHEREUM_ADDRESS,
+ value: 'payee-ethereum-address'
+};
+
+const payerIdentity = {
+ type: Types.Identity.TYPE.ETHEREUM_ADDRESS,
+ value: 'payer-ethereum-address'
+};
+
+// Define encryption parameters
+const encryptionParams = [
+ {
+ key: payeeIdentity.value,
+ method: Types.Encryption.METHOD.KMS
+ },
+ {
+ key: payerIdentity.value,
+ method: Types.Encryption.METHOD.KMS
+ }
+];
+
+// Create request parameters
+const requestCreateParameters = {
+ requestInfo: {
+ currency: {
+ type: Types.RequestLogic.CURRENCY.ERC20,
+ value: '0x370DE27fdb7D1Ff1e1BaA7D11c5820a324Cf623C',
+ network: 'sepolia',
+ },
+ expectedAmount: '1000000000000000000',
+ payee: payeeIdentity,
+ payer: payerIdentity,
+ timestamp: Utils.getCurrentTimestampInSecond(),
+ },
+ paymentNetwork: {
+ id: Types.Extension.PAYMENT_NETWORK_ID.ERC20_FEE_PROXY_CONTRACT,
+ parameters: {
+ paymentNetworkName: 'sepolia',
+ paymentAddress: payeeIdentity.value,
+ feeAddress: '0x0000000000000000000000000000000000000000',
+ feeAmount: '0',
+ },
+ },
+ contentData: {
+ reason: '🍕',
+ dueDate: '2023.06.16',
+ },
+ signer: payeeIdentity,
+};
+
+// Create the encrypted request
+const request = await requestNetwork._createEncryptedRequest({
+ requestParameters: requestCreateParameters,
+ encryptionParams
+});
+```
+
+#### Decrypting Requests
+
+```typescript
+// Fetch an existing request
+const requestId = "request_id_here";
+const request = await requestNetwork.fromRequestId(requestId);
+
+// If you have the correct permissions (wallet address in encryption params),
+// and decryption is enabled, the data will be automatically decrypted
+const requestData = await request.getData();
+
+// The decrypted data will include:
+console.log({
+ requestInfo: requestData.requestInfo,
+ paymentNetwork: requestData.paymentNetwork,
+ contentData: requestData.contentData,
+ state: requestData.state
+});
+```
+
+#### Disable Decryption
+
+```typescript
+// Disable decryption
+litProvider.enableDecryption(false)
+```
+
+#### Decryption Requirements
+
+1. The wallet address must be included in the original encryption parameters
+2. Session signatures must be valid
+3. Decryption must be enabled
+4. The Lit Protocol client must be connected
+
+#### Cleanup
+
+```typescript
+// Proper cleanup sequence
+try {
+ // First disconnect the wallet
+ await litProvider.disconnectWallet();
+
+ // Then disconnect the client
+ await litProvider.disconnectClient();
+} catch (error) {
+ console.error('Cleanup error:', error);
+}
+```
+
+### ICipherProvider Interface
+
+```typescript
+interface ICipherProvider {
+ encrypt(data: any, options: any): Promise;
+ decrypt(encryptedData: any, options: any): Promise;
+ isEncryptionAvailable(): boolean;
+ isDecryptionAvailable(): boolean;
+ enableDecryption(option: boolean): void;
+ isDecryptionEnabled(): boolean;
+}
+```
diff --git a/advanced/request-network-sdk/sdk-guides/encryption-and-decryption/handling-encryption-with-the-js-library.md b/advanced/request-network-sdk/sdk-guides/encryption-and-decryption/handling-encryption-with-the-js-library.md
new file mode 100644
index 0000000..56ec803
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/encryption-and-decryption/handling-encryption-with-the-js-library.md
@@ -0,0 +1,145 @@
+# Encrypt with an Ethereum private key
+
+{% hint style="warning" %}
+Manipulating private keys must be done with care. Losing them can lead to a loss of data, privacy or non-repudiation safety!
+{% endhint %}
+
+{% hint style="info" %}
+For an introduction to Encryption and Decryption in Request Network, see [private-requests-using-encryption.md](../../../protocol-overview/private-requests-using-encryption.md "mention")
+{% endhint %}
+
+A request can be encrypted to make its details private to selected stakeholders. In this guide, we won't explain how encryption is managed under the hood. We will mention encryption or decryption of requests with payers and payees keys. Although in practice, we will use an intermediate symmetric key. See more details on [github](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/transaction-manager/specs/encryption.md).
+
+The transaction layer manages the encryption, [see more details on the Request Protocol section](../../../introduction-to-the-request-protocol/transaction.md).
+
+To manipulate encrypted requests you need a CipherProvider (recommended) or DecryptionProvider (deprecated). Both of them require direct access to the private key. They're best suited for backends.
+
+* **EthereumPrivateKeyCipherProvider:** Provides both encryption and decryption utilities.
+* **EthereumPrivateKeyDecryptionProvider** (deprecated) provides only decryption utilities.
+
+### Create an encrypted request
+
+#### EthereumPrivateKeyCipherProvider
+
+See on [Github](https://github.com/RequestNetwork/requestNetwork/tree/master/packages/epk-cipher).
+
+```typescript
+import { EthereumPrivateKeyCipherProvider } from '@requestnetwork/epk-cipher';
+
+const cipherProvider = new EthereumPrivateKeyCipherProvider({
+ # Warning: private keys should never be stored in clear, this is a basic tutorial
+ key: '0x4025da5692759add08f98f4b056c41c71916a671cedc7584a80d73adc7fb43c0',
+ method: RequestNetwork.Types.Encryption.METHOD.ECIES,
+});
+
+const requestNetwork = new RequestNetwork({
+ cipherProvider,
+ signatureProvider,
+ useMockStorage: true,
+});
+```
+
+Then you can create an encrypted request:
+
+```typescript
+const payeeEncryptionPublicKey = {
+ key: 'cf4a1d0bbef8bf0e3fa479a9def565af1b22ea6266294061bfb430701b54a83699e3d47bf52e9f0224dcc29a02721810f1f624f1f70ea3cc5f1fb752cfed379d',
+ method: RequestNetwork.Types.Encryption.METHOD.ECIES,
+};
+const payerEncryptionPublicKey = {
+ key: '299708c07399c9b28e9870c4e643742f65c94683f35d1b3fc05d0478344ee0cc5a6a5e23f78b5ff8c93a04254232b32350c8672d2873677060d5095184dad422',
+ method: RequestNetwork.Types.Encryption.METHOD.ECIES,
+};
+
+const invoice = await requestNetwork._createEncryptedRequest(
+ {
+ requestParameters,
+ signer: requestParameters.payee,
+ paymentNetwork,
+ },
+ [payeeEncryptionPublicKey, payerEncryptionPublicKey],
+);
+```
+
+Note: You must give at least one encryption key you can decrypt with the decryption provider. Otherwise, an error will be triggered after the creation.
+
+#### EthereumPrivateKeyDecryptionProvider
+
+{% hint style="warning" %}
+[EthereumPrivateKeyDecryptionProvider](https://github.com/RequestNetwork/requestNetwork/tree/master/packages/epk-decryption) is deprecated in favor of [#ethereumprivatekeycipherprovider](handling-encryption-with-the-js-library.md#ethereumprivatekeycipherprovider "mention")
+{% endhint %}
+
+### Get invoice information from its request ID
+
+Let's step back for a second: the requester sent a request that he encrypted with the payer's public key, as well as with his own, to retrieve it later. This is an essential and typical example, but a request can be encrypted with many keys to give access to its status and details.
+
+If the decryption provider knows a private key matching one of the keys used at the creation, it can decrypt it. Like a clear request you can get it from its request id.
+
+```typescript
+const invoiceFromRequestID = await requestNetwork.fromRequestId(requestId);
+
+const requestData = invoiceFromRequestID.getData();
+
+console.log(requestData);
+
+/* {
+ requestId,
+ currency,
+ expectedAmount,
+ payee,
+ payer,
+ timestamp,
+ extensions,
+ version,
+ events,
+ state,
+ creator,
+ meta,
+ balance,
+ contentData,
+} */
+```
+
+### Accepting/canceling an invoice information
+
+Like a clear request, you can update it if the decryption provider is instantiated with a matching private key.
+
+```typescript
+//Accept
+await request.accept(payerIdentity);
+
+//Cancel
+await request.cancel(payeeIdentity);
+
+//Increase the expected amount
+await request.decreaseExpectedAmountRequest(amount, payeeIdentity);
+
+//Decrease the expected amount
+await request.increaseExpectedAmountRequest(amount, payerIdentity);
+```
+
+### Enabling/Disabling Decryption
+
+```typescript
+// Disable decryption
+cipherProvider.enableDecryption(false);
+// Check if decryption is enabled
+const isEnabled = cipherProvider.isDecryptionEnabled();
+// Re-enable decryption
+cipherProvider.enableDecryption(true);
+```
+
+### Checking Capabilities
+
+```typescript
+// Check if encryption is available
+const canEncrypt = cipherProvider.isEncryptionAvailable();
+// Check if decryption is available
+const canDecrypt = cipherProvider.isDecryptionAvailable();
+// Check if an identity is registered
+const isRegistered = await cipherProvider.isIdentityRegistered({
+type: 'ethereum_address',
+value: '0x123...'
+});// Some code
+```
+
diff --git a/advanced/request-network-sdk/sdk-guides/encryption-and-decryption/share-an-encrypted-request.md b/advanced/request-network-sdk/sdk-guides/encryption-and-decryption/share-an-encrypted-request.md
new file mode 100644
index 0000000..1c1ffff
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/encryption-and-decryption/share-an-encrypted-request.md
@@ -0,0 +1,7 @@
+# Share an encrypted request
+
+The content of an encrypted request can be shared to additional third parties using the `addStakeholder` feature.
+
+Calling `request.addStakeholder()` allows any stakeholder of a request to add the public key of a third party as a stakeholder on a request. The third party can now read the content of the request.
+
+Feature exists. Docs coming soon...
diff --git a/advanced/request-network-sdk/sdk-guides/mobile-using-expo.md b/advanced/request-network-sdk/sdk-guides/mobile-using-expo.md
new file mode 100644
index 0000000..8e92d6d
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/mobile-using-expo.md
@@ -0,0 +1,78 @@
+# Mobile using Expo
+
+## Introduction
+
+This guide demonstrates how to integrate Request Network into a React Native application using Expo. Due to the differences between Node.js and React Native environments, several polyfills and configurations are necessary to make Request Network work properly. Following this guide will set up your Expo project to use Request Network, handle polyfills for missing modules, and ensure smooth integration.\
+\
+A full Github repository with Request Network support can be found [here](https://github.com/RequestNetwork/rn-expo-support).
+
+## Installation
+
+After creating a new Expo project, install the necessary dependencies:
+
+```bash
+npm install @requestnetwork/request-client.js @requestnetwork/types @requestnetwork/payment-processor @requestnetwork/epk-signature buffer eventemitter3 stream-browserify http-browserify https-browserify react-native-get-random-values tweetnacl node-forge ethers@5.5.1
+```
+
+## Setup
+
+1- Create a new file named `index.js` in the root of your project
+
+```bash
+touch index.js
+```
+
+2- Add the following content to `index.js`
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/rn-expo-support/blob/5a771c31051ce89c4feee533692028d45e1415ab/index.js" %}
+
+\
+3- Create a file named `cryptoPolyfill.js` in the root of your project
+
+```bash
+touch cryptoPolyfill.js
+```
+
+4- Add the following content to `cryptoPolyfill.js`
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/rn-expo-support/blob/5a771c31051ce89c4feee533692028d45e1415ab/cryptoPolyfill.js" %}
+
+5- Create / Update `metro.config.js` to use the custom polyfills
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/rn-expo-support/blob/5a771c31051ce89c4feee533692028d45e1415ab/metro.config.js" %}
+
+6- Update `package.json` to set the main entry point to `index.js`
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/rn-expo-support/blob/5a771c31051ce89c4feee533692028d45e1415ab/package.json" %}
+
+7- Ensure that `app.json` file includes the correct entry point
+
+```json
+{
+ "expo": {
+ "entryPoint": "./index.js",
+ ...
+ }
+}
+```
+
+## Polyfills and Configurations
+
+### Crypto Polyfills
+
+We've created a custom crypto polyfill (`cryptoPolyfill.js`) to provide the necessary cryptographic functions. This polyfill uses `tweetnacl` and `node-forge` libraries to implement various cryptographic operations.
+
+**Why `tweetnacl` and `node-forge`?**
+
+1. **`tweetnacl`**: It's a fast, secure, and easy-to-use cryptography library. It provides a pure JavaScript implementation of the NaCl cryptography library, which is particularly useful for generating random bytes, essential for cryptographic operations.
+2. **`node-forge`**: It provides a comprehensive set of cryptographic tools and utilities. It implements various cryptographic algorithms and protocols that are not natively available in React Native. It's used in our polyfill for operations like hashing, cipher creation, and PBKDF2 key derivation.
+
+Using these libraries allows us to implement a more complete set of cryptographic functions that closely mimic the Node.js crypto module, which is not available in React Native.
+
+## Important Notes
+
+1. Ensure you're using compatible versions of React Native and Expo.
+2. The crypto polyfill may not cover all use cases. Test thoroughly and adjust as needed.
+3. Be cautious when handling private keys. Never expose them in your code or version control.
+4. The example code uses environment variables for private keys. Ensure you set these up correctly and securely.
+
diff --git a/advanced/request-network-sdk/sdk-guides/payment/README.md b/advanced/request-network-sdk/sdk-guides/payment/README.md
new file mode 100644
index 0000000..daba587
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/payment/README.md
@@ -0,0 +1,2 @@
+# Payment
+
diff --git a/advanced/request-network-sdk/sdk-guides/payment/batch-payment.md b/advanced/request-network-sdk/sdk-guides/payment/batch-payment.md
new file mode 100644
index 0000000..ea34dc8
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/payment/batch-payment.md
@@ -0,0 +1,9 @@
+# Batch Payment
+
+## Functions:
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/requestNetwork/blob/master/packages/payment-processor/src/payment/batch-conversion-proxy.ts" %}
+
+## Tests:
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/requestNetwork/blob/master/packages/payment-processor/test/payment/batch-proxy.test.ts" %}
diff --git a/advanced/request-network-sdk/sdk-guides/payment/configuring-payment-fees.md b/advanced/request-network-sdk/sdk-guides/payment/configuring-payment-fees.md
new file mode 100644
index 0000000..7227cba
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/payment/configuring-payment-fees.md
@@ -0,0 +1,2 @@
+# Configuring Payment Fees
+
diff --git a/advanced/request-network-sdk/sdk-guides/payment/conversion-request.md b/advanced/request-network-sdk/sdk-guides/payment/conversion-request.md
new file mode 100644
index 0000000..d8a424f
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/payment/conversion-request.md
@@ -0,0 +1,3 @@
+# Conversion Payment
+
+A "conversion" request is one that is denominated in one currency but paid in another currency. This is facilitated by on-chain price feeds provided by oracles. The typical use case is to denominate a request in fiat like USD and pay the request in stablecoins like USDC or DAI.
diff --git a/advanced/request-network-sdk/sdk-guides/payment/declarative-request.md b/advanced/request-network-sdk/sdk-guides/payment/declarative-request.md
new file mode 100644
index 0000000..a3d6fea
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/payment/declarative-request.md
@@ -0,0 +1,5 @@
+# Declarative Payment
+
+## Example:
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/quickstart-node-js/blob/main/src/declarePaymentSentAndReceived.js" %}
diff --git a/advanced/request-network-sdk/sdk-guides/payment/detect-a-payment.md b/advanced/request-network-sdk/sdk-guides/payment/detect-a-payment.md
new file mode 100644
index 0000000..8bcce6e
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/payment/detect-a-payment.md
@@ -0,0 +1,7 @@
+# Detect a payment
+
+Request payments can be detected easily, thanks to the integration of The Graph.
+
+Our [payment-subgraphs](https://github.com/RequestNetwork/payments-subgraph) indexes Request's proxy smart contracts and allow you to query payment data easily.
+
+Other methods are available to detect a payment by simply watching the Proxy Smart Contract used for payment. Payment transactions include a `paymentReference` that links them to the request.
diff --git a/advanced/request-network-sdk/sdk-guides/payment/escrow-request.md b/advanced/request-network-sdk/sdk-guides/payment/escrow-request.md
new file mode 100644
index 0000000..ff2a2dd
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/payment/escrow-request.md
@@ -0,0 +1,18 @@
+# Escrow Payment
+
+## Escrow
+
+The Request Network Escrow isn't a separate payment network. Rather, it builds on top of the `ERC20_FEE_PROXY_CONTRACT` payment network.
+
+## Typical Workflow
+
+1. Using the [`request-client.js`](../../sdk-api-reference/request-client.js/) package, the `payer` creates a request with the `ERC20_FEE_PROXY_CONTRACT` payment network.
+2. Using the [`payment-processor`](../../sdk-api-reference/payment-processor/) package, `payer`:
+ 1. Approves the escrow contract using `approveErc20ForEscrow()`
+ 2. Pays the escrow contract using `payEscrow()`
+ 3. Waits until the work is complete
+ 4. Pays the payee from the Escrow contract using `payRequestFromEscrow()`
+
+These steps are shown by our unit tests:
+
+[https://github.com/RequestNetwork/requestNetwork/blob/master/packages/payment-processor/test/payment/erc20-escrow-payment.test.ts#L200-L339](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/payment-processor/test/payment/erc20-escrow-payment.test.ts#L200-L339)
diff --git a/advanced/request-network-sdk/sdk-guides/payment/hinkal-private-payments.md b/advanced/request-network-sdk/sdk-guides/payment/hinkal-private-payments.md
new file mode 100644
index 0000000..e85e076
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/payment/hinkal-private-payments.md
@@ -0,0 +1,106 @@
+# Hinkal Private Payments
+
+The Request Network SDK supports Hinkal Private Payments using ERC-20 tokens. Hinkal is a middleware and suite of smart contracts on EVM-compatible chains that leverage zero-knowledge proofs and private addresses to facilitate compliant and private transactions.
+
+Each public address has exactly one Hinkal private address.
+
+The `@requestnetwork/payment-processor` package provides functions to:
+
+* **Pay a request from a Hinkal private address to a public address:** such that the payment sender's public address never appears on-chain.
+* **Deposit to a Hinkal private address from a public address**: such that the payment recipient's public address never appears on-chain. Callers can choose to deposit to their own private address or someone else's private address.
+
+{% hint style="info" %}
+Paying a request where the payment recipient address is a Hinkal private address is not supported because the Request Network payment proxy smart contracts can only send funds to public addresses. Consider using [declarative-request.md](declarative-request.md "mention") instead.
+{% endhint %}
+
+## Benefits
+
+* **Privacy**: Obfuscates payer address when paying a request.
+* **Compliance**: Ensures transactions adhere to regulatory requirements. See [Hinkal Compliance](https://hinkal-team.gitbook.io/hinkal/hinkal-wallet/compliance) for details
+
+## Supported Chains
+
+See [Hinkal Supported Chains](https://hinkal-team.gitbook.io/hinkal/ecosystem/supported-chains) for a list of chains on which Hinkal Private Payments are supported.
+
+## Installation
+
+To use Hinkal Private Payments, install the necessary package:
+
+```bash
+npm install @requestnetwork/payment-processor
+```
+
+## Usage
+
+### **Pay a request from a Hinkal private address**
+
+To pay a request from a Hinkal private address to a public address, where only the payment sender's address is obfuscated, use the \``` payErc20FeeProxyRequestFromHinkalShieldedAddress()` `` function. Ensure the payment sender's Hinkal private address has a positive balance using [#deposit-to-a-hinkal-private-address](hinkal-private-payments.md#deposit-to-a-hinkal-private-address "mention")
+
+{% hint style="warning" %}
+Strongly consider using [encryption-and-decryption](../encryption-and-decryption/ "mention") to keep the request contents private, including the payer and payee identity addresses, when paying requests from a Hinkal private address. Revealing the payer and payee identity addresses increases the likelihood of un-shielding the payment sender's address via on-chain analysis.
+{% endhint %}
+
+```typescript
+import {
+ payErc20FeeProxyRequestFromHinkalShieldedAddress,
+} from '@requestnetwork/payment-processor';
+
+// Instantiation of `RequestNetwork` and `Signer` omitted for brevity
+
+const request = await requestClient.fromRequestId('insert request id');
+const requestData = request.getData();
+
+const relayerTx = await payErc20FeeProxyRequestFromHinkalShieldedAddress(
+ requestData,
+ signer,
+);
+```
+
+{% hint style="info" %}
+See [quickstart-browser.md](../../get-started/quickstart-browser.md "mention") for how to instantiate a `RequestNetwork` and `Signer`
+{% endhint %}
+
+### Deposit to a Hinkal private address
+
+To deposit funds to a Hinkal private address from a public address, where only the payment recipient's address is obfuscated, use the `sendToHinkalShieldedAddressFromPublic()` function.
+
+* Deposit to own Hinkal shielded address: omit the `recipientInfo` argument
+* Deposit to someone else's Hinkal shielded address: set `recipientInfo` to the shielded address of the payment recipient.
+
+{% hint style="info" %}
+Hinkal private addresses must be shared out-of-band. This SDK doesn't offer functions for sharing Hinkal private addresses.
+{% endhint %}
+
+{% code overflow="wrap" %}
+```typescript
+import {
+ sendToHinkalShieldedAddressFromPublic,
+} from '@requestnetwork/payment-processor';
+
+// Instantiation of `Signer` omitted for brevity
+
+const recipientShieldedAddress = '142590100039484718476239190022599206250779986428210948946438848754146776167,0x096d6d5d8b2292aa52e57123a58fc4d5f3d66171acd895f22ce1a5b16ac51b9e,0xc025ccc6ef46399da52763a866a3a10d2eade509af27eb8411c5d251eb8cd34d'
+const tx = await sendToHinkalShieldedAddressFromPublic({
+ signerOrProvider: paymentSender,
+ tokenAddress: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913', // USDC on Base
+ amount: '1000000', // 1 USDC
+ recipientInfo: recipientShieldedAddress, // omit to deposit to own Hinkal shielded address
+})
+```
+{% endcode %}
+
+{% hint style="info" %}
+See [quickstart-browser.md](../../get-started/quickstart-browser.md "mention") for how to instantiate a `Signer`
+{% endhint %}
+
+## **Content Security Policy**
+
+The Hinkal SDK depends on [snarkjs](https://www.npmjs.com/package/snarkjs), a powerful library that enables local zero-knowledge proving in browser and Node.js environments. Snarkjs leverages [WebAssembly](https://webassembly.org/) to perform complex cryptographic computations efficiently.
+
+As a result, any client-side application integrating the Hinkal SDK must adjust its **Content-Security-Policy** to allow the `wasm-unsafe-eval` directive under the `script-src` setting. This configuration ensures that the cryptographic processes can execute properly.
+
+See [Hinkal SDK Integration](https://hinkal-team.gitbook.io/hinkal/developers/sdk-integration) for more details.
+
+## Details
+
+For more details about Hinkal Private Payments, refer to [Pull Request #1482](https://github.com/RequestNetwork/requestNetwork/pull/1482) on GitHub.
diff --git a/advanced/request-network-sdk/sdk-guides/payment/meta-payments.md b/advanced/request-network-sdk/sdk-guides/payment/meta-payments.md
new file mode 100644
index 0000000..cf54b7a
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/payment/meta-payments.md
@@ -0,0 +1,5 @@
+# Meta Payments
+
+## Tests:
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/requestNetwork/blob/master/packages/advanced-logic/test/extensions/payment-network/meta.test.ts" %}
diff --git a/advanced/request-network-sdk/sdk-guides/payment/native-payment.md b/advanced/request-network-sdk/sdk-guides/payment/native-payment.md
new file mode 100644
index 0000000..a5d5880
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/payment/native-payment.md
@@ -0,0 +1,2 @@
+# Native Payment
+
diff --git a/advanced/request-network-sdk/sdk-guides/payment/pay-through-a-proxy-contract-with-a-multisig.md b/advanced/request-network-sdk/sdk-guides/payment/pay-through-a-proxy-contract-with-a-multisig.md
new file mode 100644
index 0000000..df8b40b
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/payment/pay-through-a-proxy-contract-with-a-multisig.md
@@ -0,0 +1,71 @@
+# Pay through a proxy-contract with a multisig
+
+The imports you will need:
+
+```typescript
+import { Contract, ContractTransaction, Signer } from 'ethers';
+import {
+ encodeApproveErc20,
+ encodePayErc20Request,
+} from '@requestnetwork/payment-processor/dist/payment/erc20-proxy';
+import { getRequestPaymentValues } from '@requestnetwork/payment-processor/dist/payment/utils';
+import { ClientTypes } from '@requestnetwork/types';
+```
+
+In this example, we will use the [Gnosis multisig](https://github.com/gnosis/MultiSigWallet/blob/master/contracts/MultiSigWallet.sol). Here is its partial abi:
+
+```typescript
+const multisigAbi = [
+ 'function submitTransaction(address _destination, uint _value, bytes _data) returns (uint)',
+];
+```
+
+## Pay ETH request
+
+```typescript
+export const payEthWithMultisig = async (
+ request: ClientTypes.IRequestData,
+ multisigAddress: string,
+ signer: Signer,
+): Promise => {
+ const multisigContract = new Contract(multisigAddress, multisigAbi, signer);
+ const { paymentAddress, paymentReference } = getRequestPaymentValues(request);
+ return multisigContract.submitTransaction(paymentAddress, 0, paymentReference);
+};
+```
+
+## Pay ERC20 request
+
+### Approve ERC20 spending
+
+```typescript
+export const approveErc20WithMultisig = async (
+ request: ClientTypes.IRequestData,
+ multisigAddress: string,
+ signer: Signer,
+): Promise => {
+ const multisigContract = new Contract(multisigAddress, multisigAbi, signer);
+ const tokenAddress = request.currencyInfo.value;
+ return multisigContract.submitTransaction(tokenAddress, 0, encodeApproveErc20(request, signer));
+};
+```
+
+### Pay ERC20 request
+
+```typescript
+import { erc20FeeProxyArtifact } from '@requestnetwork/smart-contracts';
+
+export const payErc20WithMultisig = async (
+ request: ClientTypes.IRequestData,
+ multisigAddress: string,
+ signer: Signer,
+): Promise => {
+ const multisigContract = new Contract(multisigAddress, multisigAbi, signer);
+ const proxyAddress = erc20FeeProxyArtifact.getAddress(request.currencyInfo.network);
+ return multisigContract.submitTransaction(
+ proxyAddress,
+ 0,
+ encodePayErc20Request(request, signer),
+ );
+};
+```
diff --git a/advanced/request-network-sdk/sdk-guides/payment/single-request-forwarder.md b/advanced/request-network-sdk/sdk-guides/payment/single-request-forwarder.md
new file mode 100644
index 0000000..a1e865e
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/payment/single-request-forwarder.md
@@ -0,0 +1,100 @@
+# Single Request Forwarder
+
+## Overview
+
+The Single Request Forwarder is a smart contract solution that enables integration with Request Network's payment system without modifying existing smart contracts.
+
+
Single Request Forwarder Payment Flow
+
+{% hint style="info" %}
+The Single Request Forwarder Factory contact addresses can be found : [smart-contract-addresses.md](../../../../general/supported-chains/smart-contract-addresses.md "mention")
+
+The contract name is `SingleRequestProxyFactory`
+{% endhint %}
+
+## Key Benefits:
+
+* **Universal Compatibility:** Works with any system that can make standard crypto transfers.
+* **No Code Changes**: Integrate with Request Network without modifying existing smart contracts.
+* **Exchange Friendly:** Enable payments from centralized exchanges.
+
+## How it works:
+
+1. **Request**: Create a request in the Request Network protocol
+2. **Deploy:** Deploy a unique Single Request Forwarder for your request
+3. **Pay:** The Payer sends funds to the Single Request Forwarder
+4. **Complete:** The Single Request Forwarder forwards the payment to the Payee and emits an event to enable payment detection.
+
+## Integration Guide
+
+### Create a request
+
+{% hint style="info" %}
+For a complete guide on request creation, see [#create-a-request](../../get-started/quickstart-browser.md#create-a-request "mention")
+{% endhint %}
+
+```typescript
+const request = await requestClient.createRequest(requestCreateParameters);
+
+const requestData = request.getData()
+
+// In case of in-memory request
+ const requestData = request.inMemoryInfo.requestData
+```
+
+### Deploy Single Request Forwarder
+
+To deploy a Single Request Forwarder, call `deploySingleRequestForwarder()` which takes in the following arguments:
+
+* **`requestData`:** the data of the created request
+* **`signer`:** An Ethers v5 Signer to sign the deployment transaction
+
+The `deploySingleRequestForwarder()` function automatically deploys the correct type of Single Request **Forwarder** based on the Request data passed into the function; either an Ethereum Single Request Forwarder or ERC20 Single Request Forwarder
+
+It returns
+
+* **Single Request Forwarder Address**
+
+```typescript
+import { deploySingleRequestForwarder } from "@requestnetwork/payment-processor"
+
+ const forwarderAddress = await deploySingleRequestForwarder(
+ requestData,
+ signer
+ );
+
+console.log(`Single Request Forwarder Deployed At: ${forwarderAddress}`)
+// Single Request Forwarder Deployed At : 0x1234567890123456789012345678901234567890
+```
+
+### Pay through a Single Request **Forwarder**
+
+#### Pay through a Single Request **Forwarder** using the RN SDK
+
+To pay a request through a Single Request **Forwarder** using the Request Network SDK, call `payRequestWithSingleRequestForwarder()` which takes in the following arguments:
+
+* **`singleRequestForwarderAddress`:** the address of the SRP deployed in the previous step.
+* **`signer`:** A wallet signer who is making the transfer of funds.
+* **`amount`:** Amount of funds that need to be transferred**.**
+
+```typescript
+import { payRequestWithSingleRequestForwarder } from "@requestnetwork/payment-processor"
+import { utils } from "ethers"
+const paymentAmount = utils.parseUnits("1" , 18)
+await payRequestWithSingleRequestForwarder(forwarderAddress , signer, paymentAmount)
+```
+
+#### Pay through a Single Request **Forwarder** using a Direct Transfer
+
+Once we have the **Single Request Forwarder** address, we can pay by directly transferring the money to the address itself. The Single Request Forwarder will automatically process the payment.\
+\
+For ERC20 payments, the process of paying with a **Single Request Forwarder** happens in two steps:
+
+* Transferring the tokens to the **Single Request Forwarder**
+* Make a zero-value transaction to the **Single Request Forwarder** (i.e. Send 0 ETH to the contract)
+
+## Design Features:
+
+* **Single Use:** Each **Single Request Forwarder** deployment processes payments for a specific request.
+* **Immutable Parameters:** Payment details cannot be modified after deployment.
+* **Fund Recovery:** Built-in mechanisms to send stuck funds to the payment receiver.
diff --git a/advanced/request-network-sdk/sdk-guides/payment/streaming-request.md b/advanced/request-network-sdk/sdk-guides/payment/streaming-request.md
new file mode 100644
index 0000000..f4194ed
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/payment/streaming-request.md
@@ -0,0 +1,52 @@
+---
+description: Pay a series of requests with a stream of ERC777 Super Tokens from Superfluid.
+---
+
+# Streaming Payment
+
+The first request of a series is very similar to [payment-network-erc20-fee-proxy](https://github.com/RequestNetwork/requestNetwork/blob/7be84246d3012959739a99db6463062374f6cd91/packages/advanced-logic/specs/payment-network-erc20-fee-proxy-contract-0.1.0.md), it defines the `salt`, `paymentAddress` and `requestId` to compute the `paymentReference` used for the whole series.
+
+Other requests must define a `previousRequestId` and cannot redefine any of the payment properties (`paymentAddress`, `feeAddress` or `salt`).
+
+Multiple requests can be paid with the same stream, typically recurring requests of fixed amounts paid continuously. A group of requests payable with the same stream are called a request series, they must all have the same currency.
+
+For additional details, see the [payment-network-erc777-stream-0.1.0 specification](https://github.com/RequestNetwork/requestNetwork/blob/7be84246d3012959739a99db6463062374f6cd91/packages/advanced-logic/specs/payment-network-erc777-stream-0.1.0.md)
+
+## Create a Streaming Request
+
+To create a streaming request, [#create-a-request](../../get-started/quickstart-node.js.md#create-a-request "mention") like normal, but set the `paymentNetwork` parameter to the `ERC777_STREAM` payment network.
+
+### Create the first request in a series
+
+```typescript
+ // The paymentNetwork is the method of payment and related details.
+ paymentNetwork: {
+ id: Types.Extension.PAYMENT_NETWORK_ID.ERC777_STREAM,
+ parameters: {
+ expectedFlowRate: expectedFlowRate // number, Expected amount of request currency per second
+ expectedStartDate: expectedStartDate // timestamp, Expected start of stream
+ paymentAddress: payeeIdentity,
+ },
+ },
+```
+
+### Create subsequent requests in a series
+
+```
+ // The paymentNetwork is the method of payment and related details.
+ paymentNetwork: {
+ id: Types.Extension.PAYMENT_NETWORK_ID.ERC777_STREAM,
+ parameters: {
+ originalRequestId: 'abcd', // first reqeust in the series
+ previousRequestId: 'abcd', // previous request in the series
+ recurrenceNumber: 1, // 1 if previous request is original, 2+ otherwise
+ },
+ },
+```
+
+## Tests
+
+See Github for tests showing usage.
+
+* [https://github.com/RequestNetwork/requestNetwork/blob/master/packages/advanced-logic/test/extensions/payment-network/erc777/stream.test.ts](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/advanced-logic/test/extensions/payment-network/erc777/stream.test.ts)
+* [https://github.com/RequestNetwork/requestNetwork/tree/master/packages/payment-detection/test/erc777](https://github.com/RequestNetwork/requestNetwork/tree/master/packages/payment-detection/test/erc777)
diff --git a/advanced/request-network-sdk/sdk-guides/payment/swap-to-conversion-request.md b/advanced/request-network-sdk/sdk-guides/payment/swap-to-conversion-request.md
new file mode 100644
index 0000000..170efd2
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/payment/swap-to-conversion-request.md
@@ -0,0 +1,11 @@
+# Swap-to-Conversion Payment
+
+A "swap-to-conversion" payment is where the request is denominated in currency A, the payer sends currency B and the payee receives currency C.
+
+## Payment Processor Functions:
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/requestNetwork/blob/master/packages/payment-processor/src/payment/swap-conversion-erc20.ts" %}
+
+## Payment Processor Test:
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/requestNetwork/blob/master/packages/payment-processor/test/payment/swap-any-to-erc20.test.ts" %}
diff --git a/advanced/request-network-sdk/sdk-guides/payment/swap-to-pay-request.md b/advanced/request-network-sdk/sdk-guides/payment/swap-to-pay-request.md
new file mode 100644
index 0000000..8357bc0
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/payment/swap-to-pay-request.md
@@ -0,0 +1,11 @@
+# Swap-to-Pay Payment
+
+A "swap-to-pay" payment is where the payment sender sends one currency but the payment recipient receives a different currency.
+
+## Functions:
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/requestNetwork/blob/master/packages/payment-processor/src/payment/swap-erc20-fee-proxy.ts" %}
+
+## Tests:
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/requestNetwork/blob/master/packages/payment-processor/test/payment/swap-erc20-fee-proxy.test.ts" %}
diff --git a/advanced/request-network-sdk/sdk-guides/payment/transferable-receivable-payment.md b/advanced/request-network-sdk/sdk-guides/payment/transferable-receivable-payment.md
new file mode 100644
index 0000000..a74d916
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/payment/transferable-receivable-payment.md
@@ -0,0 +1,9 @@
+# Transferable Receivable Payment
+
+## Functions:
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/requestNetwork/blob/master/packages/payment-processor/src/payment/erc20-transferable-receivable.ts" %}
+
+## Tests:
+
+{% @github-files/github-code-block url="https://github.com/RequestNetwork/requestNetwork/blob/master/packages/payment-processor/test/payment/erc20-transferable-receivable.test.ts" %}
diff --git a/advanced/request-network-sdk/sdk-guides/request-client/README.md b/advanced/request-network-sdk/sdk-guides/request-client/README.md
new file mode 100644
index 0000000..462e12c
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/request-client/README.md
@@ -0,0 +1,2 @@
+# Request Client
+
diff --git a/advanced/request-network-sdk/sdk-guides/request-client/configure-the-request-client.md b/advanced/request-network-sdk/sdk-guides/request-client/configure-the-request-client.md
new file mode 100644
index 0000000..0224471
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/request-client/configure-the-request-client.md
@@ -0,0 +1,28 @@
+# Configure the Request Client
+
+## Configure the client
+
+The following command creates a new Request Client instance and configures it to :
+
+* Connect to the Gnosis Request Node Gateway maintained by the Request Network Foundation.
+* Use the web3-signature package to create requests using a web3 wallet like Metamask.
+
+```tsx
+const web3SignatureProvider = new Web3SignatureProvider(provider);
+const requestClient = new RequestNetwork({
+ nodeConnectionConfig: {
+ baseURL: 'https://xdai.gateway.request.network/'
+ },
+ signatureProvider: web3SignatureProvider,
+});
+```
+
+### Mock Storage
+
+To create mock storage requests, where the request is stored in memory on the local machine and cleared as soon as the script is finished running, set the `useMockStorage` argument to `true` when instantiating the `RequestNetwork`object.
+
+```typescript
+const requestClient = new RequestNetwork({
+ useMockStorage: true,
+});
+```
diff --git a/advanced/request-network-sdk/sdk-guides/request-client/in-memory-requests.md b/advanced/request-network-sdk/sdk-guides/request-client/in-memory-requests.md
new file mode 100644
index 0000000..14774e4
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/request-client/in-memory-requests.md
@@ -0,0 +1,104 @@
+# In-Memory Requests
+
+## Overview
+
+In-memory requests allow for creating and managing requests without immediately persisting them to storage. This enables faster payment workflows and deferred persistence.
+
+## Key benefits:
+
+* **Faster payment flow:** In-memory requests are helpful when payment is the priority, such as in e-commerce cases. In this scenario, the request is a receipt rather than an invoice.
+* **Deferred Persistence:** With in-memory requests, a request can be created on the front end with a user's signature and passed on to the backend for persistence.
+
+## How it works:
+
+The flow of creating and paying an in-memory request is similar to a regular request with the following key differences:
+
+* Create an in-memory request by passing the argument `skipPeristence: true` when instantiating the `RequestNetwork` instance.
+* An in-memory request is _not_ persisted immediately like normal requests. Instead, it is stored in memory on the device where it was created. It can be persisted at a later time using the `persistTransaction()`function.
+* An in-memory request has the `inMemoryInfo` property.
+* Avoid calling `getData()` on an in-memory request because it will fail silently by returning an empty `EventEmitter` object.
+* Retrieving an in-memory request with `requestClient.fromRequestId()` will fail because the request has not been persisted yet so it is not possible to read it from the Request Node.
+
+{% stepper %}
+{% step %}
+### Install necessary dependencies
+
+To create in-memory requests, it is necessary to install the following package:
+
+```bash
+npm install @requestnetwork/request-client.js
+```
+
+Along with the following package for payments:
+
+```bash
+npm install @requestnetwork/payment-processor
+```
+{% endstep %}
+
+{% step %}
+### Create an in-memory request
+
+Create an in-memory request by passing the argument `skipPeristence: true` when instantiating the `RequestNetwork` instance.
+
+
+{% endstep %}
+
+{% step %}
+### Pay an in-memory request
+
+To pay an in-memory request, pass the `inMemoryInfo.requestData` property to the payment function.
+
+```typescript
+import {
+ payRequest
+} from "@requestnetwork/payment-processor";
+
+const paymentTx = await payRequest(
+ inMemoryRequest.inMemoryInfo.requestData,
+ signer
+ );
+
+await paymentTx.wait(confirmationBlocks);
+
+```
+{% endstep %}
+
+{% step %}
+### Persist in-memory request
+
+In-memory requests need to be persisted using a new `RequestNetwork` client that does not use the `skipPersistence` property.
+
+```typescript
+const persistingRequestNetwork = new RequestNetwork({
+ nodeConnectionConfig: {
+ baseURL: "https://gnosis.gateway.request.network",
+ },
+ });
+
+await persistingRequestNetwork.persistRequest(inMemoryRequest);
+```
+{% endstep %}
+{% endstepper %}
+
+[^1]: Configure the RequestNetwork instance to produce in-memory requests
+
diff --git a/advanced/request-network-sdk/sdk-guides/request-client/payment-reference.md b/advanced/request-network-sdk/sdk-guides/request-client/payment-reference.md
new file mode 100644
index 0000000..1992288
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/request-client/payment-reference.md
@@ -0,0 +1,18 @@
+# Payment Reference
+
+In the Reference-based Payment Networks, Payments are linked to Requests via a `paymentReference` which is derived from the `requestId` and payment recipient address.
+
+This `paymentReference` consists of the last 8 bytes of a salted hash of the `requestId` and payment recipient address, concatenated :
+
+```typescript
+last8Bytes(hash(lowercase(requestId + salt + address)))
+```
+
+* `requestId` is the id of the request
+* `salt` is a random number with at least 8 bytes of randomness. It must be unique to each request
+* `address` is the payment address for payments, the refund address for refunds
+* `lowercase()` transforms all characters to lowercase
+* `hash()` is a keccak256 hash function
+* `last8Bytes()` take the last 8 bytes
+
+Use the [paymentreferencecalculator.md](../../sdk-api-reference/request-client.js/paymentreferencecalculator.md "mention") to calculate the payment reference.
diff --git a/advanced/request-network-sdk/sdk-guides/request-client/retrieve-a-request.md b/advanced/request-network-sdk/sdk-guides/request-client/retrieve-a-request.md
new file mode 100644
index 0000000..db3b3ae
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/request-client/retrieve-a-request.md
@@ -0,0 +1,23 @@
+# Compute a Request ID without creating the request
+
+
/** Create request parameters */
+export interface ICreateRequestParameters {
+ requestInfo: RequestLogic.ICreateParameters | IRequestInfo;
+ signer: Identity.IIdentity;
+ paymentNetwork?: Payment.PaymentNetworkCreateParameters;
+ topics?: any[];
+ contentData?: any;
+ disablePaymentDetection?: boolean;
+ disableEvents?: boolean;
+}
+
+ /**
+ * Gets the ID of a request without creating it.
+ *
+ * @param requestParameters Parameters to create a request
+ * @returns The requestId
+ */
+ public async computeRequestId(
+ parameters: Types.ICreateRequestParameters,
+ ): Promise<RequestLogicTypes.RequestId>
+
diff --git a/advanced/request-network-sdk/sdk-guides/request-client/support-a-new-currency.md b/advanced/request-network-sdk/sdk-guides/request-client/support-a-new-currency.md
new file mode 100644
index 0000000..ba84299
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/request-client/support-a-new-currency.md
@@ -0,0 +1,14 @@
+# Support a new currency
+
+Request Network allows you to support any currency. Head out to the [currency](https://github.com/RequestNetwork/requestNetwork/tree/master/packages/currency) package to see how we identify and manage currencies in the `CurrencyManager`. You don't need to add new currencies in this repository.
+
+Instead, when instanciating the `CurrencyManager`, you can feed it with a list of supported currencies for your dapp:
+
+```
+const list: CurrencyInput[] = [
+ { type: RequestLogicTypes.CURRENCY.ETH, decimals: 18, network: 'anything', symbol: 'ANY' },
+];
+const currencyManager = new CurrencyManager(list);
+```
+
+To implement new types of currencies (aside fiat, BTC, ETH, ERC20), [head towards payment networks](../../../protocol-overview/how-payment-networks-work.md#other-currencies).
diff --git a/advanced/request-network-sdk/sdk-guides/request-client/updating-a-request.md b/advanced/request-network-sdk/sdk-guides/request-client/updating-a-request.md
new file mode 100644
index 0000000..fb0aa83
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/request-client/updating-a-request.md
@@ -0,0 +1,7 @@
+# Updating a Request
+
+After a request is created, it can be updated:
+
+
Name
Description
Role Authorized
accept
accept a request, indicating that it will be paid
payer
cancel
cancel a request
payee, payer
reduceExpectedAmount
reduce the expected amount
payee
increaseExpectedAmount
increase the expected amount
payer
addStakeholders
grant 1 or more third parties access to view an encrypted request
payee, payer, third party
+
+Feature exists. More docs coming soon...
diff --git a/advanced/request-network-sdk/sdk-guides/request-client/use-your-own-signature-mechanism.md b/advanced/request-network-sdk/sdk-guides/request-client/use-your-own-signature-mechanism.md
new file mode 100644
index 0000000..3afbbfb
--- /dev/null
+++ b/advanced/request-network-sdk/sdk-guides/request-client/use-your-own-signature-mechanism.md
@@ -0,0 +1,218 @@
+# Use your own signature mechanism
+
+In a previous chapter, we used the signature providers `@requestnetwork/web3-signature` and `@requestnetwork/epk-signature` (this one is made for test purpose). But, if you are not using web3, you need to inject your own signature mechanism to the request client. This is fairly simple, you need to implement a class following this interface: (see on [github](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/types/src/signature-provider-types.ts))
+
+```typescript
+export interface ISignatureProvider {
+ supportedMethods: Signature.METHOD[];
+ supportedIdentityTypes: Identity.TYPE[];
+
+ sign: (data: any, signer: Identity.IIdentity) => Promise;
+}
+```
+
+### Example 1
+
+For example, your own package to sign needs an ethereum address and return the signature as a hexadecimal string:
+
+```typescript
+class mySignaturePackage {
+ /**
+ * Sign data
+ *
+ * @param data the data to sign
+ * @param address the address to sign with
+ * @returns a promise resolving the signature
+ */
+ public async sign(data: any, address: string): Promise;
+}
+```
+
+Your signature provider would look like:
+
+```typescript
+import { IdentityTypes, SignatureProviderTypes, SignatureTypes } from '@requestnetwork/types';
+import Utils from '@requestnetwork/utils';
+
+// Your package
+import mySignaturePackage from 'mySignaturePackage';
+
+/**
+ * Implementation of the signature provider for my wallet
+ */
+export default class MySignatureProvider implements SignatureProviderTypes.ISignatureProvider {
+ /** list of supported signing methods */
+ public supportedMethods: SignatureTypes.METHOD[] = [SignatureTypes.METHOD.ECDSA];
+ /** list of supported identity types */
+ public supportedIdentityTypes: IdentityTypes.TYPE[] = [IdentityTypes.TYPE.ETHEREUM_ADDRESS];
+
+ /**
+ * Signs data
+ *
+ * @param string data the data to sign
+ * @returns IIdentity the identity to sign with. If not given, the default signer will be used
+ *
+ * @returns string the signature
+ */
+ public async sign(
+ data: any,
+ signer: IdentityTypes.IIdentity,
+ ): Promise {
+ if (!this.supportedIdentityTypes.includes(signer.type)) {
+ throw Error(`Identity type not supported ${signer.type}`);
+ }
+
+ // Hash the normalized data (e.g. avoid case sensitivity)
+ const hashData = Utils.crypto.normalizeKeccak256Hash(data).value;
+
+ // use your signature package
+ const signatureValue = mySignaturePackage.sign(hashData, signer.value);
+
+ return {
+ data,
+ signature: {
+ method: SignatureTypes.METHOD.ECDSA,
+ value: signatureValue,
+ },
+ };
+ }
+}
+```
+
+Now you can inject it into the request client:
+
+```typescript
+import MySignatureProvider from 'mySignatureProvider';
+
+const mySignatureProvider = new MySignatureProvider();
+
+// We can initialize the RequestNetwork class with the signature provider
+const requestNetwork = new RequestNetwork.RequestNetwork({
+ signatureProvider: mySignatureProvider,
+});
+```
+
+\## Example 2
+
+For example, your own package to sign needs an internal identifier and return the signature as a Buffer:
+
+```typescript
+class mySignaturePackage {
+ /**
+ * Sign a Buffer
+ *
+ * @param data the data to sign
+ * @param walletId a way to get the right wallet to sign with
+ * @returns a promise resolving the signature
+ */
+ public async sign(data: Buffer, walletId: number): Promise;
+}
+```
+
+Your signature provider would look like:
+
+```typescript
+import { IdentityTypes, SignatureProviderTypes, SignatureTypes } from '@requestnetwork/types';
+import Utils from '@requestnetwork/utils';
+
+// Your package
+import mySignaturePackage from 'mySignaturePackage';
+
+/** Type of the dictionary of wallet id indexed by address */
+type IWalletIdDictionary = Map;
+
+/**
+ * Implementation of the signature provider for my wallet
+ */
+export default class MySignatureProvider implements SignatureProviderTypes.ISignatureProvider {
+ /** list of supported signing method */
+ public supportedMethods: SignatureTypes.METHOD[] = [SignatureTypes.METHOD.ECDSA];
+ /** list of supported identity types */
+ public supportedIdentityTypes: IdentityTypes.TYPE[] = [IdentityTypes.TYPE.ETHEREUM_ADDRESS];
+
+ /** Dictionary containing all the private keys indexed by address */
+ private walletIdDictionary: IWalletIdDictionary;
+
+ constructor(identity?: ?IdentityTypes.IIdentity, walletId?: number) {
+ this.walletIdDictionary = new Map();
+
+ if (identity && walletId) {
+ this.addSignatureParameters(identity, walletId);
+ }
+ }
+
+ /**
+ * Signs data
+ *
+ * @param string data the data to sign
+ * @returns IIdentity the identity to sign with. If not given, the default signer will be used
+ *
+ * @returns string the signature
+ */
+ public async sign(
+ data: any,
+ signer: IdentityTypes.IIdentity,
+ ): Promise {
+ if (!this.supportedIdentityTypes.includes(signer.type)) {
+ throw Error(`Identity type not supported ${signer.type}`);
+ }
+
+ // toLowerCase to avoid mismatch because of case
+ const walletId: number | undefined = this.walletIdDictionary.get(signer.value.toLowerCase());
+
+ if (!walletId) {
+ throw Error(`Identity unknown: ${signer.type}, ${signer.value}`);
+ }
+
+ // Hash the normalized data (e.g. avoid case sensitivity)
+ const hashData = Utils.crypto.normalizeKeccak256Hash(data).value;
+
+ // convert the hash from a string '0x...' to a Buffer
+ const hashDataBuffer = Buffer.from(hashData.slice(2), 'hex');
+
+ // use your signature package
+ const signatureValueBuffer = mySignaturePackage.sign(hashDataBuffer, walletId);
+
+ // convert the signature to a string '0x...'
+ const signatureValue = `0x${signatureValueBuffer.toString('hex')}`;
+
+ return {
+ data,
+ signature: {
+ method: SignatureTypes.METHOD.ECDSA,
+ value: signatureValue,
+ },
+ };
+ }
+
+ /**
+ * Function to add a new identity in the provider
+ *
+ * @param identity the new identity
+ * @param walletId the wallet id matching the identity
+ */
+ public addIdentity(identity: IdentityTypes.IIdentity, walletId: number): void {
+ if (!this.supportedIdentityTypes.includes(identity.type)) {
+ throw Error(`Identity type not supported ${identity.type}`);
+ }
+
+ this.walletIdDictionary.set(identity.value.toLowerCase(), walletId);
+ }
+}
+```
+
+Now you can inject it into the request client:
+
+```typescript
+import MySignatureProvider from 'mySignatureProvider';
+
+const mySignatureProvider = new MySignatureProvider(anIdentity, aWalletId);
+
+// We can initialize the RequestNetwork class with the signature provider
+const requestNetwork = new RequestNetwork.RequestNetwork({
+ signatureProvider: mySignatureProvider,
+});
+
+// later on, you can even add more supported identities
+mySignatureProvider.addIdentity(anotherIdentity, anotherWalletId);
+```
diff --git a/faq.md b/faq.md
new file mode 100644
index 0000000..df523f7
--- /dev/null
+++ b/faq.md
@@ -0,0 +1,176 @@
+---
+description: Frequently Asked Questions and Common Misconceptions
+---
+
+# FAQ
+
+{% hint style="info" %}
+If your question is not answered below, please consider posting it to the [Request Network Discussions](https://github.com/orgs/RequestNetwork/discussions) page on Github.
+{% endhint %}
+
+
+
+Is Request Network a blockchain, smart contract platform, or L2 scaling solution?
+
+No. Request Network is not a blockchain, smart contract platform, or scaling solution. Rather, it's a protocol for storing payment requests, facilitating on-chain payments, and reconciling those payments with the requests. It stores payment requests in [IPFS](https://www.ipfs.com/) and CID hashes on [Gnosis Chain](https://www.gnosis.io/). It uses [The Graph](https://thegraph.com/) for on-chain event indexing. It processes payments across a variety of [supported payment chains](https://docs.request.network/get-started/supported-chains).
+
+
+
+
+
+What is the difference between Request Network and Request Finance?
+
+Request Network is an open-source protocol. Request Finance is a product built on top of Request Network. Request Finance has spun off from Request Network, and they are now two separate teams.
+
+
+
+
+
+Do I need to create a request on the same chain that I want to receive payment?
+
+No. Requests are created on Gnosis Chain (or Sepolia for testing), even if the payment will happen on a different chain. Payment(s) can occur on any of our [supported payment chains](https://docs.request.network/get-started/supported-chains#payments).
+
+To help builders get started quickly, the Request Network Foundation operates [Request Node Gateways](https://docs.request.network/get-started/request-node-gateways) that are free for anyone to use. These gateways offer endpoints for creating and retrieving requests.
+
+Requests created on Gnosis Chain are "real" and will exist forever. Requests created on Sepolia are "test" requests and will exist only as long as Sepolia continues to operate.
+
+
+
+
+
+Is the address that creates a request the same address that receives the payment?
+
+It can be, but not necessarily. The [#signer-identity](glossary.md#signer-identity "mention") that signs to create a request is defined by the `signer` parameter. This is separate from the [#payment-recipient](glossary.md#payment-recipient "mention") which is defined by the `paymentNetwork.parameters.paymentAddress`parameter. They can be the same or different.
+
+This design allows for a single payee identity to have potentially multiple payment recipient addresses.
+
+See [#parties-of-a-request](glossary.md#parties-of-a-request "mention") for details.
+
+
+
+
+
+Are requests in Request Network stored fully on-chain?
+
+No. Request Network is a hybrid on/off-chain protocol storing the majority of request contents in IPFS. Only the content-addressable ID (CID) is stored on-chain, on Gnosis Chain.
+
+
+
+
+
+Can I make a payment before creating a request?
+
+Yes. Payments are linked to requests via a [payment-reference.md](advanced/request-network-sdk/sdk-guides/request-client/payment-reference.md "mention") derived from the request contents. Therefore, it is possible to calculate the `paymentReference` and execute a payment _before_ creating the corresponding request.
+
+
+
+
+
+Does Request Network support requests for fiat currency?
+
+Yes and No.
+
+Requests can be _denominated_ in fiat currencies like USD, EUR, etc. ([ISO 4217 currencies](https://en.wikipedia.org/wiki/ISO_4217)) but our payment smart contracts only support payments in cryptocurrencies. We call these [conversion-request.md](advanced/request-network-sdk/sdk-guides/payment/conversion-request.md "mention")s, in which the requested fiat amount is converted to the appropriate cryptocurrency amount using on-chain price feeds at the moment of payment.
+
+It is possible to implement fiat payments using Declarative Requests, where the payer declares that the payment was sent and the payee declares that the payment was received.
+
+
+
+
+
+Does Request Network support crypto-to-fiat (off-ramp) or fiat-to-crypto (on-ramp) payments?
+
+Not currently, but we're working on it.
+
+
+
+
+
+Does Request Network support crypto payments from centralized exchanges (CEX) or custodians?
+
+Yes. See [single-request-forwarder.md](advanced/request-network-sdk/sdk-guides/payment/single-request-forwarder.md "mention")
+
+
+
+
+
+Can a Request Node modify a request's contents before persisting it to IPFS and on-chain?
+
+No. A Request Node cannot change a request's contents before persisting it to IPFS and on-chain because doing so would invalidate the signature. This is true for private, encrypted requests as well. The Request Node cannot forge the end-user's signature.
+
+
+
+
+
+Can I create a request via the Request Network SDK without using a Request Node?
+
+No. Today, a Request Node is required to interact with the Request Network IPFS Network. That said, it is possible to make the end-user pay the protocol fee when creating a request instead of the Request Node. To do this, inject an `HttpMetaMaskDataAccess` into the frontend `RequestNetwork` instance.
+
+```typescript
+const requestNetwork = new RequestNetworkBase({
+ dataAccess: new HttpMetaMaskDataAccess({
+ ethereumProviderUrl: 'https://eth-mainnet.g.alchemy.com/v2/demo',
+ }),
+ ...
+}
+```
+
+
+
+
+
+Can I access a user's historical invoices created via Request Finance?
+
+Yes. It is possible to request access to a user's Request Finance invoices using the [`add-stakeholder` web component](https://docs.request.network/learn-request-network/components/add-stakeholder) which is just a thin wrapper around the [Request Finance Add Stakeholders API](https://docs.request.finance/faq#i-am-integrating-the-request-network.-can-i-get-access-to-users-data-on-request-finance). They display a dialog that prompts the end-user to grant access to 1 invoice at a time.
+
+Details:
+
+* Request Finance invoices are encrypted.
+* Request Network Foundation cannot grant access to encrypted requests in Request Finance.
+
+
+
+
+
+Does Request Network support cross-chain payments where the payer sends funds on one chain and the payee receives funds on a different chain?
+
+No. Request Network does not currently support cross-chain payments. All of the supported payment types involve the payer sending funds and the payee receiving funds on the same chain.
+
+
+
+
+
+Does Request Network support private requests?
+
+Yes. See:
+
+* [private-requests-using-encryption.md](advanced/protocol-overview/private-requests-using-encryption.md "mention")
+* [handle-encryption-with-a-web3-wallet.md](advanced/request-network-sdk/sdk-guides/encryption-and-decryption/handle-encryption-with-a-web3-wallet.md "mention")
+
+
+
+
+
+Does Request Network support private payments?
+
+Yes. See [hinkal-private-payments.md](advanced/request-network-sdk/sdk-guides/payment/hinkal-private-payments.md "mention")
+
+
+
+
+
+Can I create a request via a smart contract call?
+
+No. It is not currently possible to create a request via a smart contract call. However, [RequestNetwork/public-issues#15](https://github.com/RequestNetwork/public-issues/issues/15) is in our roadmap to make this possible.
+
+The recommended way to create a request is using the Request Network API.
+
+
+
+
+
+Can I use Request Network requests even if I have my own payment infrastructure?
+
+Yes. See [single-request-forwarder.md](advanced/request-network-sdk/sdk-guides/payment/single-request-forwarder.md "mention")
+
+
diff --git a/general/lifecycle-of-a-request.md b/general/lifecycle-of-a-request.md
new file mode 100644
index 0000000..706a70b
--- /dev/null
+++ b/general/lifecycle-of-a-request.md
@@ -0,0 +1,45 @@
+# Lifecycle of a Request
+
+The typical lifecycle of a request is as follows:
+
+
Typical Lifecycle of a Request
+
+## Create a request
+
+* The payer or payee signs the request which contains the payee, payer, currency, amount, payment details, and arbitrary content data.
+* The request can be optionally encrypted such that only the payee, payer, and approved 3rd parties can view the request contents.
+* The request is persisted in IPFS.
+* The IPFS Content-addressable ID (CID) is stored in a smart contract on Gnosis chain
+
+{% hint style="info" %}
+Requests are _created_ by storing their CIDs on Gnosis, but this doesn't mean _payment_ must occur on Gnosis. _Payment_ can occur on any of the supported chains including 20+ EVM-compatible chains or NEAR.
+{% endhint %}
+
+## Update a request
+
+* The payee can optionally cancel the request or increase/decrease the expected amount.
+* The payer can optionally accept the request, indicating that they intend to pay it.
+* Both payee and payer can add 3rd party stakeholders if the request is encrypted.
+
+## Pay a request
+
+* The payer derives a paymentReference from the request contents.
+* The payer calls a function on the payment network smart contract, passing in the token address, to address, amount, and paymentReference.
+* An event is emitted containing the token address, to address, amount, and paymentReference.
+
+{% hint style="info" %}
+Most requests are "reference-based" meaning that a paymentReference derived from the request contents is logged on-chain via a smart contract that emits an event. Nothing gets written back to IPFS when paying a "reference-based" request.
+
+The exception is when paying a "declarative" request, in which case, data _is_ written back to IPFS. This includes when the payer declares that the payment was sent and the payee declares that the payment was received.
+{% endhint %}
+
+## Retrieve a request / Detect a payment
+
+* The event is indexed by the payments subgraph
+* An app can retrieve the request contents from IPFS and calculate the balance based on events from the payments subgraph.
+
+{% hint style="info" %}
+The request balance is calculated by adding up all the on-chain payment events with the same paymentReference. Partial payments are possible.
+{% endhint %}
+
+All of these steps are facilitated by the Request Network JavaScript SDK such that the developer needs only make a few function calls. See the [Quickstart](../advanced/request-network-sdk/get-started/quickstart-browser.md) to learn more.
diff --git a/general/request-network-token-list.md b/general/request-network-token-list.md
new file mode 100644
index 0000000..5992f4b
--- /dev/null
+++ b/general/request-network-token-list.md
@@ -0,0 +1,41 @@
+# Request Network Token List
+
+The [Request Network Token List](https://requestnetwork.github.io/request-token-list/latest.json) is a curated list of tokens supported by Request Network products. The token list follows a standardized format and includes essential information about each token, such as address, symbol, name, decimals, and chainId.
+
+## Usage
+
+The token list is available at: [https://requestnetwork.github.io/request-token-list/latest.json](https://requestnetwork.github.io/request-token-list/latest.json)
+
+You can fetch the token list directly in your application:
+
+```typescript
+const tokenList = await fetch(
+ "https://requestnetwork.github.io/request-token-list/latest.json"
+).then((res) => res.json());
+```
+
+## Token List Structure
+
+Each token in the list contains the following information:
+
+```json
+{
+ "id": "TKN-mainnet"
+ "name": "Token Name",
+ "address": "0x...",
+ "symbol": "TKN",
+ "decimals": 18,
+ "chainId": 1,
+ "logoURI": "https://..."
+}
+```
+
+## Adding a New Token
+
+We welcome community contributions! To add a new token to the list:
+
+1. Fork the [request-token-list](https://github.com/RequestNetwork/request-token-list) repository on Github
+2. Add your token information to `tokens/token-list.json`
+3. Make sure your token meets our requirements (see [CONTRIBUTING.md](https://github.com/RequestNetwork/request-token-list/blob/main/CONTRIBUTING.md))
+4. Run tests locally: `npm test`
+5. Create a Pull Request
diff --git a/general/request-scan.md b/general/request-scan.md
new file mode 100644
index 0000000..63f49bf
--- /dev/null
+++ b/general/request-scan.md
@@ -0,0 +1,46 @@
+---
+description: >-
+ An explorer app for viewing requests, payments, and addresses in Request
+ Network.
+---
+
+# Request Scan
+
+
+
+Request Scan is an explorer for viewing requests and payments in Request Network. It enables users to explore and scrutinize requests, payments, and addresses within the Request Network ecosystem.
+
+## Intended Audience
+
+Request Scan caters to a broad audience:
+
+* **Accountants:** Audit and verify financial data on the request network.
+* **Developers:** Easily access Request Network data for troubleshooting your applications.
+* **Analysts:** Gain deep insights into network activity and trends.
+* **Researchers:** Conduct in-depth studies on blockchain data.
+* **Enthusiasts:** Stay informed about the latest happenings on the Request Network.
+
+## Usage
+
+### **User Interface**
+
+* **Search Bar:** Located at the top, allows you to search for specific requests or addresses.
+* **Dashboard:** Provides an overview of network statistics and recent activity.
+* **Requests:** View a list of recent requests with details like payee, payer, amount, and timestamp.
+* **Payments:** View a list of recent payments with details like blockchain transactions, amounts, fees, and timestamps.
+* **Address:** View information about individual addresses, including their requests and payments.
+* **Request:** View information about individual requests, including their details and table with actions and payments.
+
+### **Searching for Data**
+
+* **Request:** Enter a request ID in the search bar to view its details.
+* **Address:** Enter an address to see its requests and payment history.
+
+### Demo Video
+
+{% embed url="https://www.youtube.com/watch?v=lHjeVCvMoU0" %}
+Request Scan Demo Video
+{% endembed %}
+
diff --git a/general/supported-chains/README.md b/general/supported-chains/README.md
new file mode 100644
index 0000000..91b5b02
--- /dev/null
+++ b/general/supported-chains/README.md
@@ -0,0 +1,29 @@
+# Supported Chains
+
+## Payments
+
+The payment proxy smart contracts enable the various payment types.
+
+The most widely deployed payment proxy is the ERC20FeeProxy. The most frequently used payment proxy is the ERC20ConversionProxy.
+
+{% hint style="info" %}
+For an explanation of what each smart contract does, see [contracts.md](../../advanced/protocol-overview/contracts.md "mention")
+{% endhint %}
+
+{% hint style="info" %}
+Make sure to scroll horizontally to see all the payment proxy types! :wink:
+{% endhint %}
+
+
+
+## REQ Token and Burn Mechanism
+
+The REQ Token is on Ethereum Mainnet. The burn contracts facilitate locking xDAI on Gnosis, bridging xDAI to Ethereum, swapping xDAI for REQ, and burning the REQ.
+
+
|
+| [**ERC20SwapToConversion**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToConversion.sol) | 0x05e94CDdd14E0b18317AE21BAFAEC24156BdB7C9 |
+| [**ERC20TransferableReceivable**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20TransferableReceivable.sol) | 0xB5E53C3d145Cbaa61C7028736A1fF0bC6817A4c5 |
+| [**SingleRequestProxyFactory**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/SingleRequestProxyFactory/index.ts) | 0xf8cACE7EE4c03Eb4f225434B0709527938D365b4 |
+| [**ChainlinkConversionPath**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/ChainlinkConversionPath/index.ts) | 0x7c285b9F2dA5E2c10feA25C00Ce1aCB107F85475 |
+
+### Optimism
+
+| Contract Name | Address |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
+| [**ERC20FeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20FeeProxy.sol) | 0x399F5EE127ce7432E4921a61b8CF52b0af52cbfE |
+| [**ERC20Proxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20Proxy.sol) | N/A |
+| [**EthereumFeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumFeeProxy.sol) | 0xe11BF2fDA23bF0A98365e1A4c04A87C9339e8687 |
+| [**EthereumProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumProxy.sol) | 0x171Ee0881407d4c0C11eA1a2FB7D5b4cdED71e6e |
+| [**ERC20EscrowToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20EscrowToPay.sol) | 0x26d4912fA5aC84F185843E19eeEdcc47f4Cc9F1a |
+| [**BatchConversionPayments**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/BatchConversionPayments.sol) | 0x3cF63891928B8CeebB81C95426600a18cd59C03f |
+| [**ERC20SwapToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToPay.sol) | 0x626e6E3dac82205EA5FfB526092F4DCe525E46a9 |
+| [**ERC20ConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/Erc20ConversionProxy.sol) | 0x1550A8C4F4E5afC67Ea07e8ac590fdcAdB4bBfb1 |
+| [**ETHConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthConversionProxy.sol) | 0x7Ebf48a26253810629C191b56C3212Fd0D211c26 |
+| [**ERC20SwapToConversion**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToConversion.sol) | 0x80D1EE67ffAf7047d3E6EbF7317cF0eAd63FFc78 |
+| [**ERC20TransferableReceivable**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20TransferableReceivable.sol) | N/A |
+| [**SingleRequestProxyFactory**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/SingleRequestProxyFactory/index.ts) | 0xf8cACE7EE4c03Eb4f225434B0709527938D365b4 |
+| [**ChainlinkConversionPath**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/ChainlinkConversionPath/index.ts) | 0x0818Ad7016138f0A40DFAe30F64a923c2A8F61bA |
+
+### Arbitrum One
+
+| Contract Name | Address |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
+| [**ERC20FeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20FeeProxy.sol) | 0x0DfbEe143b42B41eFC5A6F87bFD1fFC78c2f0aC9 |
+| [**ERC20Proxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20Proxy.sol) | N/A |
+| [**EthereumFeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumFeeProxy.sol) | 0xfCFBcfc4f5A421089e3Df45455F7f4985FE2D6a8 |
+| [**EthereumProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumProxy.sol) | 0x322F0037d272E980984F89E94Aae43BD0FC065E6 |
+| [**ERC20EscrowToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20EscrowToPay.sol) | N/A |
+| [**BatchConversionPayments**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/BatchConversionPayments.sol) | 0x3cF63891928B8CeebB81C95426600a18cd59C03f |
+| [**ERC20SwapToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToPay.sol) | 0x626e6E3dac82205EA5FfB526092F4DCe525E46a9 |
+| [**ERC20ConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/Erc20ConversionProxy.sol) | 0xA5186dec7dC1ec85B42A3cd2Dc8289e248530B07 |
+| [**ETHConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthConversionProxy.sol) | 0x7Ebf48a26253810629C191b56C3212Fd0D211c26 |
+| [**ERC20SwapToConversion**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToConversion.sol) | 0x1d6B06C6f7adFd9314BD4C58a6D306261113a1D4 |
+| [**ERC20TransferableReceivable**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20TransferableReceivable.sol) | N/A |
+| [**SingleRequestProxyFactory**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/SingleRequestProxyFactory/index.ts) | 0x4D417AA04DBb207201a794E5B7381B3cde815281 |
+| [**ChainlinkConversionPath**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/ChainlinkConversionPath/index.ts) | 0x0818Ad7016138f0A40DFAe30F64a923c2A8F61bA |
+
+### Base
+
+| Contract Name | Address |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
+| [**ERC20FeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20FeeProxy.sol) | 0x1892196E80C4c17ea5100Da765Ab48c1fE2Fb814 |
+| [**ERC20Proxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20Proxy.sol) | 0xc31323ea7513799e1e112Dc15a05d5b600Cc357e |
+| [**EthereumFeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumFeeProxy.sol) | 0xd9C3889eB8DA6ce449bfFE3cd194d08A436e96f2 |
+| [**EthereumProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumProxy.sol) | 0x090D3583e3f5953e2CC758b146f4Ae11f8224ad7 |
+| [**ERC20EscrowToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20EscrowToPay.sol) | N/A |
+| [**BatchConversionPayments**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/BatchConversionPayments.sol) | 0x1aF3f22685AcdDc788B3730ed415912d8f654420 |
+| [**ERC20SwapToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToPay.sol) | 0x78384dB9674109A3Edf9F2814eFF4B6fc25D816A |
+| [**ERC20ConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/Erc20ConversionProxy.sol) | 0x8296D56321cf207925a7804E5A8E3F579838e6Ad |
+| [**ETHConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthConversionProxy.sol) | 0xEdfD8386d5DE52072B4Ad8dC69BBD0bB89f9A1fb |
+| [**ERC20SwapToConversion**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToConversion.sol) | 0xFbBd0854048a8A75a8823c230e673F8331140483 |
+| [**ERC20TransferableReceivable**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20TransferableReceivable.sol) | N/A |
+| [**SingleRequestProxyFactory**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/SingleRequestProxyFactory/index.ts) | 0xAdc0001eA67Ab36D5321612c6b500572704fFF20 |
+| [**ChainlinkConversionPath**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/ChainlinkConversionPath/index.ts) | 0x3dF89c727eaDF67eeD7b4d09EC4F2b41f8Dec2ca |
+
+### zkSync Era
+
+| Contract Name | Address |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
+| [**ERC20FeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20FeeProxy.sol) | 0x6e28Cc56C2E64c9250f39Cb134686C87dB196532 |
+| [**ERC20Proxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20Proxy.sol) | N/A |
+| [**EthereumFeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumFeeProxy.sol) | 0xE9A708db0D30409e39810C44cA240fd15cdA9b1a |
+| [**EthereumProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumProxy.sol) | N/A |
+| [**ERC20EscrowToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20EscrowToPay.sol) | N/A |
+| [**BatchConversionPayments**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/BatchConversionPayments.sol) | 0x0C41700ee1B363DB2ebC1a985f65cAf6eC4b1023 |
+| [**ERC20SwapToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToPay.sol) | N/A |
+| [**ERC20ConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/Erc20ConversionProxy.sol) | N/A |
+| [**ETHConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthConversionProxy.sol) | N/A |
+| [**ERC20SwapToConversion**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToConversion.sol) | N/A |
+| [**ERC20TransferableReceivable**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20TransferableReceivable.sol) | N/A |
+| [**SingleRequestProxyFactory**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/SingleRequestProxyFactory/index.ts) | 0x9Fd503e723e5EfcCde3183632b443fFF49E68715 |
+| [**ChainlinkConversionPath**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/ChainlinkConversionPath/index.ts) | N/A |
+
+### Gnosis
+
+| Contract Name | Address |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
+| [**ERC20FeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20FeeProxy.sol) | 0x0DfbEe143b42B41eFC5A6F87bFD1fFC78c2f0aC9 |
+| [**ERC20Proxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20Proxy.sol) | N/A |
+| [**EthereumFeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumFeeProxy.sol) | 0xfCFBcfc4f5A421089e3Df45455F7f4985FE2D6a8 |
+| [**EthereumProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumProxy.sol) | 0x322F0037d272E980984F89E94Aae43BD0FC065E6 |
+| [**ERC20EscrowToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20EscrowToPay.sol) | N/A |
+| [**BatchConversionPayments**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/BatchConversionPayments.sol) | 0x3cF63891928B8CeebB81C95426600a18cd59C03f |
+| [**ERC20SwapToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToPay.sol) | 0x626e6E3dac82205EA5FfB526092F4DCe525E46a9 |
+| [**ERC20ConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/Erc20ConversionProxy.sol) | 0xf0f49873C50765239F6f9534Ba13c4fe16eD5f2E |
+| [**ETHConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthConversionProxy.sol) | 0x3E3B04e1bF170522a5c5DDE628C4d365c0342239 |
+| [**ERC20SwapToConversion**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToConversion.sol) | 0x3b4837C9F4A606b71e61FD56Db6241781194df92 |
+| [**ERC20TransferableReceivable**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20TransferableReceivable.sol) | N/A |
+| [**SingleRequestProxyFactory**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/SingleRequestProxyFactory/index.ts) | 0x4D417AA04DBb207201a794E5B7381B3cde815281 |
+| [**ChainlinkConversionPath**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/ChainlinkConversionPath/index.ts) | 0x05D782aD6D6556179A6387Ff1D2fA104FD5c515a |
+
+### Polygon
+
+| Contract Name | Address |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
+| [**ERC20FeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20FeeProxy.sol) | 0x0DfbEe143b42B41eFC5A6F87bFD1fFC78c2f0aC9 |
+| [**ERC20Proxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20Proxy.sol) | N/A |
+| [**EthereumFeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumFeeProxy.sol) | 0xfCFBcfc4f5A421089e3Df45455F7f4985FE2D6a8 |
+| [**EthereumProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumProxy.sol) | 0x322F0037d272E980984F89E94Aae43BD0FC065E6 |
+| [**ERC20EscrowToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20EscrowToPay.sol) | 0x937Db37ffb67083242fbC6AdD472146bF10E01ec |
+| [**BatchConversionPayments**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/BatchConversionPayments.sol) | 0x3cF63891928B8CeebB81C95426600a18cd59C03f |
+| [**ERC20SwapToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToPay.sol) | 0x626e6E3dac82205EA5FfB526092F4DCe525E46a9 |
+| [**ERC20ConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/Erc20ConversionProxy.sol) | 0xf0f49873C50765239F6f9534Ba13c4fe16eD5f2E |
+| [**ETHConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthConversionProxy.sol) | 0x7Ebf48a26253810629C191b56C3212Fd0D211c26 |
+| [**ERC20SwapToConversion**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToConversion.sol) | 0x3b4837C9F4A606b71e61FD56Db6241781194df92 |
+| [**ERC20TransferableReceivable**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20TransferableReceivable.sol) | 0xd6C04C5d0e561D94B15622e770045776D4ce3739 |
+| [**SingleRequestProxyFactory**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/SingleRequestProxyFactory/index.ts) | 0x4D417AA04DBb207201a794E5B7381B3cde815281 |
+| [**ChainlinkConversionPath**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/ChainlinkConversionPath/index.ts) | 0x0818Ad7016138f0A40DFAe30F64a923c2A8F61bA |
+
+### BNB Smart Chain (BSC)
+
+| Contract Name | Address |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
+| [**ERC20FeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20FeeProxy.sol) | 0x0DfbEe143b42B41eFC5A6F87bFD1fFC78c2f0aC9 |
+| [**ERC20Proxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20Proxy.sol) | N/A |
+| [**EthereumFeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumFeeProxy.sol) | 0xfCFBcfc4f5A421089e3Df45455F7f4985FE2D6a8 |
+| [**EthereumProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumProxy.sol) | 0x322F0037d272E980984F89E94Aae43BD0FC065E6 |
+| [**ERC20EscrowToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20EscrowToPay.sol) | N/A |
+| [**BatchConversionPayments**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/BatchConversionPayments.sol) | 0x3cF63891928B8CeebB81C95426600a18cd59C03f |
+| [**ERC20SwapToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToPay.sol) | 0x626e6E3dac82205EA5FfB526092F4DCe525E46a9 |
+| [**ERC20ConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/Erc20ConversionProxy.sol) | 0xbbd9c5D112343A4Aa2bc194245760CaeeaF118Be |
+| [**ETHConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthConversionProxy.sol) | 0x7Ebf48a26253810629C191b56C3212Fd0D211c26 |
+| [**ERC20SwapToConversion**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToConversion.sol) | 0x1d6B06C6f7adFd9314BD4C58a6D306261113a1D4 |
+| [**ERC20TransferableReceivable**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20TransferableReceivable.sol) | N/A |
+| [**SingleRequestProxyFactory**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/SingleRequestProxyFactory/index.ts) | 0x4D417AA04DBb207201a794E5B7381B3cde815281 |
+| [**ChainlinkConversionPath**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/ChainlinkConversionPath/index.ts) | 0x0818Ad7016138f0A40DFAe30F64a923c2A8F61bA |
+
+### BNB Smart Chain (BSC) Testnet
+
+| Contract Name | Address |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
+| [**ERC20FeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20FeeProxy.sol) | 0x0DfbEe143b42B41eFC5A6F87bFD1fFC78c2f0aC9 |
+| [**ERC20Proxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20Proxy.sol) | N/A |
+| [**EthereumFeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumFeeProxy.sol) | N/A |
+| [**EthereumProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumProxy.sol) | N/A |
+| [**ERC20EscrowToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20EscrowToPay.sol) | N/A |
+| [**BatchConversionPayments**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/BatchConversionPayments.sol) | N/A |
+| [**ERC20SwapToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToPay.sol) | N/A |
+| [**ERC20ConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/Erc20ConversionProxy.sol) | 0xf0f49873C50765239F6f9534Ba13c4fe16eD5f2E |
+| [**ETHConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthConversionProxy.sol) | N/A |
+| [**ERC20SwapToConversion**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToConversion.sol) | 0x1d6B06C6f7adFd9314BD4C58a6D306261113a1D4 |
+| [**ERC20TransferableReceivable**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20TransferableReceivable.sol) | N/A |
+| [**SingleRequestProxyFactory**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/SingleRequestProxyFactory/index.ts) | N/A |
+| [**ChainlinkConversionPath**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/ChainlinkConversionPath/index.ts) | 0xEEc4790306C43DC00cebbE4D0c36Fadf8634B533 |
+
+### Celo
+
+| Contract Name | Address |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
+| [**ERC20FeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20FeeProxy.sol) | 0x2171a0dc12a9E5b1659feF2BB20E54c84Fa7dB0C |
+| [**ERC20Proxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20Proxy.sol) | N/A |
+| [**EthereumFeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumFeeProxy.sol) | 0xfCFBcfc4f5A421089e3Df45455F7f4985FE2D6a8 |
+| [**EthereumProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumProxy.sol) | 0x322F0037d272E980984F89E94Aae43BD0FC065E6 |
+| [**ERC20EscrowToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20EscrowToPay.sol) | N/A |
+| [**BatchConversionPayments**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/BatchConversionPayments.sol) | 0x3cF63891928B8CeebB81C95426600a18cd59C03f |
+| [**ERC20SwapToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToPay.sol) | 0x626e6E3dac82205EA5FfB526092F4DCe525E46a9 |
+| [**ERC20ConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/Erc20ConversionProxy.sol) | 0xf0f49873C50765239F6f9534Ba13c4fe16eD5f2E |
+| [**ETHConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthConversionProxy.sol) | 0x7Ebf48a26253810629C191b56C3212Fd0D211c26 |
+| [**ERC20SwapToConversion**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToConversion.sol) | 0x1d6B06C6f7adFd9314BD4C58a6D306261113a1D4 |
+| [**ERC20TransferableReceivable**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20TransferableReceivable.sol) | N/A |
+| [**SingleRequestProxyFactory**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/SingleRequestProxyFactory/index.ts) | 0x8d996a0591a0F9eB65301592C88303e07Ec481db |
+| [**ChainlinkConversionPath**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/ChainlinkConversionPath/index.ts) | 0x0818Ad7016138f0A40DFAe30F64a923c2A8F61bA |
+
+### Alfajores
+
+| Contract Name | Address |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
+| [**ERC20FeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20FeeProxy.sol) | 0x612cF8a29A9c8965a5fE512b7463165861c07EAa |
+| [**ERC20Proxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20Proxy.sol) | N/A |
+| [**EthereumFeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumFeeProxy.sol) | N/A |
+| [**EthereumProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumProxy.sol) | N/A |
+| [**ERC20EscrowToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20EscrowToPay.sol) | N/A |
+| [**BatchConversionPayments**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/BatchConversionPayments.sol) | N/A |
+| [**ERC20SwapToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToPay.sol) | N/A |
+| [**ERC20ConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/Erc20ConversionProxy.sol) | N/A |
+| [**ETHConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthConversionProxy.sol) | N/A |
+| [**ERC20SwapToConversion**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToConversion.sol) | N/A |
+| [**ERC20TransferableReceivable**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20TransferableReceivable.sol) | N/A |
+| [**SingleRequestProxyFactory**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/SingleRequestProxyFactory/index.ts) | N/A |
+| [**ChainlinkConversionPath**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/ChainlinkConversionPath/index.ts) | N/A |
+
+### Fantom
+
+| Contract Name | Address |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
+| [**ERC20FeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20FeeProxy.sol) | 0x0DfbEe143b42B41eFC5A6F87bFD1fFC78c2f0aC9 |
+| [**ERC20Proxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20Proxy.sol) | N/A |
+| [**EthereumFeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumFeeProxy.sol) | 0xfCFBcfc4f5A421089e3Df45455F7f4985FE2D6a8 |
+| [**EthereumProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumProxy.sol) | 0x322F0037d272E980984F89E94Aae43BD0FC065E6 |
+| [**ERC20EscrowToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20EscrowToPay.sol) | N/A |
+| [**BatchConversionPayments**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/BatchConversionPayments.sol) | 0x3cF63891928B8CeebB81C95426600a18cd59C03f |
+| [**ERC20SwapToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToPay.sol) | 0x626e6E3dac82205EA5FfB526092F4DCe525E46a9 |
+| [**ERC20ConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/Erc20ConversionProxy.sol) | 0xf0f49873C50765239F6f9534Ba13c4fe16eD5f2E |
+| [**ETHConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthConversionProxy.sol) | 0x7Ebf48a26253810629C191b56C3212Fd0D211c26 |
+| [**ERC20SwapToConversion**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToConversion.sol) | 0x1d6B06C6f7adFd9314BD4C58a6D306261113a1D4 |
+| [**ERC20TransferableReceivable**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20TransferableReceivable.sol) | N/A |
+| [**SingleRequestProxyFactory**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/SingleRequestProxyFactory/index.ts) | N/A |
+| [**ChainlinkConversionPath**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/ChainlinkConversionPath/index.ts) | 0x0818Ad7016138f0A40DFAe30F64a923c2A8F61bA |
+
+### Tombchain
+
+| Contract Name | Address |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
+| [**ERC20FeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20FeeProxy.sol) | 0x399F5EE127ce7432E4921a61b8CF52b0af52cbfE |
+| [**ERC20Proxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20Proxy.sol) | N/A |
+| [**EthereumFeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumFeeProxy.sol) | 0xe11BF2fDA23bF0A98365e1A4c04A87C9339e8687 |
+| [**EthereumProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumProxy.sol) | N/A |
+| [**ERC20EscrowToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20EscrowToPay.sol) | N/A |
+| [**BatchConversionPayments**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/BatchConversionPayments.sol) | N/A |
+| [**ERC20SwapToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToPay.sol) | N/A |
+| [**ERC20ConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/Erc20ConversionProxy.sol) | N/A |
+| [**ETHConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthConversionProxy.sol) | N/A |
+| [**ERC20SwapToConversion**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToConversion.sol) | N/A |
+| [**ERC20TransferableReceivable**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20TransferableReceivable.sol) | N/A |
+| [**SingleRequestProxyFactory**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/SingleRequestProxyFactory/index.ts) | N/A |
+| [**ChainlinkConversionPath**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/ChainlinkConversionPath/index.ts) | N/A |
+
+### Core
+
+| Contract Name | Address |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
+| [**ERC20FeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20FeeProxy.sol) | 0x399F5EE127ce7432E4921a61b8CF52b0af52cbfE |
+| [**ERC20Proxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20Proxy.sol) | 0x88Ecc15fDC2985A7926171B938BB2Cd808A5ba40 |
+| [**EthereumFeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumFeeProxy.sol) | 0xe11BF2fDA23bF0A98365e1A4c04A87C9339e8687 |
+| [**EthereumProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumProxy.sol) | 0x171Ee0881407d4c0C11eA1a2FB7D5b4cdED71e6e |
+| [**ERC20EscrowToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20EscrowToPay.sol) | N/A |
+| [**BatchConversionPayments**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/BatchConversionPayments.sol) | 0x02561967c48e87cfB079763F3BEf6424A5A166A7 |
+| [**ERC20SwapToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToPay.sol) | N/A |
+| [**ERC20ConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/Erc20ConversionProxy.sol) | N/A |
+| [**ETHConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthConversionProxy.sol) | N/A |
+| [**ERC20SwapToConversion**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToConversion.sol) | N/A |
+| [**ERC20TransferableReceivable**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20TransferableReceivable.sol) | N/A |
+| [**SingleRequestProxyFactory**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/SingleRequestProxyFactory/index.ts) | N/A |
+| [**ChainlinkConversionPath**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/ChainlinkConversionPath/index.ts) | N/A |
+
+### Avalanche
+
+| Contract Name | Address |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
+| [**ERC20FeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20FeeProxy.sol) | 0x0DfbEe143b42B41eFC5A6F87bFD1fFC78c2f0aC9 |
+| [**ERC20Proxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20Proxy.sol) | N/A |
+| [**EthereumFeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumFeeProxy.sol) | 0xfCFBcfc4f5A421089e3Df45455F7f4985FE2D6a8 |
+| [**EthereumProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumProxy.sol) | 0x322F0037d272E980984F89E94Aae43BD0FC065E6 |
+| [**ERC20EscrowToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20EscrowToPay.sol) | N/A |
+| [**BatchConversionPayments**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/BatchConversionPayments.sol) | 0x3cF63891928B8CeebB81C95426600a18cd59C03f |
+| [**ERC20SwapToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToPay.sol) | 0x626e6E3dac82205EA5FfB526092F4DCe525E46a9 |
+| [**ERC20ConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/Erc20ConversionProxy.sol) | 0xA5186dec7dC1ec85B42A3cd2Dc8289e248530B07 |
+| [**ETHConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthConversionProxy.sol) | 0x7Ebf48a26253810629C191b56C3212Fd0D211c26 |
+| [**ERC20SwapToConversion**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToConversion.sol) | 0x1d6B06C6f7adFd9314BD4C58a6D306261113a1D4 |
+| [**ERC20TransferableReceivable**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20TransferableReceivable.sol) | N/A |
+| [**SingleRequestProxyFactory**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/SingleRequestProxyFactory/index.ts) | 0x4D417AA04DBb207201a794E5B7381B3cde815281 |
+| [**ChainlinkConversionPath**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/ChainlinkConversionPath/index.ts) | 0x0818Ad7016138f0A40DFAe30F64a923c2A8F61bA |
+
+### Fuse
+
+| Contract Name | Address |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
+| [**ERC20FeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20FeeProxy.sol) | 0xee07ef5B414955188d2A9fF50bdCE784A49031Fc |
+| [**ERC20Proxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20Proxy.sol) | N/A |
+| [**EthereumFeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumFeeProxy.sol) | 0xfCFBcfc4f5A421089e3Df45455F7f4985FE2D6a8 |
+| [**EthereumProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumProxy.sol) | 0x322F0037d272E980984F89E94Aae43BD0FC065E6 |
+| [**ERC20EscrowToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20EscrowToPay.sol) | 0x4BA012eae4d64da79Bd6bcdBa366803fCe701A4C |
+| [**BatchConversionPayments**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/BatchConversionPayments.sol) | 0x3cF63891928B8CeebB81C95426600a18cd59C03f |
+| [**ERC20SwapToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToPay.sol) | 0x626e6E3dac82205EA5FfB526092F4DCe525E46a9 |
+| [**ERC20ConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/Erc20ConversionProxy.sol) | N/A |
+| [**ETHConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthConversionProxy.sol) | N/A |
+| [**ERC20SwapToConversion**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToConversion.sol) | N/A |
+| [**ERC20TransferableReceivable**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20TransferableReceivable.sol) | N/A |
+| [**SingleRequestProxyFactory**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/SingleRequestProxyFactory/index.ts) | N/A |
+| [**ChainlinkConversionPath**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/ChainlinkConversionPath/index.ts) | N/A |
+
+### Moonbeam
+
+| Contract Name | Address |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
+| [**ERC20FeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20FeeProxy.sol) | 0x399F5EE127ce7432E4921a61b8CF52b0af52cbfE |
+| [**ERC20Proxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20Proxy.sol) | N/A |
+| [**EthereumFeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumFeeProxy.sol) | 0xe11BF2fDA23bF0A98365e1A4c04A87C9339e8687 |
+| [**EthereumProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumProxy.sol) | 0x171Ee0881407d4c0C11eA1a2FB7D5b4cdED71e6e |
+| [**ERC20EscrowToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20EscrowToPay.sol) | 0x26d4912fA5aC84F185843E19eeEdcc47f4Cc9F1a |
+| [**BatchConversionPayments**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/BatchConversionPayments.sol) | 0x3cF63891928B8CeebB81C95426600a18cd59C03f |
+| [**ERC20SwapToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToPay.sol) | 0x626e6E3dac82205EA5FfB526092F4DCe525E46a9 |
+| [**ERC20ConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/Erc20ConversionProxy.sol) | 0x1550A8C4F4E5afC67Ea07e8ac590fdcAdB4bBfb1 |
+| [**ETHConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthConversionProxy.sol) | 0x7Ebf48a26253810629C191b56C3212Fd0D211c26 |
+| [**ERC20SwapToConversion**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToConversion.sol) | 0x80D1EE67ffAf7047d3E6EbF7317cF0eAd63FFc78 |
+| [**ERC20TransferableReceivable**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20TransferableReceivable.sol) | N/A |
+| [**SingleRequestProxyFactory**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/SingleRequestProxyFactory/index.ts) | N/A |
+| [**ChainlinkConversionPath**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/ChainlinkConversionPath/index.ts) | N/A |
+
+### Ronin
+
+| Contract Name | Address |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
+| [**ERC20FeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20FeeProxy.sol) | 0xAe23992483FeDA6E718a808Ce824f6864F13B64B |
+| [**ERC20Proxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20Proxy.sol) | N/A |
+| [**EthereumFeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumFeeProxy.sol) | 0xe9cbD1Aa5496628F4302426693Ad63006C56959F |
+| [**EthereumProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumProxy.sol) | 0x171Ee0881407d4c0C11eA1a2FB7D5b4cdED71e6e |
+| [**ERC20EscrowToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20EscrowToPay.sol) | 0x26d4912fA5aC84F185843E19eeEdcc47f4Cc9F1a |
+| [**BatchConversionPayments**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/BatchConversionPayments.sol) | 0x3cF63891928B8CeebB81C95426600a18cd59C03f |
+| [**ERC20SwapToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToPay.sol) | 0x626e6E3dac82205EA5FfB526092F4DCe525E46a9 |
+| [**ERC20ConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/Erc20ConversionProxy.sol) | N/A |
+| [**ETHConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthConversionProxy.sol) | N/A |
+| [**ERC20SwapToConversion**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToConversion.sol) | N/A |
+| [**ERC20TransferableReceivable**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20TransferableReceivable.sol) | N/A |
+| [**SingleRequestProxyFactory**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/SingleRequestProxyFactory/index.ts) | N/A |
+| [**ChainlinkConversionPath**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/ChainlinkConversionPath/index.ts) | N/A |
+
+### Mantle
+
+| Contract Name | Address |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
+| [**ERC20FeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20FeeProxy.sol) | 0x399F5EE127ce7432E4921a61b8CF52b0af52cbfE |
+| [**ERC20Proxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20Proxy.sol) | 0x88Ecc15fDC2985A7926171B938BB2Cd808A5ba40 |
+| [**EthereumFeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumFeeProxy.sol) | 0xe11BF2fDA23bF0A98365e1A4c04A87C9339e8687 |
+| [**EthereumProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumProxy.sol) | 0x171Ee0881407d4c0C11eA1a2FB7D5b4cdED71e6e |
+| [**ERC20EscrowToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20EscrowToPay.sol) | N/A |
+| [**BatchConversionPayments**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/BatchConversionPayments.sol) | N/A |
+| [**ERC20SwapToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToPay.sol) | N/A |
+| [**ERC20ConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/Erc20ConversionProxy.sol) | N/A |
+| [**ETHConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthConversionProxy.sol) | N/A |
+| [**ERC20SwapToConversion**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToConversion.sol) | N/A |
+| [**ERC20TransferableReceivable**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20TransferableReceivable.sol) | N/A |
+| [**SingleRequestProxyFactory**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/SingleRequestProxyFactory/index.ts) | 0xf8cACE7EE4c03Eb4f225434B0709527938D365b4 |
+| [**ChainlinkConversionPath**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/ChainlinkConversionPath/index.ts) | N/A |
+
+### NEAR
+
+| Contract Name | Address |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------- |
+| [**ERC20FeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20FeeProxy.sol) | pay.reqnetwork.near |
+| [**ERC20Proxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20Proxy.sol) | N/A |
+| [**EthereumFeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumFeeProxy.sol) | N/A |
+| [**EthereumProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumProxy.sol) | N/A |
+| [**ERC20EscrowToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20EscrowToPay.sol) | N/A |
+| [**BatchConversionPayments**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/BatchConversionPayments.sol) | N/A |
+| [**ERC20SwapToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToPay.sol) | N/A |
+| [**ERC20ConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/Erc20ConversionProxy.sol) | N/A |
+| [**ETHConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthConversionProxy.sol) | N/A |
+| [**ERC20SwapToConversion**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToConversion.sol) | N/A |
+| [**ERC20TransferableReceivable**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20TransferableReceivable.sol) | N/A |
+| [**SingleRequestProxyFactory**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/SingleRequestProxyFactory/index.ts) | N/A |
+| [**ChainlinkConversionPath**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/ChainlinkConversionPath/index.ts) | N/A |
+
+### NEAR Testnet
+
+| Contract Name | Address |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- |
+| [**ERC20FeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20FeeProxy.sol) | pay.reqnetwork.testnet |
+| [**ERC20Proxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20Proxy.sol) | N/A |
+| [**EthereumFeeProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumFeeProxy.sol) | N/A |
+| [**EthereumProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthereumProxy.sol) | N/A |
+| [**ERC20EscrowToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20EscrowToPay.sol) | N/A |
+| [**BatchConversionPayments**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/BatchConversionPayments.sol) | N/A |
+| [**ERC20SwapToPay**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToPay.sol) | N/A |
+| [**ERC20ConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/Erc20ConversionProxy.sol) | N/A |
+| [**ETHConversionProxy**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/EthConversionProxy.sol) | N/A |
+| [**ERC20SwapToConversion**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20SwapToConversion.sol) | N/A |
+| [**ERC20TransferableReceivable**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20TransferableReceivable.sol) | N/A |
+| [**SingleRequestProxyFactory**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/SingleRequestProxyFactory/index.ts) | N/A |
+| [**ChainlinkConversionPath**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/lib/artifacts/ChainlinkConversionPath/index.ts) | N/A |
+
+## Storage
+
+### Gnosis
+
+| Contract Name | Address |
+| ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
+| [**RequestOpenHashSubmitter**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/RequestOpenHashSubmitter.sol) | 0x268C146Afb4790902Ee26A6D2d3aff968623Ec80 |
+| [**RequestHashStorage**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/RequestHashStorage.sol) | 0x2256938E8225a998C498bf86B43c1768EE14b90B |
+
+### Sepolia
+
+| Contract Name | Address |
+| ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
+| [**RequestOpenHashSubmitter**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/RequestOpenHashSubmitter.sol) | 0x899ddc13d5DBc252916ba2D70928518f3C836ba1 |
+| [**RequestHashStorage**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/RequestHashStorage.sol) | 0xd6c085A4D14e9e171f4aF58F7F48bd81173f167E |
+
+### Ethereum (Deprecated)
+
+| Contract Name | Address |
+| ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
+| [**RequestOpenHashSubmitter**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/RequestOpenHashSubmitter.sol) | 0xa9cEaA10c12dcB33BAbC2D779e37732311504652 |
+| [**RequestHashStorage**](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/RequestHashStorage.sol) | 0x24a66afda3666fb0202f439708ece45c8121a9bb |
+
+## REQ Token and Burn Mechanism
+
+### Ethereum
+
+| Contract Name | Address |
+| ------------------- | ------------------------------------------ |
+| DaiBasedREQBurner | 0x2CFa65DcB34311293c6a52F1D7BEB8f4E31E5117 |
+| RequestToken | 0x8f8221afbb33998d8584a2b05749ba73c37a938a |
+| Burner (Deprecated) | 0x7b3C4D90e8AF6030d66c07F8F815f9505E379d6F |
+
+### Gnosis
+
+| Contract Name | Address |
+| -------------- | ------------------------------------------ |
+| lockForREQBurn | 0x2171a0dc12a9E5b1659feF2BB20E54c84Fa7dB0C |
diff --git a/glossary.md b/glossary.md
new file mode 100644
index 0000000..73d36e0
--- /dev/null
+++ b/glossary.md
@@ -0,0 +1,151 @@
+# Glossary
+
+## Parties of a Request
+
+### Payee Identity
+
+The Payee Identity is the EVM address that uniquely identifies the payee. It can be but is not necessarily the address that will receive the payment. It is authorized to make certain updates to the request after it is created. It is one of the owners of the request data. The Payee Identity is defined by the `payee` field when creating a request.
+
+### Payer Identity
+
+The Payer Identity is the EVM address that uniquely identifies the payer. It can be but is not necessarily the address that will send the payment. It is authorized to make certain updates to the request after it is created. It is one of the owners of the request data. The Payer Identity is defined by the `payer` field when creating a request.
+
+### Signer Identity
+
+The Signer Identity is the EVM address that provides the signature to create a request. It must be either the Payee Identity or Payer Identity.
+
+### Payment Recipient
+
+The EVM address that receives the payment. It is defined by the `paymentNetwork.parameters.paymentAddress`field when creating a request.
+
+### Payment Sender
+
+The EVM address that sends the payment. Anyone can pay a given request. The payment sender address is NOT stored in the request contents.
+
+### Additional Stakeholder
+
+An EVM address that has been granted view access to an encrypted request.
+
+### Declarative Delegate
+
+An EVM address that has been granted authorization to declare payments sent and payments received on behalf of either the Payee Identity or Payer Identity of a given request.
+
+## Request Protocol
+
+### Action
+
+An action is signed data added by a request's stakeholder into the Request Protocol that creates or updates the state of a request. A request can be represented by a list of actions. For example, the creation of a request is an action.
+
+### Balance
+
+When using a payment network, the balance is the current amount paid for a request. The balance is determined by the payment detection method of the payment network used.
+
+A request with no payment network provided doesn't have a balance.
+
+### Confirmed/Pending action
+
+Request relies on other blockchain technologies to ensure data immutability. Most blockchains don't offer transaction instant finality. This means that when performing an action on the request, this action can't directly be confirmed as effective.
+
+As long as the action hasn't persisted and is not confirmed, the action is marked as "pending". The "pending" state helps have a fast response and a good user experience. Until the request is Confirmed, it should not be relied upon.
+
+### Signature Provider
+
+A signature provider is an abstraction of identity management and action signatures. Depending on use cases, it allows you to give your user complete control or handle some parts for them.
+
+### Decryption Provider
+
+A decryption provider is an abstraction of the mechanism that handles the decryption of a request. Depending on use cases, it allows you to give your user complete control or handle some parts for them.
+
+It is not used for clear requests.
+
+### Extension
+
+An extension is a set of actions that extends the feature of a request. A request without extension is a fundamental request for payment with a payee, a currency, and a requested amount. The extension allows for more advanced features.
+
+### Identity
+
+The identity defines a stakeholder of a request that allows signing or encrypting the request actions. The identity is the public data that identifies the stakeholder.
+
+### Request ID
+
+The request ID is the number that uniquely identifies a request. This number is computed from the hash of the request creation action.
+
+### Request Data (aka. Request Contents)
+
+The request data is the current state of a request, the data of the request after having applied all the confirmed actions on it.
+
+### Stakeholder
+
+A request stakeholder is a party involved with the request. Stakeholders are generally the payer and the payee of the request or any other third-party allowed to perform actions on it. For encrypted requests, stakeholders are any party interested in reading the request content.
+
+### Topic
+
+A topic is a string that is used to index a request. This topic is used for request retrieval. Several requests can share the same topic.
+
+Every request has its request id and payee identity as topics (and the payer identity if it is defined). Any custom topic can be appended to a request.
+
+## Payments
+
+### Payment Detection
+
+Payment detection is a method defined by the payment network to determine the current balance of a request.
+
+### Payment Network (aka Payment Extension)
+
+A payment network is a predefined set of rules to agree on the balance of a request. The payment network is defined during the creation of the request.
+
+A payment network is generally related to one currency, but it's not always the case (the Declarative payment network is currency agnostic).
+
+### Payment Reference
+
+In the Reference-based Payment Networks, Payments are linked to Requests via a `paymentReference` which is derived from the `requestId` and payment recipient address. For details see [payment-reference.md](advanced/request-network-sdk/sdk-guides/request-client/payment-reference.md "mention")
+
+### Conversion Payment
+
+A "conversion" request is denominated in one currency but paid in another currency. This is facilitated by on-chain price feeds provided by oracles. The typical use case is to denominate a request in fiat like USD and pay the request in stablecoins like USDC or DAI. For details see [conversion-request.md](advanced/request-network-sdk/sdk-guides/payment/conversion-request.md "mention")
+
+### Swap-to-pay Payment
+
+A "swap-to-pay" payment is where the payment sender sends one currency but the payment recipient receives a different currency. For details see [swap-to-pay-request.md](advanced/request-network-sdk/sdk-guides/payment/swap-to-pay-request.md "mention")
+
+### Swap-to-Conversion Payment
+
+A "swap-to-conversion" payment is where the request is denominated in currency A, the payer sends currency B and the payee receives currency C. For details see [swap-to-conversion-request.md](advanced/request-network-sdk/sdk-guides/payment/swap-to-conversion-request.md "mention")
+
+## Ecosystem
+
+### Request Client
+
+The Request Client is a Javascript library that interacts directly with the Request Protocol. The Request Client connects to a Request Node.
+
+### Request Node
+
+Request Nodes are HTTP servers exposing an API that allows the Request Client to communicate with the Request Protocol. These servers abstract the complexity of IPFS and Ethereum used by the Request Protocol.
+
+### Request Protocol
+
+The Request Protocol is the underlying protocol that powers Request. It defines how requests are stored on a distributed ledger and how to interpret actions performed on them.
+
+## Blockchain, Cryptography
+
+### Confirmation
+
+Confirmation means that the network has verified the blockchain transaction. This happens through a process known as mining in a proof-of-work system (e.g., Bitcoin). Once a transaction is confirmed, it cannot be reversed.
+
+### Ether
+
+Ether is the native token of the Ethereum blockchain, which is used to pay for transaction fees, block proposer rewards, and other services on the network.
+
+### IPFS
+
+The Inter-Planetary File System (IPFS) is a protocol and a peer-to-peer network for storing and sharing data in a distributed file system. IPFS uses content-addressing to uniquely identify each file in a global namespace connecting all computing devices.
+
+The Request Protocol uses IPFS to ensure data accessibility.
+
+### Multi-signature
+
+Multi-signature (multisig) wallets allow multiple parties to require more than one key to authorize a transaction. The needed number of signatures is agreed upon at the creation of the wallet. Multi-signature addresses have a much greater resistance to theft.
+
+### Private Key
+
+A private key is a large number that allows you to sign or decrypt messages. Private keys can be thought of as a password; private keys must never be revealed to anyone but you, as they allow you to spend the funds from your wallet through a cryptographic signature.
diff --git a/request-network-api/api-portal-manage-api-keys-and-webhooks/README.md b/request-network-api/api-portal-manage-api-keys-and-webhooks/README.md
new file mode 100644
index 0000000..ba052db
--- /dev/null
+++ b/request-network-api/api-portal-manage-api-keys-and-webhooks/README.md
@@ -0,0 +1,76 @@
+---
+description: An app for managing Request Network API keys and webhooks.
+---
+
+# API Portal: Manage API Keys and Webhooks
+
+
+
+
+
+## Overview
+
+The Request Network API Portal provides app developers with a platform to securely manage their API keys and webhook endpoints.
+
+## Key Features
+
+### API Key Management
+
+* **Create and Manage API Keys:** Users can create new API keys for authentication.
+* **Toggle and Delete API Keys:** API keys can be toggled on and off, or deleted if no longer needed, enhancing control over API access.
+* **Security Guidelines:** API keys are sensitive and should never be shared publicly. In case of compromise, users are advised to create a new key, update their code, and delete the compromised key.
+* **Multiple Keys:** Allows the creation of multiple API keys for different environments or applications.
+
+### Webhook Management
+
+* **Create and Manage Webhooks:** App developers can configure webhook endpoints to receive real-time notifications for payment events.
+* **Security Guidelines:** Each webhook request includes a signature in the \`x-request-network-signature\` header to ensure authenticity.
+* **Signature Verification:** The signature is a SHA-256 HMAC of the request body, signed using the webhook secret.
+
+Example Verification Code:
+
+```javascript
+import express from 'express';
+import crypto from 'node:crypto';
+
+const app = express();
+const WEBHOOK_SECRET = 'your_webhook_secret';
+
+app.post('/payment', async (req, res) => {
+ const signature = req.headers['x-request-network-signature'];
+ const expectedSignature = crypto
+ .createHmac('sha256', WEBHOOK_SECRET)
+ .update(JSON.stringify(req.body))
+ .digest('hex');
+
+ if (signature !== expectedSignature) {
+ return res.status(401).json({
+ success: false,
+ message: 'Invalid signature'
+ });
+ }
+
+ // Business logic here
+ return res.status(200).json({ success: true });
+});
+```
+
+## Usage
+
+### Creating API Keys
+
+* Navigate to the "API Keys" section.
+* Click on "Create new key."
+* Store the key securely and never share it publicly.
+
+### Configuring Webhooks
+
+* Navigate to the "Webhooks" section.
+* Click on "Add webhook."
+* Enter the endpoint URL and ensure the endpoint is secure and can handle incoming JSON payloads.
+
+## Security Considerations
+
+* **Keep API keys and webhook secrets secure.** Never expose them in public repositories or client-side code.
+* **Verify all webhook signatures** to ensure authenticity and integrity.
+* **Use HTTPS** for all endpoints to encrypt communication.
diff --git a/request-network-api/api-portal-manage-api-keys-and-webhooks/manage-api-keys-and-webhooks-programmatically.md b/request-network-api/api-portal-manage-api-keys-and-webhooks/manage-api-keys-and-webhooks-programmatically.md
new file mode 100644
index 0000000..fe5fc27
--- /dev/null
+++ b/request-network-api/api-portal-manage-api-keys-and-webhooks/manage-api-keys-and-webhooks-programmatically.md
@@ -0,0 +1,64 @@
+# Manage API Keys and Webhooks programmatically
+
+This page details the endpoints for managing API keys and webhooks programmatically. These endpoints allow you to control access to the Request Network API, and receive real-time notifications about important events.
+
+**Key Features:**
+
+* **API Key Management:** Create, list, toggle, and delete API keys to control access to your platform's resources. API keys are essential for authenticating your application and ensuring secure communication with the Request Network API.
+* **Webhook Management:** Configure and manage webhooks to receive real-time notifications about events within the Request Network. This enables your application to react instantly to payment confirmations, request updates, and other critical events.
+
+**Authentication Requirement:**
+
+Most of the endpoints described in this section require an active `session_token` cookie. This cookie is automatically set in your browser after a successful login. Make sure you've logged in before attempting to use these endpoints.
+
+## Authentication
+
+{% openapi src="https://api.request.network/open-api/openapi.json" path="/v1/auth/register" method="post" %}
+[https://api.request.network/open-api/openapi.json](https://api.request.network/open-api/openapi.json)
+{% endopenapi %}
+
+{% openapi src="https://api.request.network/open-api/openapi.json" path="/v1/auth/login" method="post" %}
+[https://api.request.network/open-api/openapi.json](https://api.request.network/open-api/openapi.json)
+{% endopenapi %}
+
+{% openapi src="https://api.request.network/open-api/openapi.json" path="/v1/auth/logout" method="post" %}
+[https://api.request.network/open-api/openapi.json](https://api.request.network/open-api/openapi.json)
+{% endopenapi %}
+
+## Manage API Keys
+
+{% openapi src="https://api.request.network/open-api/openapi.json" path="/v1/key" method="post" %}
+[https://api.request.network/open-api/openapi.json](https://api.request.network/open-api/openapi.json)
+{% endopenapi %}
+
+{% openapi src="https://api.request.network/open-api/openapi.json" path="/v1/key" method="get" %}
+[https://api.request.network/open-api/openapi.json](https://api.request.network/open-api/openapi.json)
+{% endopenapi %}
+
+{% openapi src="https://api.request.network/open-api/openapi.json" path="/v1/key/{id}" method="put" %}
+[https://api.request.network/open-api/openapi.json](https://api.request.network/open-api/openapi.json)
+{% endopenapi %}
+
+{% openapi src="https://api.request.network/open-api/openapi.json" path="/v1/key/{id}" method="delete" %}
+[https://api.request.network/open-api/openapi.json](https://api.request.network/open-api/openapi.json)
+{% endopenapi %}
+
+## Manage Webhooks
+
+{% openapi src="https://api.request.network/open-api/openapi.json" path="/v1/webhook" method="post" %}
+[https://api.request.network/open-api/openapi.json](https://api.request.network/open-api/openapi.json)
+{% endopenapi %}
+
+{% openapi src="https://api.request.network/open-api/openapi.json" path="/v1/webhook" method="get" %}
+[https://api.request.network/open-api/openapi.json](https://api.request.network/open-api/openapi.json)
+{% endopenapi %}
+
+{% openapi src="https://api.request.network/open-api/openapi.json" path="/v1/webhook/{webhookId}" method="put" %}
+[https://api.request.network/open-api/openapi.json](https://api.request.network/open-api/openapi.json)
+{% endopenapi %}
+
+{% openapi src="https://api.request.network/open-api/openapi.json" path="/v1/webhook/{webhookId}" method="delete" %}
+[https://api.request.network/open-api/openapi.json](https://api.request.network/open-api/openapi.json)
+{% endopenapi %}
+
+For detailed information on all available endpoints and their parameters, please refer to the full [Request Network API Reference](https://api.request.network/open-api)
diff --git a/request-network-api/create-and-pay-requests.md b/request-network-api/create-and-pay-requests.md
new file mode 100644
index 0000000..b3c5028
--- /dev/null
+++ b/request-network-api/create-and-pay-requests.md
@@ -0,0 +1,82 @@
+---
+description: >-
+ The Request Network API provides an interface for creating and paying requests
+ within your application.
+---
+
+# Create and Pay Requests
+
+{% hint style="info" %}
+**Talk to an expert**
+
+Discover how Request Network API can enhance your app's features - [book a call](https://calendly.com/mariana-rn/request-network-demo-docs) with us.
+{% endhint %}
+
+## **Core Functionality**
+
+At its core, the Request Network API empowers you to:
+
+* **Create Requests:** Define payment requests with information such as payee, payer (optional), amount, currency, and recurrence (optional).
+* **Facilitate Payments:** Return transaction calldata, ready to be signed by end-users and sent to the blockchain for secure and transparent value transfer.
+* **Deliver Webhook Notifications:** Receive instant updates on payment status changes, enabling your application to react dynamically to completed transactions.
+
+{% openapi src="https://api.request.network/open-api/openapi.json" path="/v1/request" method="post" %}
+[https://api.request.network/open-api/openapi.json](https://api.request.network/open-api/openapi.json)
+{% endopenapi %}
+
+{% openapi src="https://api.request.network/open-api/openapi.json" path="/v1/request/{paymentReference}" method="get" %}
+[https://api.request.network/open-api/openapi.json](https://api.request.network/open-api/openapi.json)
+{% endopenapi %}
+
+{% openapi src="https://api.request.network/open-api/openapi.json" path="/v1/request/{paymentReference}/stop-recurrence" method="patch" %}
+[https://api.request.network/open-api/openapi.json](https://api.request.network/open-api/openapi.json)
+{% endopenapi %}
+
+
+
+{% openapi src="https://api.request.network/open-api/openapi.json" path="/v1/request/{paymentReference}/pay" method="get" %}
+[https://api.request.network/open-api/openapi.json](https://api.request.network/open-api/openapi.json)
+{% endopenapi %}
+
+{% openapi src="https://api.request.network/open-api/openapi.json" path="/v1/pay" method="post" %}
+[https://api.request.network/open-api/openapi.json](https://api.request.network/open-api/openapi.json)
+{% endopenapi %}
+
+
+
+For detailed information on all available endpoints and their parameters, please refer to the full [Request Network API Reference](https://api.request.network/open-api)
+
+## Create and Pay Request Workflow
+
+The following diagram illustrates the typical flow for creating and paying requests using the Request Network API:
+
+```mermaid fullWidth="false"
+sequenceDiagram
+ actor User
+ participant App
+ participant Request Network API
+ participant Blockchain
+
+ User->>App: Create Request
+ App->>Request Network API: POST /request {apiKey, payee, payer?, amount, invoiceCurrency, paymentCurrency}
+ Request Network API-->>App: 201 Created {requestId, paymentReference}
+
+ User->>App: Pay Request
+ App->>Request Network API: GET /request/{paymentReference}/pay {apiKey}
+ Request Network API-->>App: 200 OK {transactions[calldata], metadata{stepsRequired, needsApproval, approvalTransactionIndex}}
+ Request Network API-)Request Network API: Start listening {paymentReference}
+
+ opt if needs approval
+ App->>User: Prompt for approval signature
+ User-->>App: Sign approval transaction
+ App->>Blockchain: Submit approval transaction
+ end
+
+ App->>User: Prompt for payment signature
+ User-->>App: Sign payment transaction
+ App->>Blockchain: Submit payment transaction
+
+ Request Network API->>Request Network API: Payment detected, stop listening {paymentReference}
+ Request Network API->>App: POST {"payment.confirmed", requestId, paymentReference, request scan link, timestamp}
+ App-->>User: Payment Complete
+```
diff --git a/request-network-api/crosschain-payments.md b/request-network-api/crosschain-payments.md
new file mode 100644
index 0000000..4705249
--- /dev/null
+++ b/request-network-api/crosschain-payments.md
@@ -0,0 +1,197 @@
+---
+description: >-
+ Pay requests using stablecoins from any supported network, without manual
+ bridging or token swaps.
+---
+
+# Crosschain Payments
+
+{% hint style="info" %}
+**Talk to an expert**\
+Discover how Request Network API can enhance your app's features - [book a call](https://calendly.com/mariana-rn/request-network-demo-docs) with us.
+{% endhint %}
+
+Crosschain payments allow users to pay a request using a stablecoin from a different blockchain network than the one specified on the request. For example, a payer can pay a request for USDC on Base using USDT from their Optimism wallet.
+
+## Benefits
+
+* **Flexibility:** Payers can pay with their preferred currency.
+* **Cost-Effective:** Automated routing balances cost and speed.
+* **Time-Saving:** Payers don't need to swap or bridge tokens manually.
+* **Simplified UX:** Payment settlement requires only 1 or 2 signatures from the Payer.
+
+## Supported Networks
+
+Crosschain payments are supported on the following blockchain networks:
+
+* Base
+* Optimism
+* Arbitrum
+* Ethereum
+
+## Supported Stablecoins
+
+{% hint style="warning" %}
+**Warning:** Crosschain payments work only with mainnet funds (real money). Test networks are not supported.
+{% endhint %}
+
+The following stablecoins are supported for crosschain payments on both the sending and receiving networks.
+
+* USDC
+* USDT
+* DAI
+
+## How it works
+
+### 1. Request creation
+
+To enable crosschain payments, the request must be created with the following parameters:
+
+* `paymentCurrency` included in the [#supported-stablecoins](crosschain-payments.md#supported-stablecoins "mention") and [#supported-networks](crosschain-payments.md#supported-networks "mention").
+* `amount` greater than 1 - _executing_ crosschain payments under 1 stablecoins is not allowed, even though _creating_ requests has no restrictions on `amount` .
+
+For more details about creating requests, please see the [#v1-request](create-and-pay-requests.md#v1-request "mention") endpoint.
+
+### 2. Payment route fetching
+
+To display a list of possible routes for a given request and payer address, use the [#v1-request-paymentreference-routes](crosschain-payments.md#v1-request-paymentreference-routes "mention") endpoint. It returns all of the possible routes based on the payer's token balances.
+
+#### Route Ranking
+
+The API automatically ranks available payment routes based on the following factors:
+
+* Transaction fees
+* Processing speed
+
+Routes that offer a _balanced_ combination of lower fees and faster processing times are ranked higher in the results.
+
+#### Fee breakdown
+
+When fetching payment routes, each route displays the total estimated fees in the payment currency. This fee represents the combined costs associated with processing the transaction**,** including:
+
+1. **Gas Fees:**
+
+ The total fee includes all gas costs incurred by the payment processor wallet for processing the transaction. this covers:
+
+ \- Transferring tokens from the payer's wallet.
+
+ \- Approving the payment execution smart contract.
+
+ \- Executing the crosschain payment transaction.
+
+ **For tokens supporting EIP-2612:**
+
+ \- The payment processor wallet also covers for the onchain permit transaction.
+
+ **For tokens that do not support EIP-2612:**
+
+ \- The payer must perform an onchain approval transaction and pay for the gas fee directly. This fee is **not** included in the total fee shown for the route.
+2. **Service Fees:**
+
+ The total fees also include any service fees charged by the crosschain infrastructure for facilitating transfers or swaps between different blockchains.
+
+#### Samechain routes
+
+The API may return samechain routes if the payer address has supported currencies on the same chain as the `paymentCurrency` .
+
+* Example: `paymentCurrency` is USDC on Base, and the payer has USDT on Base
+* Gassless transactions - the transaction fees are added on top of the request amount
+* No native token (ETH, etc..) needed for gas
+
+{% openapi src="https://api.stage.request.network/open-api/openapi.json" path="/v1/request/{paymentReference}/routes" method="get" %}
+[https://api.stage.request.network/open-api/openapi.json](https://api.stage.request.network/open-api/openapi.json)
+{% endopenapi %}
+
+### 3. Getting payment calldata
+
+Once the route is selected, the payer needs to fetch the unsigned payment calldata or intents.\
+\
+If the selected route is a crosschain payment, the [#v1-request-paymentreference-pay](crosschain-payments.md#v1-request-paymentreference-pay "mention") endpoint returns an unsigned payment intent. It will also return an unsigned approval permit or unsigned approval calldata, depending on whether the `paymentCurrency` supports [EIP-2612 Permit](https://eips.ethereum.org/EIPS/eip-2612). For crosschain payments, this endpoint is NOT approval aware - it will return an approval permit or approval calldata even if approval has already been granted.
+
+If the selected route is a direct payment, the [#v1-request-paymentreference-pay](crosschain-payments.md#v1-request-paymentreference-pay "mention") returns an unsigned payment calldata. It may also return an approval calldata. For direct payments, this endpoint IS approval aware - it will omit the approval calldata if sufficient approval has already been granted.
+
+{% openapi src="https://api.stage.request.network/open-api/openapi.json" path="/v1/request/{paymentReference}/pay" method="get" %}
+[https://api.stage.request.network/open-api/openapi.json](https://api.stage.request.network/open-api/openapi.json)
+{% endopenapi %}
+
+### 4. Signing the payment intent
+
+The intents and calldata returned by the [#v1-request-paymentreference-pay](crosschain-payments.md#v1-request-paymentreference-pay "mention") endpoint in the previous step must be signed by the payer's wallet to authorize the crosschain payment. The process for signing the approval varies depending on whether the `paymentCurrency` supports [EIP-2612 Permit](https://eips.ethereum.org/EIPS/eip-2612), indicated by the `metadata` response parameter.
+
+```json
+ "metadata": {
+ "supportsEIP2612": true
+ }
+```
+
+If the token does not support EIP-2612 Permit, the payer must sign and submit a standard ERC20 approval transaction.
+
+{% tabs %}
+{% tab title="Ethers V5" %}
+```typescript
+import { ethers } from "ethers";
+
+const ethersProvider = new ethers.providers.Web3Provider(
+ // Connected wallet provider
+ walletProvider as ethers.providers.ExternalProvider,
+);
+const signer = await ethersProvider.getSigner();
+
+// Response from the `GET /request/{paymentReference}/pay` endpoint
+const response = ...
+
+const paymentIntent = JSON.parse(paymentData.paymentIntent);
+const supportsEIP2612 = paymentData.metadata.supportsEIP2612;
+let approvalSignature = undefined;
+let approval = undefined;
+
+if (supportsEIP2612) {
+ approval = JSON.parse(paymentData.approvalPermitPayload);
+
+ approvalSignature = await signer._signTypedData(
+ approval.domain,
+ approval.types,
+ approval.values,
+ );
+} else {
+ const tx = await signer.sendTransaction(paymentData.approvalCalldata);
+ await tx.wait();
+}
+
+const paymentIntentSignature = await signer._signTypedData(
+ paymentIntent.domain,
+ paymentIntent.types,
+ paymentIntent.values,
+);
+
+const signedData = {
+ signedPaymentIntent: {
+ signature: paymentIntentSignature,
+ nonce: paymentIntent.values.nonce.toString(),
+ deadline: paymentIntent.values.deadline.toString(),
+ },
+ signedApprovalPermit: approvalSignature
+ ? {
+ signature: approvalSignature,
+ nonce: approval.values.nonce.toString(),
+ deadline: approval?.values?.deadline
+ ? approval.values.deadline.toString()
+ : approval.values.expiry.toString(),
+ }
+ : undefined,
+};
+```
+{% endtab %}
+{% endtabs %}
+
+### 5. Sending the signed data
+
+Finally, the signed payment intent (and possibly the signed approval permit) are sent back to execute the crosschain payment via the [#v1-request-paymentintentid-send](crosschain-payments.md#v1-request-paymentintentid-send "mention") endpoint. It will handle all the necessary steps to complete the payment. A `payment.complete` event will be sent to the platform's webhooks when the payment is completed.
+
+{% openapi src="https://api.stage.request.network/open-api/openapi.json" path="/v1/request/{paymentIntentId}/send" method="post" %}
+[https://api.stage.request.network/open-api/openapi.json](https://api.stage.request.network/open-api/openapi.json)
+{% endopenapi %}
+
+## Custom fee configuration
+
+It will be possible in the future to add a custom fee to the payment, this is currently under development.
diff --git a/request-network-api/easyinvoice-api-demo-app.md b/request-network-api/easyinvoice-api-demo-app.md
new file mode 100644
index 0000000..82bfdd9
--- /dev/null
+++ b/request-network-api/easyinvoice-api-demo-app.md
@@ -0,0 +1,89 @@
+---
+description: An app for creating and paying requests using the Request Network API.
+---
+
+# EasyInvoice: API Demo App
+
+EasyInvoice is a web application built with Next.js that allows users to create and manage invoices, and accept crypto payments via the Request Network API. It mimics Web2 apps in its functionalities, providing a user-friendly experience with Google login and real-time updates.
+
+{% hint style="info" %}
+**Talk to an expert**
+
+Discover how your app can have its own EasyInvoice features - [book a call](https://calendly.com/mariana-rn/request-network-demo-docs) with us.
+{% endhint %}
+
+## Key Features
+
+### Login
+
+* **Google Login**: Securely log in to your account using Google OAuth.
+
+
EasyInvioce Login Page
+
+### **Invoice Creation**
+
+* **Invoice Creation**: A simple form to create invoices.
+ * Client name and email fields.
+ * Items, amounts, and notes fields.
+ * Invoice currency and payment currency options, supporting currency conversion via the Request Network API.
+* **Currency Conversion**: uses on-chain price feeds to calculate the exact payment currency amount based on the invoice currency at the moment of payment so you always receive the correct amount.
+
+
EasyInvoice Create Invoice Page
+
+### **Dashboard**
+
+* **Dashboard**: View key metrics and a table of your invoices.
+
+
EasyInvoice Dashboard
+
+### Invoice Payment
+
+* **Invoice Payment:**
+ * View invoice details and initiate payment using transaction calldata provided by the Request Network API.
+ * Compatible with 50+ different crypto wallets.
+* **Real-time Updates**: The app receives webhooks from the Request Network API to update the invoice status in real-time.
+
+
EasyInvoice Invoice Payment Page
+
+
EasyInvoice supports 50+ wallets via Reown AppKit
+
+### Recurring Invoices
+
+* **Recurring Invoice**: Automatically create new invoices based on the selected start date and frequency
+
+
Create New Invoice page - Recurring Invoice Enabled
+
+
Invoice Dashboard - Recurring Invoice
+
+### Invoice Crosschain Payment
+
+{% hint style="warning" %}
+**Warning:** Crosschain payments are currently only available in our staging environment at [https://easyinvoice.stage.request.network](https://easyinvoice.stage.request.network) and are not ready for production use. Use with caution.
+{% endhint %}
+
+
+
+### Direct Payment
+
+* **Direct Payment**: Send a payment without having to create a request first.
+
+
EasyInvoice Direct Payment page
+
+### InvoiceMe Link
+
+* **InvoiceMe Link**: Prompt clients to send you an invoice prefilled with your name and email address.
+
+
+
+## Usage
+
+1. **Login:** Log in with your Google account to access the dashboard.
+2. **Create Invoice:** Fill out the invoice form with the necessary details, including client information, amount, currency, and payee address.
+ 1. If the invoice currency is USD, you must select a payment currency (Sepolia ETH or FAU) for conversion.
+ 2. For non-conversion scenarios, the payment currency will be the same as the invoice currency.
+3. **Pay Invoice:** Connect your wallet and initiate the payment. The app will guide you through the steps, including ERC20 approval and transaction confirmation.
+4. **Monitor Status:** Track the payment status in real-time on the invoice details page and the dashboard.
.svg)
.svg)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
