# Zen.js

Zen.js is helps in:

* Generate Mnemonic phrase
* Secure Mnemonic phrase
* Serialise and deserialise Consensus types
* Sign transactions
* Defining the contract message body
* Create a wallet instance to interact with the blockchain
* Encode and decode extendend keys to address

{% embed url="<https://gitlab.com/zenprotocol/zen.js>" %}

### Install

```
npm config set @zen:registry https://www.myget.org/F/zenprotocol/npm/ 
npm install --save @zen/zenjs
```

### Generating mnemonic phrase, keys and accepting payments

```typescript
import {Mnemonic, ExtendedKey} from '@zen/zenjs'
const mnemonic = Mnemonic.generateMnemonic(24);
const extendedKey = ExtendedKey.fromMnemonic(mnemonic);
const derivedExtendedKey = extendedKey.derivePath("m/44'/258'/0'/0/0");
const privateKey = derivedExtendedKey.getPrivateKey();
const publicKey = derivedExtendedKey.getPublicKey();
const address = publicKey.toAddress('main');
console.log(address, publicKey.toAddress('main'));
```

### Creating and signing transactions

To create a transaction using a TransactionBuilder, you need to:

* Add an input: This involves providing the transaction hash (txHash) of a previous transaction that contains the unspent transaction output (UTXO) you want to use as an input, along with the index of the UTXO in that transaction. Additionally, you need to provide the private key associated with the UTXO's address.
* Add an output: This involves specifying the receiver's address (where you want to send the funds), the amount of Kalapas (the cryptocurrency) to send, and the asset ID (the identifier of the asset being transferred).

Once you have added the input and output to the transaction, you can proceed to sign it. The signing process involves using the private key associated with the input UTXO to create a digital signature for the transaction. The signature ensures the integrity and authenticity of the transaction.

After the transaction is signed, it needs to be transformed into hexadecimal format (hex) so that it can be published on the network. This encoding ensures that the transaction can be transmitted and understood by the blockchain network.

Here an example:

```typescript
import {TransactionBuilder,ExtendedKey} from '@zen/zenjs'
import {post} from 'axios'

const mnemonic = 'one one one one one one one one one one one one one one one one one one one one one one one one';
const privateKey = ExtendedKey.fromMnemonic(mnemonic).derivePath("m/44'/258'/0'/0/0").getPrivateKey();
const tb = new TransactionBuilder('test');
tb.addInput('0000000000000000000000000000000000000000000000000000000000000000',0, privateKey);
tb.addOutput('tp1qfyplhxql09lvvg53dxg7t77tkkxhsp3l6q8xjjpj85hvqlw0ttqswjdapx', 100, '00');
const tx = tb.sign();
console.log(tx.hash(), tx.toJson());
const hex = tx.toHex();// Transaction is ready to be published 
post('http://127.0.0.1/:31567/blockchain/publishtransaction',hex,{ headers: { 'Content-Type': 'application/json' }});
```

### Wallet functionalities

```typescript
export class Wallet {
    constructor(extendedKey: ExtendedKey, actions: WalletActions, index?: number);
    static fromMnemonic(key: string, actions: WalletActions): Wallet;
    getExternalPublicKey(): PublicKey;
    getExternalPublicKeyHash(): Hash;
    getExternalAddress(): string;
    connectWallet();
    getActiveContracts(): Promise<ActiveContracts[]>;
    getBalance(addresses?: string[]): Promise<{}>;
    submitRepoVote(repoVotingContract: string, commitID: string, phase: "Contestant" | "Candidate", currentInterval: number, privates: PrivateKey[], publish?: boolean): Promise<string>;
    submitCGPBallot(cgpVotingContract: string, command: string, ballotData: Payout | Allocation, isNomination: boolean, currentInterval: number, privates: PrivateKey[], publish?: boolean): Promise<string>;
    signMessage(msg: Buffer, path: string, privates: PrivateKey[]): Signature;
    getAddress(path: string): string;
    getTransactions(skip?: number, take?: number): Promise<Transactions>;
    getTransactionCount(): Promise<number>;
    send(outputs: Array<SpendType>, privates: PrivateKey[], publish?: boolean): Promise<string>;
    sendRaw(outputs: Array<SpendType>): Promise<RawTransaction>;
    executeContract({ address, contractData, privates, publish }?: any): Promise<string>;
    extendContract({ contractId, numberOfBlocks, privates, publish }?: any): Promise<string>;
    activateContract({ code, limit, numberOfBlocks, privates, publish }?: any): Promise<string>;
    signTransaction(unspentTx: Transaction | string, privateKeys: PrivateKey[]): Promise<string>;
    signContractExecution(unspentTx: Transaction | string, sign: string | undefined, privateKeys: PrivateKey[]): Promise<string>;
    collectRaw(requiredAmounts: {[s: string]: string;}, addresses?: string[]);
}
```


---

# 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.zenprotocol.com/apps/zen_js.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.