# Venom In Action. Going Global

First thing you should deal with - locklift config. Let's setup some global networks in `network` section of config

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

```typescript
const config: LockliftConfig = {
...
  networks: {
    venomMainnet: {
      connection: {
        group: "mainnet",
        type: "jrpc",
        data: {
          endpoint: 'https://jrpc.venom.foundation/rpc',
        },
      },
      giver: {
        giverFactory: (ever, keyPair, address) => new GiverWallet(ever, keyPair, address),
        address: "",
        phrase: "",
        accountId: 0
      },
      keys: {
        phrase: "",
        amount: 20,
      },
    },
    venomTestnet: {
      connection: {
        group: "testnet",
        type: "jrpc",
        data: {
          endpoint: 'https://jrpc-testnet.venom.foundation/rpc',
        },
      },
      giver: {
        giverFactory: (ever, keyPair, address) => new GiverWallet(ever, keyPair, address),
        address: "",
        phrase: "",
        accountId: 0
      },
      keys: {
        phrase: "",
        amount: 20,
      },
    },
...
}
```

{% endcode %}

Now we have two new networks in our config - `venomTestnet` and `venomMainnet`. Our interest now in `giver` section of each network.

When you work with local node, you have a pre-deployed giver, which you can use for contract deploying. Of course there is no givers in global network (at least publicly accessible, you can deploy your own giver same as in local node for sure). Locklift allows you to use your venom wallet as giver. In a giver section you should fill `address`, `phrase` and `accountId` fields, according to your wallet data (address of the wallet, seed phrase and account number for accountId). You can use field `key` with secret key instead of phrase. Then you should fill keys section the same way (`phrase` field, and `amount` of accounts you need from given seed phrase)

As you can see we have a `giverFactory` field, that initialize a `GiverWallet` object. Let's have a look up there.

{% code title="giverSettings/index.ts" lineNumbers="true" %}

```typescript
export class GiverWallet implements Giver {
	public giverContract: Contract<typeof giverWallet>;
	
	constructor(ever: ProviderRpcClient, readonly keyPair: Ed25519KeyPair, address: string) {
		const giverAddr = new Address(address);
		this.giverContract = new ever.Contract(giverWallet, giverAddr);
	}
	
	public async sendTo(sendTo: Address, value: string): Promise<{ transaction: Transaction; output?: {} }> {
		return await this.giverContract.methods
		.sendTransaction({
			dest: sendTo,
			value: value,
			bounce: false,
			flags: 3,
			payload: "",
		})
		.sendExternal({ publicKey: this.keyPair.publicKey });
	}
}

const giverWallet = {
	"ABI version": 2,
	"version": "2.3",
	header: ["pubkey", "time", "expire"],
	functions: [
		{
			name: "sendTransaction",
			inputs: [
				{ name: "dest", type: "address" },
				{ name: "value", type: "uint128" },
				{ name: "bounce", type: "bool" },
				{ name: "flags", type: "uint8" },
				{ name: "payload", type: "cell" },
			],
			outputs: [],
		},
	],
	events: [],
} as const;
```

{% endcode %}

Pretty simple, isn't it? All you need is to provide an ABI of your contract and change `sendTo` function according to provided ABI (of course you should provide a keys in a giver and keys section of config, that allows calling of provided address). When you will use `locklift.factory.deployContract`, method `sendTo` will be called before deploying.

Now you can just use same deploy scripts, but with another network. For example

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

Summarizing:

1. Fill `network` section of your locklift config with data of network you want
2. Take your wallet address (or another contract you want), seed phrase (or secret key)
3. Fill a `giver` and `keys` section of your locklift config with data you take previously
4. Change `GiverWallet` class according to ABI of your contract (`sendTo` function)
5. Call any deploy script with network you need


---

# 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/venom-in-action.-going-global.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.