# Transactions

## Basic usage

```js
import LTO, { Binary } from '@ltonetwork/lto';
enum RELATIONSHIP { MEMBER_OF=0x3400 };
enum STATEMENT { VERIFIED=0x3500 };

lto = new LTO('T');
const account = lto.account();

const recipient = '3N2XoMuukk4BPiLn95vDkv4ocU5szMXuxVN';

lto.getBalance(account);
lto.transfer(account, recipient, 100_00000000);
lto.massTransfer(account, [{recipient: recipient1, amount: 100_00000000}, {recipient: recipient2, amount: 50_00000000}]);

lto.anchor(account, new Binary('some value').hash(), new Binary('other value').hash());
lto.anchor(
  account,
  { key: new Binary('some key').hash(), value: new Binary('some value').hash() },
  { key: new Binary('other key').hash(), value: new Binary('other value').hash() },
);

lto.associate(account, RELATIONSHIP.MEMBER_OF, recipient);
lto.revokeAssociation(account, RELATIONSHIP.MEMBER_OF, recipient);

lto.lease(account, recipient, 10000_00000000);
lto.cancelLease(account, '9V7tdKEEJiH86eCPNxPg1vxhmp8oNH6Mqtf1fQeSeS4U');

lto.sponsor(account, recipient);
lto.cancelSponsorship(account, recipient);

lto.makeStatement(account, STATEMENT.VERIFIED, recipient);

lto.setData(account, {foo: 'bar'});
lto.getData(account);
```

{% hint style="info" %}
Amounts are in `LTO * 10^8`. Eg: 12.46 LTO is`1246000000`, which may be written as `12_46000000` in JavaScript.
{% endhint %}

## Executing Transactions

The `LTO` class provides a simple way for doing transactions. Alternatively, you can create a transaction object, sign it, and broadcast it.

### Create transaction

```js
import { Transfer } from '@ltonetwork/lto/transactions';

const transaction = new Transfer(recipient, amount);
```

### Sign transaction

The Transaction needs then to be signed. In order to sign a transaction an account is needed.

```js
account.sign(transaction);
```

### Broadcasting transaction

For last the transaction needs to be broadcasted to the node. In order to do so we need to connect to the node using the PublicNode class.

```js
const broadcastedTx = await lto.node.broadcast(transaction);
```

### Fluent interface

Transaction classes have convenience methods, providing a fluent interface

```js
import { Transfer } from '@ltonetwork/lto/transactions';

const tx = await new Transfer(recipient, amount)
    .signWith(account)
    .broadcastTo(lto.node);
```

### Sponsoring transactions

A second account can offer to pay for the transaction fees by co-signing the transaction.

```js
import { Anchor } from '@ltonetwork/lto/transactions';

const tx = await new Anchor(new Binary('foo').hash())
    .signWith(someAccount)
    .sponsorWith(mainAccount)
    .broadcastTo(lto.node);
```

Alternatively, you can set the `parent` property of an account to automatically have the parent sponsor all transactions of the child.

## Transaction types

### Transfer transaction

```js
import { Transfer } from '@ltonetwork/lto/transactions';

const tx = new Transfer(recipient, amount, new Binary('attachment'))
```

### Mass Transfer transaction

```js
import { MassTransfer } from '@ltonetwork/lto/transactions';

const tx = new MassTransfer(
  [
    {recipient: recipient1, amount: amount1},
    {recipient: recipient2, amount: amount2}
  ],
  new Binary('attachment'),
);
```

### Anchor transaction

```js
import { Anchor } from '@ltonetwork/lto/transactions';

const hash1 = new Binary('hello').hash();
const hash2 = Binary.fromHex('e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855');

const tx = new Anchor(hash1, hash2, ...);
```

### Mapped Anchor transaction

```javascript
import { MappedAnchor } from '@ltonetwork/lto/transactions';

const hashKey = new Binary('key').hash();
const hashValue = new Binary('value').hash();

const tx = new MappedAnchor({ key: hashKey, value: hashValue }, ...);
```

### Lease transaction

```js
import { Lease } from '@ltonetwork/lto/transactions';

const tx = new Lease(recipient, amount);
```

### Cancel Lease transaction

```js
import { CancelLease } from '@ltonetwork/lto/transactions';

const tx = new CancelLease(leaseId);
```

### SetScript transaction

Create a `SetScript` transaction using the `compile` method of the public node.

```js
const tx = lto.node.compile(script);
```

Clear a script by using `null` as compiled script.

```js
import { SetScript } from '@ltonetwork/lto/transactions';

const tx = new SetScript(null);
```

### Sponsorship transaction

```js
import { SetScript } from '@ltonetwork/lto/transactions';

const tx = new Sponsorship(recipient);
```

### Cancel Sponsorship transaction

```js
import { CancelSponsorship } from '@ltonetwork/lto/transactions';

const tx = new CancelSponsorship(recipient);
```

### Association transaction

```js
import { Association } from '@ltonetwork/lto/transactions';

const tx = new Association(
  association_type,
  recipient,
  new Binary('subject'),
  expires,
  data
);
```

### Revoke Association transaction

```js
import { RevokeAssociation } from '@ltonetwork/lto/transactions';

const tx = new RevokeAssociation(association_type, recipient, new Binary('subject'));

```

### Statement transaction

```javascript
import { Statement } from '@ltonetwork/lto/transactions';

const tx = new Statement(
  statement_type,
  recipient,
  new Binary('subject'),
  expires,
  data
);
```

### Data transaction

```javascript
import { Data } from '@ltonetwork/lto/transactions';

const tx = new Data({
  num: 100,
  str: 'some string',
  bin: new Binary('Hello').hash(),
  bool: true,
});
```

## Public Node

By default, the following public nodes are used

* **Mainnet** - <https://nodes.lto.network>
* **Testnet** - <https://testnet.lto.network>

To use your own public node, set the node address of the `LTO` object.

```javascript
lto.nodeAddress = "http://localhost:6869";
```

The `lto.node` object will automatically be replaced when the node address is changed.


---

# 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.ltonetwork.com/libraries/javascript/transactions.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.