Update

Author: xmoohad

docs/source/faq.md

@@ -28,7 +28,3 @@ and other type checkers like pyright not falling over this. The error can be dis
 [tool.mypy]
 disable_error_code = "func-returns-value"
 ```
-
-## How do I <insert topic>?
-Have a look at the examples on GitHub if the documentation doesn't cover your question. If the examples also don't answer
-your question then feel free to ask on GitHub or ask in #python on the [NEO Discord server](https://discord.gg/rvZFQ5382k).

docs/source/smart-contracts.md

@@ -1,14 +1,14 @@
 # Smart contracts
 
 This document explains how to work with smart contracts. First we'll establish the mental model of working with 
-blockchains. If you are already familiar with the NEO blockchain or talking to smart contracts on blockchains in general 
+blockchains. If you are already familiar with the EpicChain blockchain or talking to smart contracts on blockchains in general 
 you can go directly to the [interaction section](#interacting-with-smart-contracts). Next we'll look have a what comes 
 in to play in a basic smart contract interaction. Followed by that we build an understanding of how the wrappers work 
 before diving into the breakdown of a NEP-17 token transfer where all learned comes together.
 
 After reading this chapter you'll have an understanding of the major components involved in interacting with smart 
 contracts. You be able to do all common interactions with a smart contract of choice and have the foundational knowledge 
-that allows you to follow the [examples](https://github.com/CityOfZion/neo-mamba/tree/master/examples) on the Github repo.
+that allows you to follow the [examples](https://github.com/epicchainlabs/Python-SDK-for-the-EpicChain-blockchain/tree/main/examples) on the Github repo.
 
 ## What are smart contracts?
 
@@ -18,7 +18,7 @@ tokens, executing some algorithm or just reading stored data is up to the contra
 that the smart contract code does not live on your machine and is executed on a remote network (the blockchain). 
 
 Add to this that smart contracts are "compiled" to a custom language and executed by a custom processor 
-(the NEO Virtual Machine). That means that your Python code cannot talk Python to the smart contract, but that a 
+(the EpicChain Virtual Machine). That means that your Python code cannot talk Python to the smart contract, but that a 
 translation has to happen. This library performs that translation under the hood and helps communicate between your 
 machine and the smart contract.
 
@@ -28,23 +28,20 @@ There are 2 layers in this library used to talk to smart contracts. First, wrapp
 regular Python code. Second, a `ChainFacade` class which acts as the network gateway. It will build and sign a 
 transaction if state needs to be persisted or use other means for read-only (free) executions.
 
-Lets breakdown the following example which queries the blockchain for the symbol of the Neo token contract and 
-will return `NEO` as result.
+Lets breakdown the following example which queries the blockchain for the symbol of the EpicChain token contract and 
+will return `EpicChain` as result.
 <a name="symbol-reading-example"></a>
 ```py3
 facade = ChainFacade.node_provider_mainnet()
-neo = NeoToken()
+epicchain = epicchainToken()
 await facade.test_invoke(neo.symbol())
 ```
 Line `1` creates a facade for communicating with the MainNet. While it can be configured to perform automatic 
 transaction signing when persisting state, for now it is only important to know that this configured the facade to talk 
 to a MainNet RPC node internally.
 
-Line `2` instantiates our first wrapper. The `NeoToken` class wraps around the native [NeoToken](https://github.com/neo-project/neo/blob/77ee2cc5b6ea371efdf3be506b173c6304b0fc01/src/Neo/SmartContract/Native/NeoToken.cs#L31) 
-smart contract (built-in to the chain) and gives a convenient way of calling the public functions of the smart contract.
-
-Line `3` is where the interesting parts happen. The call to `neo.symbol()` does not actually return "NEO", instead it 
-builds a sequence of NEO Virtual Machine instructions that the network understands. These instructions need to be sent
+Line `2` is where the interesting parts happen. The call to `neo.symbol()` does not actually return "EpicChain", instead it 
+builds a sequence of EpicChain Virtual Machine instructions that the network understands. These instructions need to be sent
 to the network, which is where the `facade` comes in to play. The `facade` has two ways of sending the instructions
 
 1. `test_invoke()` - Use for read-only calls. Does not cost GAS.
@@ -64,20 +61,18 @@ choice. For now let's first get a greater understanding of the various wrappers
 
 ## Contract wrappers
 The smart contract wrappers are a key component in simplifying smart contract interaction. Like the facade they live in 
-the `neo3.api.wrappers` module. The NEO blockchain has a few native contracts build into the chain such as the NEO and 
-GAS tokens, but also contracts providing information regarding the chain configuration like the 
-[PolicyContract](https://github.com/neo-project/neo/blob/77ee2cc5b6ea371efdf3be506b173c6304b0fc01/src/Neo/SmartContract/Native/PolicyContract.cs#L22).
-For these kind of contracts specialised wrappers exist like `NeoToken`, `GasToken`, `PolicyContract` and `RoleContract`.
+the `neo3.api.wrappers` module. The EpicChain blockchain has a few native contracts build into the chain such as the EpicChain and 
+EpicPulse tokens, but also contracts providing information regarding the chain configuration like thekind of contracts specialised wrappers exist like `EpicChain`, `EpicPulse`, `PolicyContract` and `RoleContract`.
 
 ### Types of smart contracts
 Technically speaking there are no types of smart contracts. However, they can implement standards that give 
-them compartalisable behaviour. For example implementing [NEP-11](https://github.com/neo-project/proposals/blob/master/nep-11.mediawiki) 
-gives NFT like behaviour, [NEP-17](https://github.com/neo-project/proposals/blob/master/nep-17.mediawiki) gives 
-fungible token behaviour. NEO and GAS are examples of NEP-17 tokens, but there are many more NEP-17 tokens in the system.
-To easily use these contracts there are more generic wrappers available such as `NEP17Contract`, `NEP11DivisibleContract` and 
+them compartalisable behaviour. For example implementing [XEP-11](https://github.com/neo-project/proposals/blob/master/nep-11.mediawiki) 
+gives NFT like behaviour, [XEP-17](https://github.com/neo-project/proposals/blob/master/nep-17.mediawiki) gives 
+fungible token behaviour. EpicChain and GAS are examples of NEP-17 tokens, but there are many more NEP-17 tokens in the system.
+To easily use these contracts there are more generic wrappers available such as `XEP17Contract`, `NEP11DivisibleContract` and 
 `NEP11NonDivisibleContract`.
 
-All they require is the contract hash and you're ready to call them like NEO or GAS. For example wrapping the 
+All they require is the contract hash and you're ready to call them like EpicChain or EpicPulse. For example wrapping the 
 [TOTHEMOON](https://dora.coz.io/contract/neo3/mainnet/0x56199aa066633745de4d603e6477881455c08243) token is done as follows 
 
 ```py3 linenums="0"
@@ -105,7 +100,7 @@ The diagram below shows the structure
 * White are building blocks and not intended to be used on their own. They are shown to make the picture complete.
 
 ## Modifying chain state
-This section shows what it takes to modify chain state, specifically we'll show how to transfer a NEP-17 token (NEO) and 
+This section shows what it takes to modify chain state, specifically we'll show how to transfer a NEP-17 token (EpicChain) and 
 break down the steps and options.
 
 We've [previously](#symbol-reading-example) seen how to query the `symbol` of a contract by using the `test_invoke()` 
@@ -140,21 +135,21 @@ async def main():
         Signer(account.script_hash)
     )
 
-    destination = "NUVaphUShQPD82yoXcbvFkedjHX6rUF7QQ"
+    destination = "XsokdeQ3kXqsryRycSVd1cJ86tHJ8kn8uP"
     print(await facade.invoke(neo.transfer(account.address, destination, 10)))
 
 if __name__ == "__main__":
     asyncio.run(main())
 ```
 #### Wallet account setup
-Skipping the imports, startup boilerplate code and NeoToken wrapper creation (that we've seen before) we start here
+Skipping the imports, startup boilerplate code and EpicChain wrapper creation (that we've seen before) we start here
 ```py3 linenums="11"
 wallet = Wallet.from_file("./path_to/mywallet.json")
 account = wallet.account_default
 ```
 In order to transfer tokens we need to have an account with funds to transfer them from. Secondly, all transactions are
-paid for with `GAS`. So while this example transfers `NEO`, the account must also hold a bit of `GAS` to pay for the 
-fees. For the aforementioned reasons we assume you already have a [NEP-6](https://github.com/neo-project/proposals/blob/master/nep-6.mediawiki)
+paid for with `GAS`. So while this example transfers `EpicChain`, the account must also hold a bit of `EpicPulse` to pay for the 
+fees. For the aforementioned reasons we assume you already have a [XEP-6](https://github.com/neo-project/proposals/blob/master/nep-6.mediawiki)
 wallet that we'll load from disk.
 
 !!! tip
@@ -183,7 +178,7 @@ It states that `account` agrees with the modification that the transaction `scri
 will verify the validity of the signature before performing the transfer. 
 
 The `Signer` will have a scope of `CALLED_BY_ENTRY` by default. This means that the signature is only valid inside the
-first contract called. In this case that will be the `NeoToken` contract. This scope can be checked by the 
+first contract called. In this case that will be the `EpicChain` contract. This scope can be checked by the 
 `CheckWitness` function inside smart contracts to avoid abuse. There are many scenarios where one contract may need to
 call one or more other contracts. For such cases the signer can be configured with other scope options and rules. This
 however is beyond the scope of this example and can be learned more about [in this excellent article](https://neospcc.medium.com/thou-shalt-check-their-witnesses-485d2bf8375d) 

examples/shared/coz-wallet.json

@@ -8,7 +8,7 @@
   },
   "accounts": [
     {
-      "address": "NUVaphUShQPD82yoXcbvFkedjHX6rUF7QQ",
+      "address": "XsokdeQ3kXqsryRycSVd1cJ86tHJ8kn8uP",
       "label": null,
       "isDefault": false,
       "lock": false,

examples/shared/default.neo-express

@@ -43,7 +43,7 @@
       "accounts": [
         {
           "private-key": "1faa2f5afb23a2eceff89dc54bfb3b777d1b7d9d435646bd9672becbf22c204d",
-          "script-hash": "NUVaphUShQPD82yoXcbvFkedjHX6rUF7QQ",
+          "script-hash": "XsokdeQ3kXqsryRycSVd1cJ86tHJ8kn8uP",
           "label": null,
           "is-default": true,
           "contract": {