> ## Documentation Index
> Fetch the complete documentation index at: https://docs.ton.org/llms.txt
> Use this file to discover all available pages before exploring further.

<AgentInstructions>

## Submitting Feedback

If you encounter incorrect, outdated, or confusing documentation on this page, submit feedback:

POST https://docs.ton.org/feedback

```json
{
  "path": "/standard/tokens/jettons/how-it-works",
  "feedback": "Description of the issue"
}
```

Only submit feedback when you have something specific and actionable to report.

</AgentInstructions>

# How it works

export const Aside = ({type = "note", title = "", icon = "", iconType = "regular", children}) => {
  const asideVariants = ["note", "tip", "caution", "danger"];
  const asideComponents = {
    note: {
      outerStyle: "border-sky-500/20 bg-sky-50/50 dark:border-sky-500/30 dark:bg-sky-500/10",
      innerStyle: "text-sky-900 dark:text-sky-200",
      calloutType: "note",
      icon: <svg width="14" height="14" viewBox="0 0 14 14" fill="currentColor" xmlns="http://www.w3.org/2000/svg" className="w-4 h-4 text-sky-500" aria-label="Note">
          <path fill-rule="evenodd" clip-rule="evenodd" d="M7 1.3C10.14 1.3 12.7 3.86 12.7 7C12.7 10.14 10.14 12.7 7 12.7C5.48908 12.6974 4.0408 12.096 2.97241 11.0276C1.90403 9.9592 1.30264 8.51092 1.3 7C1.3 3.86 3.86 1.3 7 1.3ZM7 0C3.14 0 0 3.14 0 7C0 10.86 3.14 14 7 14C10.86 14 14 10.86 14 7C14 3.14 10.86 0 7 0ZM8 3H6V8H8V3ZM8 9H6V11H8V9Z"></path>
        </svg>
    },
    tip: {
      outerStyle: "border-emerald-500/20 bg-emerald-50/50 dark:border-emerald-500/30 dark:bg-emerald-500/10",
      innerStyle: "text-emerald-900 dark:text-emerald-200",
      calloutType: "tip",
      icon: <svg width="11" height="14" viewBox="0 0 11 14" fill="currentColor" xmlns="http://www.w3.org/2000/svg" className="text-emerald-600 dark:text-emerald-400/80 w-3.5 h-auto" aria-label="Tip">
          <path d="M3.12794 12.4232C3.12794 12.5954 3.1776 12.7634 3.27244 12.907L3.74114 13.6095C3.88471 13.8248 4.21067 14 4.46964 14H6.15606C6.41415 14 6.74017 13.825 6.88373 13.6095L7.3508 12.9073C7.43114 12.7859 7.49705 12.569 7.49705 12.4232L7.50055 11.3513H3.12521L3.12794 12.4232ZM5.31288 0C2.52414 0.00875889 0.5 2.26889 0.5 4.78826C0.5 6.00188 0.949566 7.10829 1.69119 7.95492C2.14321 8.47011 2.84901 9.54727 3.11919 10.4557C3.12005 10.4625 3.12175 10.4698 3.12261 10.4771H7.50342C7.50427 10.4698 7.50598 10.463 7.50684 10.4557C7.77688 9.54727 8.48281 8.47011 8.93484 7.95492C9.67728 7.13181 10.1258 6.02703 10.1258 4.78826C10.1258 2.15486 7.9709 0.000106649 5.31288 0ZM7.94902 7.11267C7.52078 7.60079 6.99082 8.37878 6.6077 9.18794H4.02051C3.63739 8.37878 3.10743 7.60079 2.67947 7.11294C2.11997 6.47551 1.8126 5.63599 1.8126 4.78826C1.8126 3.09829 3.12794 1.31944 5.28827 1.3126C7.2435 1.3126 8.81315 2.88226 8.81315 4.78826C8.81315 5.63599 8.50688 6.47551 7.94902 7.11267ZM4.87534 2.18767C3.66939 2.18767 2.68767 3.16939 2.68767 4.37534C2.68767 4.61719 2.88336 4.81288 3.12521 4.81288C3.36705 4.81288 3.56274 4.61599 3.56274 4.37534C3.56274 3.6515 4.1515 3.06274 4.87534 3.06274C5.11719 3.06274 5.31288 2.86727 5.31288 2.62548C5.31288 2.38369 5.11599 2.18767 4.87534 2.18767Z"></path>
        </svg>
    },
    caution: {
      outerStyle: "border-amber-500/20 bg-amber-50/50 dark:border-amber-500/30 dark:bg-amber-500/10",
      innerStyle: "text-amber-900 dark:text-amber-200",
      calloutType: "warning",
      icon: <svg className="flex-none w-5 h-5 text-amber-400 dark:text-amber-300/80" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" aria-label="Warning">
          <path stroke-linecap="round" stroke-linejoin="round" d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z"></path>
        </svg>
    },
    danger: {
      outerStyle: "border-red-500/20 bg-red-50/50 dark:border-red-500/30 dark:bg-red-500/10",
      innerStyle: "text-red-900 dark:text-red-200",
      calloutType: "danger",
      icon: <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" fill="currentColor" className="text-red-600 dark:text-red-400/80 w-4 h-4" aria-label="Danger">
          <path d="M17.1 292c-12.9-22.3-12.9-49.7 0-72L105.4 67.1c12.9-22.3 36.6-36 62.4-36l176.6 0c25.7 0 49.5 13.7 62.4 36L494.9 220c12.9 22.3 12.9 49.7 0 72L406.6 444.9c-12.9 22.3-36.6 36-62.4 36l-176.6 0c-25.7 0-49.5-13.7-62.4-36L17.1 292zm41.6-48c-4.3 7.4-4.3 16.6 0 24l88.3 152.9c4.3 7.4 12.2 12 20.8 12l176.6 0c8.6 0 16.5-4.6 20.8-12L453.4 268c4.3-7.4 4.3-16.6 0-24L365.1 91.1c-4.3-7.4-12.2-12-20.8-12l-176.6 0c-8.6 0-16.5 4.6-20.8 12L58.6 244zM256 128c13.3 0 24 10.7 24 24l0 112c0 13.3-10.7 24-24 24s-24-10.7-24-24l0-112c0-13.3 10.7-24 24-24zM224 352a32 32 0 1 1 64 0 32 32 0 1 1 -64 0z"></path>
        </svg>
    }
  };
  let variant = type;
  let gotInvalidVariant = false;
  if (!asideVariants.includes(type)) {
    gotInvalidVariant = true;
    variant = "danger";
  }
  const iconVariants = ["regular", "solid", "light", "thin", "sharp-solid", "duotone", "brands"];
  if (!iconVariants.includes(iconType)) {
    iconType = "regular";
  }
  return <>
      <div className={`callout my-4 px-5 py-4 overflow-hidden rounded-2xl flex gap-3 border ${asideComponents[variant].outerStyle}`} data-callout-type={asideComponents[variant].calloutType}>
        <div className="mt-0.5 w-4" data-component-part="callout-icon">
          {}
          {icon === "" ? asideComponents[variant].icon : <Icon icon={icon} iconType={iconType} size={14} />}
        </div>
        <div className={`text-sm prose min-w-0 w-full ${asideComponents[variant].innerStyle}`} data-component-part="callout-content">
          {gotInvalidVariant ? <p>
              <span className="font-bold">
                Invalid <code>type</code> passed!
              </span>
              <br />
              <span className="font-bold">Received: </span>
              {type}
              <br />
              <span className="font-bold">Expected one of: </span>
              {asideVariants.join(", ")}
            </p> : <>
              {title && <p className="font-bold">{title}</p>}
              {children}
            </>}
        </div>
      </div>
    </>;
};

export const Image = ({src, darkSrc, alt = '', darkAlt, href, target, height = 342, width = 608, noZoom = false, center = false}) => {
  const isSVG = src.match(/\.svg(?:[#?].*?)?$/i) !== null;
  const shouldInvert = isSVG && !darkSrc;
  const shouldCreateLink = href !== undefined;
  const minPx = 9;
  const maxPx = 608;
  const expectedPx = `a number or a string with a number that is greater than ${minPx - 1} and less than or equal to ${maxPx}`;
  const createInvalidPropCallout = (title, received, expected) => {
    return <Danger>
        <span className="font-bold">
          Invalid <code>{title.toString()}</code> passed!
        </span>
        <br />
        <span className="font-bold">Received: </span>
        {received.toString()}
        <br />
        <span className="font-bold">Expected: </span>
        {expected.toString()}
        {}
      </Danger>;
  };
  const checkValidDimensionValue = value => {
    switch (typeof value) {
      case "string":
      case "number":
        const num = Number(value);
        return Number.isSafeInteger(num) && num >= minPx && num <= maxPx;
      default:
        return false;
    }
  };
  let callouts = [];
  if (height && !checkValidDimensionValue(height)) {
    callouts.push(createInvalidPropCallout("height", height, expectedPx));
  }
  if (width && !checkValidDimensionValue(width)) {
    callouts.push(createInvalidPropCallout("width", width, expectedPx));
  }
  if (callouts.length !== 0) {
    return callouts;
  }
  const heightPx = Number(height);
  const widthPx = Number(width);
  const shouldCenter = center === "true" || center === true ? true : false;
  const shouldNotZoom = noZoom === "true" || noZoom === true ? true : false;
  const images = <>
      <img className="block dark:hidden" src={src} alt={alt} {...height && ({
    height: heightPx
  })} {...width && ({
    width: widthPx
  })} {...(shouldCreateLink || shouldInvert || shouldNotZoom) && ({
    noZoom: "true"
  })} />
      <img className={`hidden dark:block ${shouldInvert ? "invert" : ""}`} src={darkSrc ?? src} alt={darkAlt ?? alt} {...height && ({
    height: heightPx
  })} {...width && ({
    width: widthPx
  })} {...(shouldCreateLink || shouldInvert || shouldNotZoom) && ({
    noZoom: "true"
  })} />
    </>;
  if (shouldCreateLink) {
    if (shouldCenter) {
      return <div style={{
        display: "flex",
        justifyContent: "center"
      }}>
          <a href={href} target={target ?? "_self"}>
            {images}
          </a>
        </div>;
    }
    return <a href={href} target={target ?? "_self"}>
        {images}
      </a>;
  }
  if (shouldCenter) {
    return <div style={{
      display: "flex",
      justifyContent: "center"
    }}>{images}</div>;
  }
  return images;
};

This article describes the basic ideas and processes behind the implementation of Jettons (aka tokens in Ethereum) in the TON Blockchain.

## Related smart contracts

Standardized tokens on TON (see TEPs [0074](https://github.com/ton-blockchain/TEPs/blob/master/text/0074-jettons-standard.md)
and [0089](https://github.com/ton-blockchain/TEPs/blob/master/text/0089-jetton-wallet-discovery.md)) are implemented using a set of
smart contracts, including:

* [Jetton master](https://github.com/ton-blockchain/token-contract/blob/main/ft/jetton-minter.fc) (that is also called *Jetton minter*) smart contract;
* [Jetton wallet](https://github.com/ton-blockchain/token-contract/blob/main/ft/jetton-wallet.fc) smart contract.

It is important to keep in mind that Jetton standards provide only a general scheme of interaction, leaving the specific implementation of related contracts to developers.

### Jetton master

*Jetton master* smart contracts store general information about a particular jetton, such as total supply (the total number of tokens of this type),
a metadata link (or the metadata itself), and the code of the standard jetton-wallet smart contract for this jetton. They
also have an *owner (admin)* who, by sending suitable messages to them, [mints new tokens](/standard/tokens/jettons/mint), closes the minting, changes metadata, or transfers the
admin rights to another contract.

Jetton master contracts also receive notifications about the [burning of tokens](/standard/tokens/jettons/burn).
When they receive such a notification, they must adjust the total supply accordingly.

### Jetton wallet

*Jetton wallet* smart contracts are used to [transfer](/standard/tokens/jettons/transfer), receive, and [burn](/standard/tokens/jettons/burn) jettons. Each jetton wallet contract stores
the wallet balance information for a specific user (owner), the address of the Jetton master contract (for appropriate minting), and some additional information.
In certain cases, Jetton wallets are used for individual token holders for each token type.

### Difference between Jetton wallets and regular ones

Although both regular wallets and Jetton wallets are smart contracts, there are some significant differences between them.

The regular wallets' smart contracts are designed for off-chain interaction with their owner. In most implementations, their main purpose is to receive
external messages and perform the operations requested in them. It is through a regular
wallet that the user sends requests for the transfer of tokens or their burning to the Jetton wallet smart contract.
They are designed to store only the native TON Blockchain currency: Toncoin (or TON).

On the other hand, Jetton wallet smart contracts are designed only for storing and processing tokens. They ignore any external messages and
accept only special internal ones. They execute commands received only from the Jetton master, another Jetton wallet, or
their owner's regular wallet smart contracts.

## Message layouts

Interactions with Jetton contracts, which users and developers most often encounter, are:

* tokens transfer: sending tokens from one Jetton wallet to another;
* tokens minting: minting new tokens and transferring them to the Jetton wallet;
* tokens burning: burn a certain number of tokens on the Jetton wallet contract;
* wallet address providing: find the address of the Jetton wallet corresponding to a regular wallet.

<Aside type="caution">
  In all schemes below, you will see the `query id` field. Nowadays, the field is almost deprecated, and the protocol itself doesn't need it.
  It is mostly used for easier off-chain parsing and other web2 processing.
</Aside>

### Token transfer

<Image src="/resources/images/jettons/transfer_light.png" darkSrc="/resources/images/jettons/transfer_dark.png" alt="Jetton transfer" />

`Actor A regular wallet -> actor A Jetton wallet`. *Transfer* message contains the following data:

| Name                   | Type              | Description                                                                                                                                                            |
| ---------------------- | ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `query_id`             | uint64            | Links the three messaging types—transfer, transfer notification, and excesses—to each other. To ensure this process works correctly, **always use a unique query ID**. |
| `amount`               | VarUInteger 16    | The total jetton amount to transfer.                                                                                                                                   |
| `destination`          | MsgAddress        | The address of the actor B's regular wallet.                                                                                                                           |
| `response_destination` | MsgAddress        | The wallet address used to return remaining Toncoin through the excesses message.                                                                                      |
| `custom_payload`       | Maybe ^Cell       | The optional custom data used by either the sender or receiver jetton wallet for internal logic.                                                                       |
| `forward_ton_amount`   | VarUInteger 16    | Toncoin to forward to the recipient. Must `> 0` to send a transfer notification with `forward_payload` and must be less than the amount attached to this message.      |
| `forward_payload`      | Either Cell ^Cell | Optional data. If the first `32` bits equal `0x00000000`, it is a text comment.                                                                                        |

that meet the TL-B scheme specified in [TEP 0074](https://github.com/ton-blockchain/TEPs/blob/master/text/0074-jettons-standard.md):

```tlb theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
transfer#0f8a7ea5 query_id:uint64 amount:(VarUInteger 16) destination:MsgAddress
                 response_destination:MsgAddress custom_payload:(Maybe ^Cell)
                 forward_ton_amount:(VarUInteger 16) forward_payload:(Either Cell ^Cell)
                 = InternalMsgBody;
```

`Actor A Jetton wallet -> actor B Jetton wallet`. *Internal transfer* message contains the following data:

| Name                   | Type              | Description                                                                                                                                                            |
| ---------------------- | ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `query_id`             | uint64            | Links the three messaging types—transfer, transfer notification, and excesses—to each other. To ensure this process works correctly, **always use a unique query ID**. |
| `amount`               | VarUInteger 16    | The total jetton amount to transfer.                                                                                                                                   |
| `sender`               | MsgAddress        | The address of the actor A regular wallet.                                                                                                                             |
| `response_destination` | Maybe MsgAddress  | The optional wallet address used to return remaining Toncoin through the excesses message.                                                                             |
| `forward_ton_amount`   | VarUInteger 16    | Toncoin to forward to the recipient. Must `> 0` to send a transfer notification with `forward_payload` and must be less than the amount attached to this message.      |
| `forward_payload`      | Either Cell ^Cell | Optional data. If the first `32` bits equal `0x00000000`, it is a text comment.                                                                                        |

that is not specified, but has a recommended TL-B scheme in [TEP 0074](https://github.com/ton-blockchain/TEPs/blob/master/text/0074-jettons-standard.md):

```tlb theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
internal_transfer#178d4519  query_id:uint64 amount:(VarUInteger 16) from:MsgAddress
                     response_address:MsgAddress
                     forward_ton_amount:(VarUInteger 16)
                     forward_payload:(Either Cell ^Cell)
                     = InternalMsgBody;
```

`Actor B Jetton wallet → actor B regular wallet`. The transfer notification message. This is sent only if `forward_ton_amount` is not zero and contains the following data:

| Name              | Type              | Description                                                                                                                                                            |
| ----------------- | ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `query_id`        | uint64            | Links the three messaging types—transfer, transfer notification, and excesses—to each other. To ensure this process works correctly, **always use a unique query ID**. |
| `amount`          | VarUInteger 16    | The total jetton amount were transferred.                                                                                                                              |
| `sender`          | MsgAddress        | The address of the actor A regular wallet.                                                                                                                             |
| `forward_payload` | Either Cell ^Cell | Some data.                                                                                                                                                             |

that meet the TL-B scheme specified in [TEP 0074](https://github.com/ton-blockchain/TEPs/blob/master/text/0074-jettons-standard.md):

```tlb theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
transfer_notification#7362d09c query_id:uint64 amount:(VarUInteger 16)
           sender:MsgAddress forward_payload:(Either Cell ^Cell)
           = InternalMsgBody;
```

`Actor B Jetton wallet -> actor C smart contract`. Excess message body. This is sent only if there are remaining Toncoin after paying the fees. Contains the following data:

| Name       | Type   |
| ---------- | ------ |
| `query_id` | uint64 |

that meet the TL-B scheme specified in [TEP 0074](https://github.com/ton-blockchain/TEPs/blob/master/text/0074-jettons-standard.md):

```tlb theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
excesses#d53276db query_id:uint64 = InternalMsgBody;
```

### Token minting

<Image src="/resources/images/jettons/mint_light.png" darkSrc="/resources/images/jettons/mint_dark.png" alt="Jettons minting" />

`Admin regular wallet -> Jetton master contract`. *Mint* message contains the following data:

<Aside type="caution">
  The following data layout is just a possible example. The structure of the Mint message is not specified in any TEPs and is left to the choice of the developer.
</Aside>

| Name          | Type       | Description                                                                           |
| ------------- | ---------- | ------------------------------------------------------------------------------------- |
| `query_id`    | uint64     | To ensure this process works correctly, **always use a unique query ID**.             |
| `receiver`    | MsgAddress | The address of the actor A regular wallet.                                            |
| `mintMessage` | Cell       | The rest of the data as in an internal transfer message, except the `query_id` field. |

The rest of the messages have already been described above when analyzing the transfer process.

### Token burning

<Image src="/resources/images/jettons/burn_light.png" darkSrc="/resources/images/jettons/burn_dark.png" alt="Jettons burning" />

`Actor A regular wallet -> actor A Jetton wallet`. *Burn* message contains the following data:

| Name                   | Type           | Description                                                                       |
| ---------------------- | -------------- | --------------------------------------------------------------------------------- |
| `query_id`             | uint64         | To ensure this process works correctly, **always use a unique query ID**.         |
| `amount`               | VarUInteger 16 | The total jetton amount to burn.                                                  |
| `response_destination` | MsgAddress     | The wallet address used to return remaining Toncoin through the excesses message. |
| `custom_payload`       | Maybe ^Cell    | The optional custom data used by the receiver jetton wallet for internal logic.   |

that meet a TL-B scheme in [TEP 0074](https://github.com/ton-blockchain/TEPs/blob/master/text/0074-jettons-standard.md):

```tlb theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
burn#595f07bc query_id:uint64 amount:(VarUInteger 16)
       response_destination:MsgAddress custom_payload:(Maybe ^Cell)
       = InternalMsgBody;
```

`Actor A Jetton wallet -> Jetton master contract`. *Burn notification* message contains the following data:

| Name                   | Type           | Description                                                                       |
| ---------------------- | -------------- | --------------------------------------------------------------------------------- |
| `query_id`             | uint64         | To ensure this process works correctly, **always use a unique query ID**.         |
| `amount`               | VarUInteger 16 | The total jetton amount was burned.                                               |
| `sender`               | MsgAddress     | The address of the actor A regular wallet.                                        |
| `response_destination` | MsgAddress     | The wallet address used to return remaining Toncoin through the excesses message. |

that is not specified but has a recommended TL-B scheme in [TEP 0074](https://github.com/ton-blockchain/TEPs/blob/master/text/0074-jettons-standard.md):

```tlb theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
burn_notification#7bdd97de query_id:uint64 amount:(VarUInteger 16)
       sender:MsgAddress response_destination:MsgAddress
       = InternalMsgBody;
```

### Wallet address providing

This process is straightforward. Some actor sends to the Jetton master contract `provide_wallet_address` message that contains the following fields:

| Name              | Type       | Description                                                                |
| ----------------- | ---------- | -------------------------------------------------------------------------- |
| `query_id`        | uint64     | To ensure this process works correctly, **always use a unique query ID**.  |
| `owner_address`   | MsgAddress | The address of the actor for which the Jetton wallet address is needed.    |
| `include_address` | Bool       | Whether to include the address of the actor himself in the output message. |

Then, the Jetton master contract sends to the actor a message that contains the following fields:

| Name             | Type              | Description                                                               |
| ---------------- | ----------------- | ------------------------------------------------------------------------- |
| `query_id`       | uint64            | To ensure this process works correctly, **always use a unique query ID**. |
| `wallet_address` | MsgAddress        | The Jetton wallet contract address.                                       |
| `owner_address`  | Maybe ^MsgAddress | The address of the owner.                                                 |

These messages meet the corresponding TL-B schemes in [TEP 0089](https://github.com/ton-blockchain/TEPs/blob/master/text/0089-jetton-wallet-discovery.md):

```tlb theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
provide_wallet_address#2c76b973 query_id:uint64 owner_address:MsgAddress
include_address:Bool = InternalMsgBody;

take_wallet_address#d1735400 query_id:uint64 wallet_address:MsgAddress
owner_address:(Maybe ^MsgAddress) = InternalMsgBody;
```

## Interaction from UI

There are three actions that can be performed through the UI:

* [getting wallet balance](/standard/tokens/jettons/wallet-data);
* [transfer jettons](/standard/tokens/jettons/transfer);
* indexing available jettons.

### Applications

The most popular user wallet applications, such as [TonKeeper](https://tonkeeper.com/), use their own SQL-like database. When the user receives a new jetton for the first time,
the application processes the `transfer_notification` message. Next, information about the number of jettons received is taken from it, and it is
checked if there is information about this jetton in the applications database. If there is, information is added to the database stating that the user has a
new type of jetton in the amount received. If not, the database starts indexing this new jetton, and after the validation process begins to show data
about it to users. This is how all the jettons that a given user has and their amounts are listed.

For a user to transfer a given amount of a token to another user, they only need to fill in the `destination` and `amount`
fields through the application. Next, it will automatically generate a transfer message and send it to the Jetton wallet associated with the user.

### Web services

Various web services, such as [Tonviewer](https://tonviewer.com/), can also be used to obtain information about the types of user jettons and their amounts.
Unlike wallet applications, they also have the ability to directly invoke the get methods of related smart contracts.
However, they are not designed to generate and send messages.