# Receive

The `receive` operation is used to declare that your account expects to receive a certain token or asset from another account. It’s commonly used in swaps and other multi-party interactions where one party commits to sending something, and the other defines what they want in return.

This operator is added to a transaction using a `builder` and is usually paired with a corresponding `send` operation.

## When to Use

* Declaring part of a **swap** (e.g., “I send X, and expect to receive Y”)
* Defining expected incoming tokens or assets in a contract
* Building conditional transactions where value is exchanged

## How it works

When performing a swap, the `send()` operation defines what your account is giving, and the `receive()` operation defines what you expect in return.

You create a transaction using both operations, then **compute** the block — but **don’t publish it**. The resulting unsigned block is meant to be sent to the counterparty (e.g. via QR, API, or message).

They can then **verify, sign, and publish** the transaction on-chain. Once published with signatures, the swap is finalized.

```typescript
const signer = KeetaNet.lib.Account.fromSeed(DEMO_ACCOUNT_SEED, 0);
const client = KeetaNet.UserClient.fromNetwork('test', signer);

// Addresses
const recipient = KeetaNet.lib.Account.fromPublicKeyString('<recipient-address>');
const sendToken = KeetaNet.lib.Account.fromPublicKeyString('<abc-token-address>');
const receiveToken = KeetaNet.lib.Account.fromPublicKeyString('<xyz-token-address>');

// Amounts (assumes you’ve already fetched decimals and validated)
const sendAmount = Numeric.fromDecimalString("10.0", 2);     // 10 ABC
const receiveAmount = Numeric.fromDecimalString("5.0", 2);   // 5 XYZ

// Create transaction
const builder = client.initBuilder();

builder.send(recipient, sendAmount.valueOf(), sendToken);
builder.receive(recipient, receiveAmount.valueOf(), receiveToken, true);

// Compute the transaction block (not yet published)
const { blocks } = await client.computeBuilderBlocks(builder);

// This unsigned block can now be signed and published by the other party
const unsignedBytes = blocks[0].toBytes();

console.log("📦 Unsigned swap block ready for signature:", unsignedBytes);
```

## Signature Flow:

* You (Party A) compute the transaction with `send()` and `receive()`.
* You send the **unpublished block** to Party B (e.g., over API or QR code).
* Party B verifies it, signs it, and publishes the transaction to KeetaNet.
* Done — the atomic swap is complete!

{% hint style="warning" %}
You **must not publish** the block yourself if you're expecting a counterparty to sign it. The final publish should be done by the party who agrees to the trade — typically the one **receiving the assets**.
{% endhint %}