# Smart Contract Development Tool

## Zetrix Development Tool

The following guide explains how to use our [Zetrix development tool](https://github.com/Zetrix-Chain/zetrix-development-tool), built for professionals. It facilitates performing frequent tasks, such as smart contract deployment and testing.

### Getting Started

For the purpose of this guide, clone the [repository](https://github.com/Zetrix-Chain/zetrix-development-tool) to your local machine. It will be used a base project for your own smart contract development on Zetrix.

After cloning the repository, we install the NPM packages for this project by running the following command:

```shell
npm install
```

Then create a `.env` file in the root of your project and insert your key/value pairs in the following format of `KEY=VALUE`:

If you're using the Zetrix testnet:

```sh
NODE_URL=test-node.zetrix.com
```

If you're using the Zetrix mainnet:

```shell
NODE_URL=node.zetrix.com
```

Insert the Zetrix address you are going to use to deploy the smart contract from

```sh
ZTX_ADDRESS=<YOUR ZETRIX ADDRESS>
```

Insert the private key of the Zetrix address you are going to use to deploy the smart contract from

```sh
PRIVATE_KEY=<THE PRIVATE KEY TO YOUR ZETRIX ADDRESS>
```

#### Contract development

The smart contract components can be found in the **contracts** directory. If you change the filename(s), please modify the contract name in **scripts** directory as well.

**Manual for running script:**

```sh
npm run help
```

**Contract deployment:**

```sh
npm run deploy:<NAMING_REFER_TO_PACKAGE_JSON>
```

**Contract upgrade:**

```sh
npm run upgrade:<NAMING_REFER_TO_PACKAGE_JSON>
```

**Run test with coverage:**

```sh
npm run test-coverage tests/unit/<TEST_CASE>.js
```

**Run integration test:**

```sh
npm test tests/integration/<TEST_CASE>.js
```

#### Development Guide

The development of Zetrix smart contract is using Javascript ES5 which has less support on OOP concepts such as `class`. Hence, we imitate the OOP implementation by using functionalities available in ES5.

**Class**

OOP implementation

```java
class Example {
    
    Example(String param) {
        // constructor
    }
}

Example exampleInst = new Example(param);
```

ES5 Javascript implementation

```javascript
const Example = function () {
    
    const self = this; // keep the context
    
    self.init = function (param) {
        // constructor
    };
};

const exampleInst = new Example();
exampleInst.init(param);
```

**Managing private, protected and public method**

OOP implementation

```java
class Example {
    
    private void privateMethod() {
        // private method
    }
    
    public void publicMethod() {
        // public method
    }

    protected void protectedMethod() {
        // protected method
    }
}
```

ES5 Javascript implementation

```javascript
const Example = function () {
    
    const self = this; // keep the context

    self.p = {/*protected function*/};
    
    const _privateMethod = function () {
        // private method
    };
    
    self.publicMethod = function () {
        // public method
    };
    
    self.p.protectedMethod = function () {
        // protected method : this method is similar to the public method, but we just defined in `p` nameclass to differentiate  
    };
};
```

**Inheritance and override**

OOP implementation

```java
class ExampleParent {
    
    public void parentMethod1() {
        
    }

    public void parentMethod2() {

    }
    
    public void parentMethod3(int a, int b) {
        
    }
}

class ExampleChild extends ExampleParent {
    
    @Override
    public void parentMethod1() {
        // Override parent method
        // Do something else and continue with original parentMethod
        super.parentMethod1();
    }

    @Override
    public void parentMethod2() {
        // Override parent method
    }
    
    private void childMethod(int a, int b) {
        // Use parent function in child wrapper
        return super.parentMethod3(a, b);
    } 
}
```

ES5 Javascript implementation

```javascript
const ExampleParent = function () {

    const self = this; // keep the context

    self.p = {/*protected function*/};
    
    self.p.parentMethod1 = function () {

    };
    
    self.p.parentMethod2 = function() {
        
    };
    
    self.parentMethod3 = function(a, b) {
        
    };
};

const ExampleChild = function () {

    const self = this;

    ExampleParent.call(self); // Inherit
    
    const _parentMethod1 = self.p.parentMethod1
    self.p.parentMethod1 = function(){
        // Override parent method
        // Do something else and continue with original parentMethod
        _parentMethod1.call(self);
    };
    
    self.p.parentMethod2 = function() {
        // Override parent method
    };

    const _childMethod = function() {
        // Use parent function in child wrapper
        return self.parentMethod3(a, b);
    };

};
```

This is the end of the tutorial. Happy buidling!


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.zetrix.com/en/developer-resources/smart-contract-development-tool.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.