# Your First Transaction
This tutorial describes how to generate and submit transactions to the Endless blockchain, and verify these submitted transactions. The `transfer-coin` example used in this tutorial is built with the Endless SDKs.
## Step 1: Pick an SDK
Install your preferred SDK from the below list:
* TypeScript SDK
* Rust SDK
***
## Step 2: Run the example
Clone the endless-ts-sdk repo and build it:
```shell
git clone https://github.com/endless-labs/endless-ts-sdk.git
cd endless-ts-sdk
pnpm install
pnpm build
```
Navigate to the Typescript examples directory:
```shell
cd examples/endless
```
Install the necessary dependencies:
```shell
pnpm install
```
Run the [`transfer_coin`](https://github.com/endless-labs/endless-ts-sdk/blob/main/examples/endless/transfer_coin.ts) example:
```shell
pnpm run transfer_coin
```
Clone the endless-core repo:
```shell
git clone https://github.com/endless-labs/endless.git
```
**Rust**
Clone the endless-core repo:
```shell
git clone https://github.com/endless-labs/endless.git
```
Navigate to the Rust SDK directory:
```shell
cd endless-core/sdk
```
Run the [`transfer_coin`](https://github.com/endless-labs/endless/blob/main/sdk/examples/transfer_coin.rs) example:
```shell
cargo run --example transfer_coin
```
***
## Step 3: Understand the output
An output very similar to the following will appear after executing the above command:
```js
=== Addresses ===
Alice's address is: 0xbd20517751571ba3fd06326c23761bc0bc69cf450898ffb43412fbe670c28806
Bob's address is: 0x8705f98a74f5efe17740276ed75031927402c3a965e10f2ee16cda46d99d8f7f
=== Funding Alice ===
=== Initial Balances ===
Alice's balance is: 1000000000
Bob's balance is: 0
=== Transfer 1000000 from Alice to Bob ===
Committed transaction: 0xc0d348afdfc34ae2c48971b253ece727cc9980dde182e2f2c42834552cbbf04c
=== Balances after transfer ===
Alice's balance is: 998899500
Bob's balance is: 1000000
```
The above output demonstrates that the `transfer-coin` example executes the following steps:
* Initializing the Endless client.
* The creation of two accounts: Alice and Bob.
* The funding and creation of Alice's account from a faucet.
* The transferring of 1000000 coins from Alice to Bob.
* The 100500 coins of gas paid for by Alice to make that transfer.
Now see the below walkthrough of the SDK functions used to accomplish the above steps.
***
## Step 4: The SDK in depth
The `transfer-coin` example code uses helper functions to interact with the [REST API](https://rpc-test.endless.link/v1/spec#/). This section reviews each of the calls and gives insights into functionality.
{% hint style="info" %}
See the full code See the TypeScript [`transfer_coin`](https://docs.endless.link/endless/devbuild/build/tutorials/your-first-transaction) for the complete code as you follow the below steps.
{% endhint %}
***
### Step 4.1: Initializing the clients
In the first step, the `transfer_coin` example initializes the Endless client:
```js
const config = new EndlessConfig({
network: Network.TESTNET,
fullnode: "https://rpc-test.endless.link/v1",
indexer: "https://idx-test.endless.link/api/v1",
});
const endless = new Endless(config);
```
{% hint style="info" %}
By default, the Endless client points to Endless testnet services. However, it can be configured with the `network` input argument
{% endhint %}
In the first step, the \`transfer\_coin\` example initializes the REST and indexer clients:
* The REST client interacts with the REST API.
* The indexer client interacts with the tesnet indexer service for complex searching.
***
### Step 4.2: Creating local accounts
The next step is to create two accounts locally. Accounts represent both on and off-chain state. Off-chain state consists of an address and the public/private key pair used to authenticate ownership. This step demonstrates how to generate that off-chain state.
```js
const alice = Account.generate();
const bob = Account.generate();
```
***
### Step 4.3: Creating blockchain accounts
In Endless, each account must have an on-chain representation in order to receive tokens and coins and interact with other dapps. An account represents a medium for storing assets; hence, it must be explicitly created. This example leverages the Faucet to create and fund Alice's account and to create but not fund Bob's account:
```js
const fund_tx = await endless.fundAccount({ signer: alice });
await endless.waitForTransaction({ transactionHash: fund_tx.hash });
```
***
### Step 4.4: Reading balances
In this step, the SDK translates a single call into the process of querying a resource and reading a field from that resource.
```js
const ALICE_INITIAL_BALANCE = await endless.viewEDSBalance(alice.accountAddress);
const BOB_INITIAL_BALANCE = await endless.viewEDSBalance(bob.accountAddress);
```
Behind the scenes, the `balance` function uses the SDK `viewCoinBalance` function that reads the FungibleStore stored value:
```js
const EDSMetadataAddress = "ENDLESSsssssssssssssssssssssssssssssssssssss";
return viewCoinBalance({
endlessConfig: this.config,
account,
fungibleAssetMetadataAddress: AccountAddress.from(EDSMetadataAddress),
});
```
***
### Step 4.5: Transferring
Like the previous step, this is another helper step that constructs a transaction transferring the coins from Alice to Bob. The SDK provides a helper function to generate a `transferEDS` transaction that can be simulated or submitted to chain. Once a transaction has been submitted to chain, the API will return a transaction hash that can be used in the subsequent step to check on the transaction status. The Endless blockchain does perform a handful of validation checks on submission; and if any of those fail, the user will instead be given an error. These validations use the transaction signature and unused sequence number, and submitting the transaction to the appropriate chain.
```js
const transaction = await endless.transferEDS({
sender: alice,
recipient: bob.accountAddress,
amount: Number(TRANSFER_AMOUNT),
});
const pendingTxn = await endless.signAndSubmitTransaction({ signer: alice, transaction });
```
Behind the scenes, the `transferEDS` function generates a transaction payload that can be simulated or submitted to chain:
```js
export async function transferEDS(args: {
endlessConfig: EndlessConfig;
sender: Account;
recipient: AccountAddress;
amount: AnyNumber;
options?: InputGenerateTransactionOptions;
}): Promise {
const { endlessConfig, sender, recipient, amount, options } = args;
return generateTransaction({
endlessConfig,
sender: sender.accountAddress,
data: {
function: "0x1::endless_account::transfer",
functionArguments: [recipient, amount],
abi: transferEDSAbi,
},
options,
});
}
```
Breaking the above down into pieces:
1. `transfer_coins` internally is a `EntryFunction` in the [Endless Account Move module](https://docs.endless.link/endless/devbuild/build/tutorials/your-first-transaction), i.e. an entry function in Move that is directly callable.
2. The Move function is stored on the endless\_account module: `0x1::endless_account`.
Like the previous step, this is another helper step that constructs a transaction transferring the coins from Alice to Bob. For correctly generated transactions, the API will return a transaction hash that can be used in the subsequent step to check on the transaction status. The Endless blockchain does perform a handful of validation checks on submission; and if any of those fail, the user will instead be given an error. These validations use the transaction signature and unused sequence number, and submitting the transaction to the appropriate chain.
***
### Step 4.6: Waiting for transaction resolution
In the TypeScript SDK, just calling `waitForTransaction` is sufficient to wait for the transaction to complete. The function will return the `Transaction` returned by the API once it is processed (either successfully or unsuccessfully) or throw an error if processing time exceeds the timeout.
```js
const response = await endless.waitForTransaction({
transactionHash: pendingTxn.hash,
});
```
The transaction hash can be used to query the status of a transaction:
## Supporting documentation
* [Account basics](https://docs.endless.link/endless/devbuild/technical-documentation/endless-account)
* [TypeScript SDK](https://github.com/endless-labs/endless-ts-sdk)
* [Golang SDK](https://github.com/endless-labs/endless-go-sdk)
* [Rust SDK](https://github.com/endless-labs/endless-rust-sdk)
* [REST API specification](https://rpc.endless.link/v1/spec#/)
---
# 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.endless.link/endless/devbuild/build/tutorials/your-first-transaction.md?ask=
```
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.