# Operations (buy/sell/withdraw crypto)

### Available operations

* [Buying process](/mobilesdk-en/operations.md#buying-crypto)
  * [Getting token for buying](/mobilesdk-en/operations.md#getting-token-for-buying)
  * [Buying](/mobilesdk-en/operations.md#buying)
  * [Confirmation of operation](/mobilesdk-en/operations.md#confirmation-of-operation)
  * [Getting rate for buying](/mobilesdk-en/operations.md#getting-rate-for-buying)
* [Selling process](/mobilesdk-en/operations.md#selling-process)
  * [Getting token for selling](/mobilesdk-en/operations.md#getting-token-for-selling)
  * [Selling](/mobilesdk-en/operations.md#selling)
  * [Getting rate for buying](/mobilesdk-en/operations.md#getting-exchange-rate-for-selling)
* [Withdrawal to another wallet](/mobilesdk-en/operations.md#withdrawal-to-another-wallet)
  * [Currency converter](/mobilesdk-en/operations.md#currency-converter)
  * [Withdrawal fees](/mobilesdk-en/operations.md#withdrawal-fees)
  * [Make a withdrawal](/mobilesdk-en/operations.md#make-a-withdrawal)
  * [Withdrawal confirmation](/mobilesdk-en/operations.md#withdrawal-confirmation)

## Buying crypto

`Buy` object needs to be obtained first to start the process of buying:

{% tabs %}
{% tab title="Kotlin" %}

```kotlin
val mercuryo: Mercuryo = Mercuryo.create(...)  
val buy: Buy = mercuryo.operations.buy
```

{% endtab %}

{% tab title="Swift" %}

```swift
var mercuryoSDK: IMercuryo = IMercuryo(isDebug: true, baseHost: "HOST_HERE")
var wallet = mercuryoSDK.operations.buy
```

{% endtab %}
{% endtabs %}

### Getting token for buying

Before buying, you need to get a unique token designated to this specific operation, for this you can use the `.convert` method:

{% tabs %}
{% tab title="Kotlin" %}

```kotlin
buy.convert(fromCurrency: String, toCurrency: String, amount: String) : ConverterResult
```

{% endtab %}

{% tab title="Swift" %}

```swift
var token: String?

buy.convert(fromCurrency: "BTC", toCurrency: "EUR", amount: "1") { converterResult, error in 
    token = converterResult?.token
    //do some magic here
}
```

{% endtab %}
{% endtabs %}

### Buying

After you obtained a [buying token](/mobilesdk-en/operations.md#getting-token-for-buying) you can call buy method passing parameters of operation.

{% tabs %}
{% tab title="Kotlin" %}

```kotlin
buy.commit(cardId: String, cvv: String, buyToken: String, redirectUrl: String): TransactionStatus
```

{% endtab %}

{% tab title="Swift" %}

```swift
var transactionID: String?

buy.commit(cardId: "CARD_ID HERE", cvv: "CARD_CVV HERE", buyToken: token, redirectUrl: "REDIRECT_URL HERE") { transactionStatus, error in 
    transactionID = transactionStatus?.id
    //do some magic here
}
```

{% endtab %}
{% endtabs %}

| Parameter   | Description                                                                                                                                                             |
| ----------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| cardId      | ID of card in Mercuryo                                                                                                                                                  |
| cvv         | CVV code of card                                                                                                                                                        |
| buyToken    | Buying token [`buy.convert(...)`](/mobilesdk-en/operations.md#getting-token-for-buying)                                                                                 |
| redirectUrl | URL where user will be redirected after operation. Example: [http://my.mercuryo.io/orders?invoice={invoice\_id}](http://my.mercuryo.io/orders?invoice=%7Binvoice_id%7D) |

### Confirmation of operation

To finalize an operation user may need to confirm ownership of bank account by providing a descriptor sent as a part of transaction.

{% tabs %}
{% tab title="Kotlin" %}

```
buy.verifyDescriptor(transactionId: String, code: String): TransactionStatus
```

{% endtab %}

{% tab title="Swift" %}

```swift
buy.verifyDescriptor(transactionId: transactionID, code: "TRANSACTION_CODE HERE") { transactionStatus, error in 
    //do some magic here
}
```

{% endtab %}
{% endtabs %}

| Parameter     | Description                                                                                                |
| ------------- | ---------------------------------------------------------------------------------------------------------- |
| transactionId | ID of transaction obtained after [`buy.commit(...)`](/mobilesdk-en/operations.md#getting-token-for-buying) |
| code          | Descriptor code                                                                                            |

### Getting rate for buying

User may want to know the rate of fiat-crypto conversion which may be obtained using the following method:

{% tabs %}
{% tab title="Kotlin" %}

```kotlin
buy.rate(fromCurrency: String, toCurrency: String): Rate
```

{% endtab %}

{% tab title="Swift" %}

```swift
buy.getRate(fromCurrency: "BTC", toCurrency: "EUR") { rate, error in 
    //do soma magic here
}
```

{% endtab %}
{% endtabs %}

## Selling process

`Sell` object needs to be obtained first to start the process of buying:

{% tabs %}
{% tab title="Kotlin" %}

```kotlin
val mercuryo: Mercuryo = Mercuryo.create(...)  
val sell: Sell = mercuryo.operations.sell
```

{% endtab %}

{% tab title="Swift" %}

```swift
var mercuryoSDK: IMercuryo = IMercuryo(isDebug: true, baseHost: "HOST_HERE")
var wallet = mercuryoSDK.operations.sell
```

{% endtab %}
{% endtabs %}

### Getting token for selling

Before selling, you need to get a unique token designated to this specific operation, for this you can use the `.convert` method:

{% tabs %}
{% tab title="Kotlin" %}

```kotlin
sell.convert(fromCurrency: String, toCurrency: String, amount: String) : ConverterResult
```

{% endtab %}

{% tab title="Swift" %}

```swift
var token: String?

sell.convert(fromCurrency: "BTC", toCurrency: "EUR", amount: "1") { converterResult, error in 
    token = converterResult?.token
    //do some magic here
}
```

{% endtab %}
{% endtabs %}

### Selling

To sell you need to [get token for selling](/mobilesdk-en/operations.md#getting-token-for-selling) first call method as shown below.

{% tabs %}
{% tab title="Kotlin" %}

```kotlin
sell.commit(cardId: String, sellToken: String): TransactionStatus
```

{% endtab %}

{% tab title="Swift" %}

```swift
sell.commit(cardId: "CARD_ID HERE", sellToken: token) { transactionStatus, error in 
    //do some magic here
}
```

{% endtab %}
{% endtabs %}

| Parameter | Description                                                                                      |
| --------- | ------------------------------------------------------------------------------------------------ |
| cardId    | ID of card in Mercuryo                                                                           |
| sellToken | Token obtained from [`sell.convert(...)`](/mobilesdk-en/operations.md#getting-token-for-selling) |

### Getting exchange rate for selling

Rate includes a fee.

{% tabs %}
{% tab title="Kotlin" %}

```kotlin
sell.rate(fromCurrency: String, toCurrency: String): Rate
```

{% endtab %}

{% tab title="Swift" %}

```swift
sell.getRate(fromCurrency: "BTC", toCurrency: "EUR") { rate, error in 
    //do soma magic here
}
```

{% endtab %}
{% endtabs %}

## Withdrawal to another wallet

`Withdraw` object needs to be obtained first to start the process of buying:

{% tabs %}
{% tab title="Kotlin" %}

```kotlin
val mercuryo: Mercuryo = Mercuryo.create(...)  
val withdraw: Withdraw = mercuryo.operations.withdraw
```

{% endtab %}

{% tab title="Swift" %}

```swift
var mercuryoSDK: IMercuryo = IMercuryo(isDebug: true, baseHost: "HOST_HERE")
var wallet = mercuryoSDK.operations.buy
```

{% endtab %}
{% endtabs %}

### Currency converter

Before sending crypto it may be beneficial for user to know how amount converts to fiat or vice versa. Mercuryo SDK provides a method for that allowing to understand transaction better.

{% tabs %}
{% tab title="Kotlin" %}

```kotlin
withdraw.convert(fromCurrency: String, toCurrency: String, amount: String) : ConverterResult
```

{% endtab %}

{% tab title="Swift" %}

```swift
var token: String?

withdraw.convert(fromCurrency: "BTC", toCurrency: "EUR", amount: "1") { converterResult, error in 
    token = converterResult?.token
    //do some magic here
}
```

{% endtab %}
{% endtabs %}

### Withdrawal fees

To make withdrawal you need to obtain available blockchain fees first. In case there are no fees this method will throw an `CurrencyNotSupportFeeException` exception.

{% tabs %}
{% tab title="Kotlin" %}

```kotlin
withdraw.getEstimateFee(currency: String, fiatCurrency: String, address: String, amount: String): EstimateWithdrawFee
```

{% endtab %}

{% tab title="Swift" %}

```swift
var firstEstimateId: String?
withdraw.getEstimateFee(currency: "BTC", fiatCurrency: "EUR", address: "ADDRESS HERE", amount: "1") { fee, error in 
    firstEstimateId = fee?.fees.first?.id
    //do soma magic here
}
```

{% endtab %}
{% endtabs %}

### Make a withdrawal

{% tabs %}
{% tab title="Kotlin" %}

```kotlin
withdraw.commit(currency: String, address: String, amount: String, estimateId: String?): VerifyMetaData
```

{% endtab %}

{% tab title="Swift" %}

```swift
var nextStep: VerifyMetaData.NextStep?
var key: String?

withdraw.commit(currency: "BTC", address: "ADDRESS HERE", amount: "1", estimateId: firstEstimateId) { verifyData, error in 
    nextStep = verifyData?.step
    key = verifyData?.key
    //do some magic here
}
```

{% endtab %}
{% endtabs %}

| Fields     | Description                                                                                                                             |
| ---------- | --------------------------------------------------------------------------------------------------------------------------------------- |
| currency   | Crypto                                                                                                                                  |
| address    | Wallet address                                                                                                                          |
| amount     | Amount of withdrawal in crypto                                                                                                          |
| estimateId | ID of estimation fee obtained on the previous step, see method [`withdraw.getEstimateFee`](/mobilesdk-en/operations.md#withdrawal-fees) |

### Withdrawal confirmation

User may need to confirm withdrawal using text message or email code.

{% tabs %}
{% tab title="Kotlin" %}

```kotlin
withdraw.verify(next: VerifyMetaData.NextStep, key: String, code: String): TransactionStatus
```

{% endtab %}

{% tab title="Swift" %}

```swift
withdraw.verify(next: nextStep, key: key, code: "SMS/EMAIL CODE") { transactionStatus, error in 
    //do some magic here
}
```

{% endtab %}
{% endtabs %}


---

# 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://mercuryo.gitbook.io/mobilesdk-en/operations.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.