# Quick start developing with TIP-3

## Source code

You can inspect the source code of TIP-3 token implementation by [link](https://github.com/broxus/tip3).

## How to deploy your own token

{% hint style="info" %}
You need to have an installed Smart Contract Development Environment. If you haven't already, follow [this tutorial](/knowledge-base/build/development-guides/setting-up-a-venom-smart-contract-development-environment.md).
{% endhint %}

### Initialize your token project

```shell
npx locklift init --path my-first-token
> [INFO]  New Locklift project initialized in .
> [INFO]  Installing required dependencies...
> [INFO]  
> added 181 packages, and audited 182 packages in 13s

> 23 packages are looking for funding
>   run `npm fund` for details

> found 0 vulnerabilities

> [INFO]  LockLift initialized in my-first-token happy hacking!
```

### Install dependencies

Add TIP-3 implementation repository as a `devDependencies` in corresponding section of `package.json` file

{% code title="package.json" lineNumbers="true" %}

```json
{
  "devDependencies": {
    "tip3": "git://github.com/broxus/tip3#5.0",
    ...
  },
}
```

{% endcode %}

Specify installed contracts to external contracts section of locklift config, by providing path to contracts artifacts (.abi.json files, .tvc files etc., most commonly placed in a build folder of smart contracts projects) and contract names array.

{% code title="locklift.config.ts" lineNumbers="true" %}

```json
compiler: {
    ...
    externalContracts: {
      "node_modules/tip3/build": ["TokenRoot", "TokenWallet"],
    },
  }
```

{% endcode %}

Now we can compile our contracts and make sure that artifacts were created

```shell
npx locklift build

> Found 1 sources
>
> factorySource generated
> Built

ls ./build

> ...
> TokenRoot.abi.json
> TokenRoot.code
> TokenRoot.base64
> TokenRoot.tvc
> ...
> TokenWallet.abi.json
> TokenWallet.code
> TokenWallet.base64
> TokenWallet.tvc
> ...
```

Let's move to deploy action. Firstly, we make a new deploy script in `scripts` directory for TokenRoot contract. 

{% code title="01-deploy-token-root.ts" lineNumbers="true" %}

```typescript
import { Address, getRandomNonce, toNano, zeroAddress } from "locklift"
import BigNumber from "bignumber.js"

async function main() {
  const signer = (await locklift.keystore.getSigner("0"))!
  
  // Address of initial token supply recipient (write your own)
  const initialSupplyTo   = new Address("0:7542...")
  // Address of token owner (write your own)
  const rootOwner         = new Address("0:7542...")
  // Name of the token     
  const name              = "First Venom Token"
  // Symbol of the token
  const symbol            = "FVT"
  // How many token will be issued instantly after deploy                
  const initialSupply     = 0
  // The number of decimals the token uses        
  const decimals          = 18
  // If `true`, disables token minting
  const disableMint       = false
  // If `true`, disables token burning by root                
  const disableBurnByRoot = false
  // If `true`, pauses token burning                
  const pauseBurn         = false
                  
  
  /* 
    Returns compilation artifacts based on the .sol file name
      or name from value config.externalContracts[pathToLib].
  */
  const TokenWallet = locklift.factory.getContractArtifacts("TokenWallet")
  
  /* 
    Deploy the TIP-3 Token Root contract.
    @params deployWalletValue: Along with the deployment of the root token,
      the wallet will be automatically deployed to the owner. 
      This is the amount of EVERs that will be sent to the wallet.
  */
  const { contract: tokenRoot } = await locklift.factory.deployContract({
    contract: "TokenRoot",
    publicKey: signer.publicKey,
    initParams: {
      deployer_: zeroAddress, // this field should be zero address if deploying with public key (see source code)
      randomNonce_: getRandomNonce(),
      rootOwner_: rootOwner,
      name_: name,
      symbol_: symbol,
      decimals_: decimals,
      walletCode_: TokenWallet.code,
    },
    constructorParams: {
      initialSupplyTo: initialSupplyTo,
      initialSupply: new BigNumber(initialSupply).shiftedBy(decimals).toFixed(),
      deployWalletValue: toNano(1),
      mintDisabled: disableMint,
      burnByRootDisabled: disableBurnByRoot,
      burnPaused: pauseBurn,
      remainingGasTo: zeroAddress,
    },
    value: toNano(5),
  })

  console.log(`${name}: ${tokenRoot.address}`)
}

main()
  .then(() => process.exit(0))
  .catch(e => {
    console.log(e)
    process.exit(1)
  })

```

{% endcode %}

Finally, we can deploy a new token to `local` network. For this, make sure local node is running, if not follow the next command

<pre class="language-shell"><code class="lang-shell"><strong>docker run -d --name local-node -e USER_AGREEMENT=yes -p80:80 tonlabs/local-node
</strong></code></pre>

and run the deploy script

```shell
npx locklift run -s ./scripts/01-deploy-token.ts -n local

> Found 1 sources

> factorySource generated
> Built
> First Venom Token: 0:69f2407386ca20390878565da97124be717f65496cb03e14aaa676709a6ccb2b
```

Congratulations, your first token on the Venom network has been deployed!


---

# 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://venom-docs.gitbook.io/knowledge-base/build/development-guides/how-to-create-your-own-fungible-tip-3-token/quick-start-developing-with-tip-3.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.