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.
# Event chain
Microledger on the private layer
The event chain is a microledger. Normally, a ledger is a hash chain of blocks, with each block containing multiple transactions. The event chain is a hash chain of individual events.
## **Create an event chain**
The event id is generated from the account public key and a random value or a nonce, to prevent collisions.
```javascript
import LTO from '@ltonetwork/lto';
import { EventChain } from '@ltonetwork/lto/events';
const lto = new LTO('T');
const account = lto.account();
const chain = new EventChain(account); // Creates an empty event chain with a valid id
```
## Adding events
The genesis event determines the purpose of the event chain. For an Ownable, the genesis event contains an instantiate message.
```javascript
import { EventChain, Event } from '@ltonetwork/lto/events';
const body = {
'@context': 'instantiate_msg.json',
ownable_id: '88pDRu52FpsU3kKHwdvPV21RMkBqVqNnthjfdCesTHQhLnUpanw49n6b2PzGnEy',
package: 'bafybeie4ts4mbcw4pswzh45bj32ulcyztup2dr7zbbjv3y2ym3q3uuejba',
network_id: 'T',
};
const lto = new LTO('T');
const account = lto.account();
const chain = new EventChain(account);
new Event(body).addTo(chain).signWith(account);
```
{% hint style="warning" %}
Events need to be added to the chain before they can be signed.
{% endhint %}
## Loading an event chain
You can store or submit an event chain as JSON. To create an event chain object from JSON data use the `from` method.
```javascript
import { EventChain } from '@ltonetwork/lto/events';
const data = {
id: '2dZKMnHHsM1MGqTPZ5p3NmmGmAFE4hYFtMwb2e6tGVDMGZT13cBomKoo8DLEWh',
events: [
{
timestamp: 1519882600,
previous: 'A332JTKSBZipjXxjC1xPxQoheF83WkEBMwLYaYs8yUBa',
signKey: {
keyType: 'ed25519',
publicKey: '2KduZAmAKuXEL463udjCQkVfwJkBQhpciUC4gNiayjSJ',
},
signature: '4xn3xqLFXDLVtUjyKXAjTVGfjWkbCbtyQxFSVoYGLRzePGeyRAeEU7a29ZFztgD3ifwBBMWv9T51ecY2ZBNyWvXV',
hash: 'BRFnaH3UFnABQ1gV1SvT9PLo5ZMFzH7NhqDSgyn1z8wD',
mediaType: 'application/json',
data: 'base64:eyJmb28iOiJiYXIiLCJjb2xvciI6InJlZCJ9',
},
{
timestamp: 1519883600,
previous: 'BRFnaH3UFnABQ1gV1SvT9PLo5ZMFzH7NhqDSgyn1z8wD',
signKey: {
keyType: 'ed25519',
publicKey: '2KduZAmAKuXEL463udjCQkVfwJkBQhpciUC4gNiayjSJ',
},
signature: '2hqLhbmh2eX2WhAgbwHhBZqzdpFcjWBYYN5WBj8zcYVKzVbnVH7mESCC9c9acihxWFwfvufnFYxxgFMgJPbpbU4N',
hash: '9Y9DhjXHdrsUE93TZzSAYBWZS5TDWWNKKh2mihqRCGXh',
mediaType: 'application/json',
data: 'base64:eyJmb28iOiJiYXIiLCJjb2xvciI6ImdyZWVuIn0=',
},
{
timestamp: 1519884600,
previous: '9Y9DhjXHdrsUE93TZzSAYBWZS5TDWWNKKh2mihqRCGXh',
signKey: {
keyType: 'ed25519',
publicKey: '2KduZAmAKuXEL463udjCQkVfwJkBQhpciUC4gNiayjSJ',
},
signature: 'BDtUgUJRmbumMMw3V35v7AJrnJ954cBVYQDPyyMc1Hx2x5LZYZkByuUzNJ2zvUWUhCUL3PJF86FQE6WFyQ7VCZU',
hash: 'C2TsRTTsj7V923RQnEARYL596AXvccd1np32N9of4FaP',
mediaType: 'application/json',
data: 'base64:eyJmb28iOiJiYXIiLCJjb2xvciI6ImJsdWUifQ==',
},
],
};
const chain = EventChain.from(data);
```
### Validation
When receiving an event chain from an untrusted source, you should always validate it. The `validate` method checks the integrity of the hash chain and verifies the signatures.
```javascript
chain.validate();
```
The `validate` function does not return any value, but throws an error in case something is wrong with the chain.
Additionally, you may want to check if the signer of the genesis event is the account that created the event chain.
```javascript
const genesisSigner = lto.account(chain.events[0].signKey);
if (!chain.isCreatedBy(genesisSigner))
throw new Error('Event chain hijacking: genesis event not signed by chain creator');
```
## Partial chain
There are several reasons why you'd only want to get part of the event chain. For instance, you may only need to share added events with another party. To do so, you can `startingWith` or `startingAfter` method.
```javascript
const partial1 = chain.startingWith('9Y9DhjXHdrsUE93TZzSAYBWZS5TDWWNKKh2mihqRCGXh');
const partial2 = chain.startingAfter('9Y9DhjXHdrsUE93TZzSAYBWZS5TDWWNKKh2mihqRCGXh');
```
You can either pass an event hash or an `Event` object.
```javascript
const partial = chain.startAfter(chain.event[1]);
```
### Appending a partial chain
You can append the events of a partial chain to the full chain. If there's an overlap in events, the `add` method will skip those events.
If both chains have the same genesis event, but branch off, a `MergeConflict` will be thrown.
```javascript
try {
chain.add(partial);
} catch (error) {
if (!(error instanceof MergeConflict)) throw error;
// handle merge conflict
}
```
The event chain doesn't have an internal consensus mechanism. Instead, it relies on anchoring events on the public chain to determine which branch should be accepted in case of a merge conflict.
## Anchoring events
To detect rollbacks, resolve merge conflicts, and prevent tampering, events should be anchored. Anchoring is the action of writing the event hash to the public chain.
For rollback detection, we use mapped anchoring where the event hash is combined with a state.
```javascript
import LTO from '@ltonetwork/lto';
const lto = new LTO('T');
const account = lto.account();
const appendedEvents = chain.startingAfter(lastKnownEvent);
const anchorMap = appendedEvents.anchorMap();
await lto.anchor(account, anchorMap);
```
# Messages
Send messages on the private layer
To share information on the private layer, it should be wrapped as a message.
```javascript
import LTO from '@ltonetwork/lto';
import { Message } from '@ltonetwork/lto/messages';
const lto = new LTO('T');
const account = lto.account();
const message = new Message('hello')
.to('3MsAuZ59xHHa5vmoPG45fBGC7PxLCYQZnbM')
.signWith(account);
```
To send a message through a public [LTO Relay service](https://github.com/ltonetwork/relay), it needs to be anchored.
```javascript
await lto.anchor(account, message.hash);
await lto.relay.send(message);
```
{% hint style="success" %}
The requirement to anchor prevents spam by associating a small cost for each message.
{% endhint %}
### Encrypted messages
Messages can be encrypted so the data can only be read or processed by a specific LTO account. Encrypting a message is done using the public key of the recipient.
To get the public key from an address, we'll need to resolve the address. This uses the LTO DID resolver internally.
```javascript
import LTO from '@ltonetwork/lto';
import { Message } from '@ltonetwork/lto/messages';
const lto = new LTO('T');
const account = lto.account();
const recipient = await lto.resolveAccount('3MsAuZ59xHHa5vmoPG45fBGC7PxLCYQZnbM');
const message = new Message('hello')
.encryptFor(recipient)
.signWith(account);
```
{% hint style="warning" %}
Only accounts that have submitted at least one transaction on the public chain can be resolved.
{% endhint %}
The recipient can decrypt the message using its private key.
import LTO from '@ltonetwork/lto';
import { Message } from '@ltonetwork/lto/messages';
const lto = new LTO('T');
const account = lto.account({ seed: 'satisfy sustain shiver skill betray mother appear pupil coconut weasel firm top puzzle monkey seek', nonce: 1 });
const data = {
type: 'message',
sender: { keyType: 'ed25519', publicKey: '3ct1eeZg1ryzz24VHk4CigJxW6Adxh7Syfm459CmGNv2' },
recipient: '3MsAuZ59xHHa5vmoPG45fBGC7PxLCYQZnbM',
timestamp: '2023-06-20T21:40:40.268Z',
signature: '362PiaufpQotrVjXJNQFF9HQ3cqKnmgwD3LzkX3PCWHRzqjUGAQxrWPfCC2irvFUqrM4YkWq9jpv6QYiPJMHTDCJ',
hash: '8cb1ab4507c0f0f9cf9742f98805bf2cb69277c3ac7a845958dfbe087285fbbd',
encryptedData: 'VuQ5544fbeodXVy86g9yk8zVgCjNNXqrMVOAou9d8SQM+2PF/CPuUm/rWEoB5OHSc40H2V3DheEiqkQ9di66NQ==',
};
const message = Message
.from(data)
.decryptWith(account);
### Adding Metadata to Messages
To enhance client-side rendering and improve UX, you can attach metadata to a message before sending it. This metadata allows the receiving wallet to preview the content with a title, description, and thumbnail.
**Supported Metadata Fields**
* `type`: A string identifier (e.g., `"ownable"`) if type is left undefined the library defaults to "basic", generally advised to explictly use "ownable" if its an ownable.
* `title`: A short, human-readable title
* `description`: A brief explanation of the message contents
* `thumbnail`: A binary image preview (max size: **256KB**)
```typescript
const thumbnail = Binary.from(new Uint8Array(buffer)); // ensure <= 256KB
const meta = {
type: "ownable",
title: "Cool Ownable",
description: "Ownable created by @user123",
thumbnail,
};
const message = new Message(
messageContent,
"application/octet-stream",
meta
)
.to(recipient)
.signWith(sender);
await this.relay.send(message);
```
{% hint style="info" %}
Metadata is optional, but including it enables:
* Rich previews in wallet interfaces
* Early validation before import
{% endhint %}
## Ownables messages
By default, messages are assigned the `basic` type, which provides minimal descriptive context. While this is sufficient for most simple message exchanges, it lacks the flexibility needed for richer, more descriptive content.
Starting from versions **v0.15.17** and **v0.16.9+**, support for **message metadata** and **message versioning** was introduced. This enhancement allows developers to embed additional context such as a **title**, **description**, and a **thumbnail** directly into the message metadata.
This is particularly valuable for **Ownables**, where visual and descriptive cues are essential for user comprehension. With metadata support, client-side applications can render messages with meaningful context, without decrypting and parsing message bodies just to extract basic display information. This not only improves performance but also significantly enhances the developer and user experience.
```javascript
import {Message, Binary} from '@ltonetwork/lto/messages'
const imageBuffer = await some-image-file.arrayBuffer()
const meta = {
type: "ownable", //defaults to basic if not provided
title: "ownableRobot",
description: "A simple robot ownables",
thumbnail: Binary.from(new Uint8Array(image-file)),
}
//application-octet sets the mediaType arbitrarily
const message = new Message('hello', "application/octet-stream", meta)
.encryptFor(recipient)
.signWith(account);
```
{% hint style="info" %}
Messages with a metadata are marked version=1, Messages without a metadata have a version=0
{% endhint %}
{% hint style="info" %}
Thumbnails are optional, but if you must include it, then it should be in a Binary format
{% endhint %}
## Relay service
By default, messages are posted through . Instead of depending on the public relay service, you can [host your own](https://github.com/ltonetwork/relay).
```javascript
import LTO from '@ltonetwork/lto';
import { Relay } from '@ltonetwork/lto/messages';
const lto = new LTO('T');
lto.relay = new Relay('https://my-relay.example.com');
```
# Identities
Create a DID Document for an account
Any account on LTO network, for which the public key is known, can be resolved as DID (decentralized identifier). To explicitly create a DID use the identity builder.
```js
import LTO from '@ltonetwork/lto';
import { IdentityBuilder } from '@ltonetwork/lto/identities';
const lto = new LTO('T');
const account = lto.account();
new IdentityBuilder(account)
.transactions.map(tx => lto.node.broadcast(tx));
```
The main account is known as the management key.
{% hint style="info" %}
Use `Promise.all()` if you wait to await for the transactions to be broadcasted.
{% endhint %}
### Verification methods
By default, the account's public key is the only verification method of the DID. Other verification methods can be added through associations with other accounts.
```js
import LTO from '@ltonetwork/lto';
import { IdentityBuilder } from '@ltonetwork/lto/identities';
const lto = new LTO('T');
const account = lto.account();
const key1 = lto.account({ publicKey: "8cMyCW5Esx98zBqQCy9N36UaGZuNcuJhVe17DuG42dHS" });
const key2 = lto.account({ publicKey: "9ubzzV9tRYTcQee68v1mUPJW7PHdB74LZEgG1MgZUExf" });
const expires = new Date();
expires.setFullYear(expires.getFullYear() + 1);
new IdentityBuilder(account)
.addVerificationMethod(key1)
.addVerificationMethod(key2, ['authentication', 'assertionMethod'], expires)
.transactions.map(tx => lto.node.broadcast(tx));
```
If no verification relationships are specified, it is only listed as a verification method, which is typically not what you want. Optionally, you can have the verification method automatically expire.
#### Revoking verification methods
```javascript
import LTO from '@ltonetwork/lto';
import { IdentityBuilder } from '@ltonetwork/lto/identities';
const lto = new LTO('T');
const account = lto.account();
const key = lto.account({publicKey: "8cMyCW5Esx98zBqQCy9N36UaGZuNcuJhVe17DuG42dHS"});
new IdentityBuilder(account)
.removeVerificationMethod(key)
.transactions.map(tx => lto.node.broadcast(tx));
```
Verification methods can also be removed by address.
### Services
```javascript
import LTO from '@ltonetwork/lto';
import { IdentityBuilder } from '@ltonetwork/lto/identities';
const lto = new LTO('T');
const account = lto.account();
new IdentityBuilder(account)
.addService({type: 'LTORelay', serviceEndpoint: 'ampq://relay.lto.network'})
.transactions.map(tx => lto.node.broadcast(tx));
```
#### Removing services
```javascript
import LTO from '@ltonetwork/lto';
import { IdentityBuilder } from '@ltonetwork/lto/identities';
const lto = new LTO('T');
const account = lto.account();
new IdentityBuilder(account)
.removeService({type: 'LTORelay'})
.transactions.map(tx => lto.node.broadcast(tx));
```
A service may also be removed by id.
### Deactivation
If the management key is compromised, the DID should be deactivated.
```javascript
import LTO from '@ltonetwork/lto';
import { IdentityBuilder } from '@ltonetwork/lto/identities';
const lto = new LTO('T');
const account = lto.account();
new IdentityBuilder(account).deactivate().broadcastTo(lto.node);
```
#### Grant deactivation capability
Allow a trusted party to deactivate the DID in case the management key is lost.
```javascript
import LTO from '@ltonetwork/lto';
import { IdentityBuilder } from '@ltonetwork/lto/identities';
const lto = new LTO('T');
const account = lto.account();
const trustedAccount = lto.account({publicKey: "8cMyCW5Esx98zBqQCy9N36UaGZuNcuJhVe17DuG42dHS"});
const expires = new Date();
expires.setFullYear(expires.getFullYear() + 1);
const revokeDelay = 86400_000; // 24h in ms
new IdentityBuilder(account)
.grantDisableCapability(trustedAccount, expires, revokeDelay)
.transactions.map(tx => lto.node.broadcast(tx));
```
The `expires` and `revokeDelay` arguments are optional.
#### Revoke deactivation capability
```javascript
import LTO from '@ltonetwork/lto';
import { IdentityBuilder } from '@ltonetwork/lto/identities';
const lto = new LTO('T');
const account = lto.account();
const trustedAccount = lto.account({publicKey: "8cMyCW5Esx98zBqQCy9N36UaGZuNcuJhVe17DuG42dHS"});
new IdentityBuilder(account)
.revokeDisableCapability(trustedAccount)
.transactions.map(tx => lto.node.broadcast(tx));
```
# HTTP Authentication
To authenticate to a backend service with an LTO account, you can sign the HTTP request using the [HTTP Message Signatures draft standard](https://www.ietf.org/archive/id/draft-ietf-httpbis-message-signatures-00.html).
## Installation
```
npm install @ltonetwork/http-message-signatures --save
```
## Signing
The `sign()` method accepts an LTO account as the `signer`. The `keyid` will be the public key of the account.
```javascript
import LTO from '@ltonetwork/lto';
import { sign } from '@ltonetwork/http-message-signatures';
const lto = new LTO();
const account = lto.account();
const request = {
method: 'GET',
url: 'https://example.com/api/data',
};
const signedRequest = await sign(request, { signer: account });
// ... Send the signed request to the server
```
You can sign a [Fetch API Request](https://developer.mozilla.org/en-US/docs/Web/API/Request) object or a plain object.
## Verification
The `verify()` method accepts an LTO client as verifier. The key type is determined based on the algorithm specified in the `Signature`. The keyid is used as the public key. The `verify()` method uses the LTO Client to create an account from the public key and verify the signature.
```javascript
import LTO from '@ltonetwork/lto';
import { verify } from '@ltonetwork/http-message-signatures';
const lto = new LTO();
const request = {
method: 'GET',
url: 'https://example.com/api/data',
headers: {
'Signature-Input': 'sig1=("@method" "@path" "@authority");created=1618884475;keyid="2KduZAmAKuXEL463udjCQkVfwJkBQhpciUC4gNiayjSJ";alg=ed25519',
'Signature': 'sig1=:base64signature:'
}
};
(async () => {
try {
const account = await verify(request, lto);
console.log('Verification succeeded');
} catch (err) {
console.error('Verification failed:', err.message);
}
})();
```
# Python
Python client library for interacting with LTO Network
{% hint style="info" %}
Visit the [project on Github](https://github.com/ltonetwork/lto-api.python)
{% endhint %}
## Installation
```shell
pip install lto
```
## Usage
```python
from lto import LTO
from lto.public_node import PublicNode
seed = "manage manual recall harvest series desert melt police rose hollow moral pledge kitten position add"
account = LTO("T").Account(seed='seed')
node = PublicNode("https://testnet.lto.network")
amount = 1000.0 # Amount of LTO to transfer
recipient = "3Jo1JCrBvnWCg37VDxMXAjYhsS9rRDLBSze"
transaction = Transfer(recipient, amount)
transaction.sign_with(account)
transaction.broadcast_to(node)
```
To check the response from the node is easy, just modify the last line and add a print
```python
response = transaction.broadcast_to(node)
print(response.to_json())
```
# Accounts
## Creation
### Create an account
```
from lto import LTO
account = LTO(chain_id).Account()
```
### Create an account from seed
```
from lto import LTO
account = LTO(chain_id).Account(seed=my_seed)
```
### Create an account from public key
```
from lto import LTO
account = LTO(chain_id).Account(public_key=my_pub_key)
```
### Create an account from private key
```
from lto import LTO
account = LTO(chain_id).Account(provate_key=my_priv_key)
```
## Different encryption algorithms
### If not specified EdDSA is default:
**ed25519**
```
account = LTO(chain_id).Account()
```
### For ECDSA we have two available curves:
**secp256k1**
```
account = LTO(chain_id).Account(key_type = "secp256k1")
```
**secp256r1**
```
account = LTO(chain_id).Account(key_type = "secp256r1")
```
## Signing
### Signing a message
We first need to convert the string to bytes using our crypto library
```
from lto import crypto
message = crypto.str2bytes("test")
signature = account.sign(message)
```
### Verifying a message
```
account.verify_signature(message, signature)
```
# Public layer
## Executing Transactions
### Create transaction
First a transaction needs to be created.
```python
from src.LTO.Transactions.Transfer import Transfer
transaction = Transfer(recipient, amount)
```
The Transaction needs then to be signed. In order to sign a transaction an account is needed.
### Sign transaction
```python
transaction.sign_with(account)
```
### Broadcast 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.
```python
from src.LTO.PublicNode import PublicNode
node = PublicNode(url)
```
The url refers to the node, there are many nodes available, here there are two examples, one for the mainnet and one for the testnet
*
*
```python
transaction.broadcast_to(node)
```
## Transactions
### Transfer Transaction
```python
from lto.transactions import Transfer
transaction = Transfer(recipient, amount)
```
### Mass Transfer Transaction
```python
from lto.transactions import MassTransfer
transaction = MassTransfer(transfers)
```
### Anchor Transaction
```python
from lto.transactions import Anchor
transaction = Anchor(anchor)
```
### Lease Transaction
```python
from lto.transactions import Lease
transaction = Lease(recipient, amount)
```
### Cancel Lease Transaction
```python
from lto.transactions import CancelLease
transaction = CancelLease(lease_id)
```
### SetScript Transaction
```python
from lto.transactions import SetScript
transaction = SetScript(script)
```
### Sponsorship transaction
```python
from lto.transactions import Sponsorship
transaction = Sponsorship(recipient)
```
### Cancel Sponsorship transaction
```python
from lto.transactions import CancelSponsorship
transaction = CancelSponsorship(recipient)
```
### Association transaction
```python
from lto.transactions import Association
transaction = Association(recipient, association_type, anchor)
```
### Revoke Association transaction
```python
from lto.transactions import RevokeAssociation
transaction = RevokeAssociation(recipient, association_type, anchor)
```
### Data transaction
```python
from lto.transactions import Data
transaction = Data(data_entries)
```
### Register transaction
```python
from lto.transactions import Register
transaction = Register(account2, account3)
```
### Burn transaction
```python
from lto.transactions import Burn
transaction = Burn(amount)
```
# PHP
PHP client library for interacting with LTO Network
{% hint style="success" %}
Visit the [project on GitHub](https://github.com/ltonetwork/lto-api.php).
{% endhint %}
## Installation
```
composer require lto/api
```
## Usage
```php
use LTO\Transaction\Transfer;
use LTO\PublicNode;
// Create account for signing
$seedText = "manage manual recall harvest series desert melt police rose hollow moral pledge kitten position add";
$factory = new LTO\AccountFactory('T'); // 'T' for testnet, 'L' for mainnet
$account = $factory->seed($seedText);
// Public layer
$node = new PublicNode('https://nodes.lto.network');
$amount = 1000.0; // Amount of LTO to transfer
$recipient = "3Jo1JCrBvnWCg37VDxMXAjYhsS9rRDLBSze";
$transferTx = (new Transfer($amount, $recipient))
->signWith($account)
->broadcastTo($node);
// Private layer
$body = [
'$schema' => "http://specs.example.com/message",
'content' => "Hello world!",
];
$chain = $account->createEventChain();
$chain->addIdentity($account->asIdentity())->signWith($account);
$chain->add(new Event($body))->signWith($account);
```
# Accounts
## Creation
### **Create an account from seed**
```php
$seedText = "manage manual recall harvest series desert melt police rose hollow moral pledge kitten position add";
$factory = new LTO\AccountFactory('T'); // 'T' for testnet, 'L' for mainnet
$account = $factory->seed($seedText);
```
### **Create an account from private sign key**
```php
$secretKey = 'wJ4WH8dD88fSkNdFQRjaAhjFUZzZhV5yiDLDwNUnp6bYwRXrvWV8MJhQ9HL9uqMDG1n7XpTGZx7PafqaayQV8Rp';
$factory = new LTO\AccountFactory('T'); // 'T' for testnet, 'L' for mainnet
$account = $factory->create($secretKey);
```
### **Create an account from full info**
```php
$accountInfo = [
'address' => '3PLSsSDUn3kZdGe8qWEDak9y8oAjLVecXV1',
'sign' => [
'secretkey' => 'wJ4WH8dD88fSkNdFQRjaAhjFUZzZhV5yiDLDwNUnp6bYwRXrvWV8MJhQ9HL9uqMDG1n7XpTGZx7PafqaayQV8Rp',
'publickey' => 'FkU1XyfrCftc4pQKXCrrDyRLSnifX1SMvmx1CYiiyB3Y'
],
'encrypt' => [
'secretkey' => 'BnjFJJarge15FiqcxrB7Mzt68nseBXXR4LQ54qFBsWJN',
'publickey' => 'BVv1ZuE3gKFa6krwWJQwEmrLYUESuUabNCXgYTmCoBt6'
]
];
$factory = new LTO\AccountFactory('T'); // 'T' for testnet, 'L' for mainnet
$account = $factory->create($accountInfo);
```
Properties that are specified will be verified. Properties that are omitted will be generated where possible.
## Signing (ED25519)
### **Sign a message**
```php
$signature = $account->sign('hello world'); // Base58 encoded signature
```
### **Verify a signature**
```php
if (!$account->verify($signature, 'hello world')) {
throw new RuntimeException('invalid signature');
}
```
## Encryption (X25519)
### **Encrypt a message for another account**
```php
$message = 'hello world';
$recipientPublicKey = "HBqhfdFASRQ5eBBpu2y6c6KKi1az6bMx8v1JxX4iW1Q8"; // base58 encoded X25519 public key
$recipient = $factory->createPublic(null, $recipientPublicKey);
$cyphertext = $account->encryptFor($recipient, $message); // Raw binary, not encoded
```
You can use `$account->encryptFor($account, $message)` to encrypt a message for yourself.
### **Decrypt a message received from another account**
```php
$senderPublicKey = "HBqhfdFASRQ5eBBpu2y6c6KKi1az6bMx8v1JxX4iW1Q8"; // base58 encoded X25519 public key
$sender = $factory->createPublic(null, $senderPublicKey);
$message = $account->decryptFrom($sender, $cyphertext);
```
You can use `$account->decryptFrom($account, $message)` to decrypt a message from yourself.
# Identities
The LTO identity library supports resolving DIDs to DID documents. It's DID method independent.
## Resolver
```php
use LTO\Identity\Resolver\LTONetwork as LTOResolver;
$resolver = new LTOResolver();
$identity = $resolver->resolve("lto:did:3JkihPXS5iPs8xDKcFQmhR8TVcAmDRUZpyx");
```
The Resolver class can be used to combine multiple resolvers.
```php
use LTO\Identity\Resolver;
use LTO\Identity\Resolver\LTONetwork as LTOResolver;
use LTO\Identity\Resolver\WebNetwork as WebResolver;
$resolver = new Resolver(
new LTOResolver(),
new WebResolver(),
);
$identity = $resolver->resolve("lto:did:3JkihPXS5iPs8xDKcFQmhR8TVcAmDRUZpyx");
```
## Identity
The identity is a representation of a DID document.
After a signature or JWT is verified, use `hasVerificationMethod()` to check if the public key used in the verification belongs to the identity.
```php
$method = [
"type": "Ed25519VerificationKey2018",
"publicKeyBase58": "H3C2AVvLMv6gmMNam3uVAjZpfkcJCwDwnZn6z3wXmqPV",
];
$identity->hasVerificationMethod($method);
```
Optionally check if the verification method can be used for a specific purpose
```php
use LTO\Identity\VerificationMethod;
$identity->hasVerificationMethod($method, VerificationMethod\Authentication);
```
---
[Next Page](/llms-full.txt/1)
We could represent this with an NFT smart contract. The NFT is minted by Volvo and transferred to Arnold, who transfers it to Bob. The verifier can ask the contract who the current owner is: Bob.
On LTO, we would present this as 3 statements. Each statement would have the same subject, which should be a unique reference to the car. To find out the current owner, a verifier needs to track the car from the manufacturer, following all related statements.
#### Invalid statement
Xavier wants to make a statement that he transferred the car to David.
With a smart contract, this statement would be denied, as Xavier isn't the owner of the car.
On LTO, Xavier is able to publish this statement on-chain. A verifier will disregard this statement because it doesn't come across it when tracking it from the manufacturer.
#### Authorized statement
Since we're tracking a real-world asset, we might come across a situation where an authority, like law enforcement, has taken hold of an asset without the consent of the current owner.
To make this possible with a smart contract, the issuers must keep a list of authorized accounts that are able to seize a token.
On LTO, the police can publish this statement on-chain. It's up to the verifier to determine if should honor this statement, making David the current owner.
### Responsibility
Looking at the previous example, we can see the key difference between the smart contract and the approach taken by LTO Network.
With a smart contract, it's the original issuer that determines which statements should be accepted. This does not match the scenario in the real world. It's typically not up to the manufacturer of the car to determine which authority is recognized and which isn't.
With statements on LTO Network, it's up to the verifier to determine with authority to recognize. This more closely resembles the real-world situation, where it's up to a potential buyer to ensure he's purchasing the car from the legal owner.
### Conclusion
The design choices make LTO Network better suited for mimicking real-world scenarios and tracking off-chain assets than most other blockchains. On the other hand, it makes it less suited for on-chain assets, as validators might come to a different conclusion if they don't follow the same ruleset.
Putting the responsibility of validation on the end-user (application) is uncommon for a blockchain, but very common for other decentralized technologies. For example; anyone can issue a [verifiable credential](/protocol/identities/verifiable-credentials). It's up to the recipient of the verifiable claim to determine whether or not to accept it.
Because of this, it will feel more natural to combine non-blockchain decentralized technologies with LTO Network than with most other blockchains.
## Decentralized graph
Smart contracts provide an isolated state. With LTO Network, we need to consider all data on the network to make conclusions. The best way to look at the information on the LTO public blockchain is as a decentralized directed graph.
A graph is made up of points (also called vertices) connected with edges. Both the points and edges can have data. On LTO, the points are accounts and the edges are created through associations.
### Statements
The graph can help determine which statements to consider and which to ignore. There are different kinds of statements that can be made. Off-chain these are in the form of verifiable credentials. On-chain, there are statement transactions allowing a public statement about any subject and/or another account.
Anchoring can also be seen as a statement. It's limited to just publishing a hash, but more cost-efficient.
### Identities
The graph allows you to specify other keys that you own and for what purpose you use them. This information is used to build up a [DID document](/protocol/identities/decentralized-identifiers). Decentralized Identifiers (DID) is an emerging standard for (off-chain) authentication, that's already widely supported.
Besides public keys, services can be defined as part of the DID document. This is supported by LTO through Data transactions. Other personal information like name, address, etc is never part of a DID document.
## Private layer
The private layer is not a blockchain. It consists of individual micro-ledgers, called event chains, that are shared between accounts.
A blockchain accomplishes decentralization by sharing data between public nodes (run by independent parties), where it's stored in such a way that the authenticity can be validated. The user only needs to store their private key in a wallet application. The information is retrieved from a public node.
Sharing information publicly isn't always a viable option. It may reveal company secrets or contain personal information. Especially with personal information we need to be careful. Information on a blockchain can't be erased, which violates privacy regulations like GDPR.
With the LTO private layer data isn't stored by public nodes but in the wallet of the user. The public blockchain is only utilized to validate the authenticity of the stored data.
### Messaging
Unless account holders physically meet, it's not possible to send data directly from one wallet to another. To solve this, data is wrapped in messages that are routed through a relay service.
This service is comparable to e-mail, except it works with encrypted messages, and the service endpoint is configured through the DID document, rather than through DNS. The relay protocol is based on AMPQ, ensuring that messages aren't lost even when a service is temporarily unavailable.
{% hint style="warning" %}
[DIDComm](https://didcomm.org/) is an open standard with a functionality that's similar to LTO Messaging. At this moment the technology is under development and available libraries are not production ready. In the future, LTO might switch from our custom protocol to DIDComm.
{% endhint %}
### Event chain
Normally a ledger is a hash chain of blocks, with each block containing multiple transactions. The event chain consists of individual events. Each event references the previous event, forming a hash chain.
```
You can use this template and customize it to display your own ownable widget. All you have to do is replace the title used in `