# Cronos POS

Source: https://developers.bitgo.com/docs/cronos

## Overview

CRONOS is the native asset of the Cronos POS blockchain. It utilizes:

- Account model
- EcDSA signature algorithm

Cronos POS is a Cosmos SDK–based Layer 1 using Tendermint BFT consensus with Proof-of-Stake (PoS). Validators finalize blocks, ensuring high throughput and instant finality. The network natively supports IBC for cross-chain communication.

## Explorer
<a href="https://cronos-pos.org/explorer/" target="_blank" rel="noreferrer">https://cronos-pos.org/explorer/</a>

## Wallets Types

BitGo enables holding Cronos POS in the following wallet types:

|                  | Multisig Cold | Multisig Hot | MPC Cold | MPC Hot |
|------------------|---------------|--------------|----------|---------|
| **Custodial**    | ❌             | ❌            | ✅        | ❌       |
| **Self Managed** | ❌             | ❌            | ✅        | ✅       |

## Ticker Symbols

| Mainnet    | Testnet         |
|------------|-----------------|
| cronos     | tcronos         |

## Faucet

Testnet tcronos coins can be requested from the <a href="https://cronos-pos.org/faucet" target="_blank" rel="noreferrer">Cronos POS faucet</a>.

## Units

CRO is divisible by 10<sup>-8</sup> and the base unit is a basecro:

- 1 cro = 100,000,000 basecro
- 1 basecro = 0.00000001 cro

Cronos POS balances can be in either integer or string format. However, BitGo recommends using string format to ensure values don't exceed the programmable number limit.

## Tokens

The Cronos POS blockchain doesn't natively support tokens.

## Fees

CRO has the following fees:

- Minimum fee = 0.0003 CRO
- Default fee rate = 0.0003 CRO

## Address Format

Cronos addresses follow the format: `cro1<38-character-bech32-body>`. All addresses are exactly 42 characters in length and begin with the fixed prefix `cro1`. This format adheres to the following regular expression:
```regex
/^(cro)1(['qpzry9x8gf2tvdw0s3jn54khce6mua7l]{38})$/
```

### Memo ID Support

- Optionally, a `?memoId=<n>` query parameter can be appended to the address for use cases such as identifying transaction metadata. Here, `<n>` can be any integer.
- Using `memoId`-based addressing eliminates the need to generate multiple deposit addresses per user. A single static address can be reused safely across users and use cases, with the `memoId` serving as the unique identifier.
- Since Cronos uses `memoId`-based receive addresses, manual consolidation is not required.


## Create Wallet

```shell cURL
    export BITGO_EXPRESS_HOST="<YOUR_LOCALHOST>"
    export COIN="tcronos"
    export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"
      export LABEL="<DESIRED_WALLET_NAME>"
        export PASSPHRASE="<YOUR_BITGO_LOGIN_PASSPHRASE>"
          export ENTERPRISE_ID="<YOUR_ENTERPRISE_ID>"

            curl -X POST \
            http://$BITGO_EXPRESS_HOST/api/v2/$COIN/wallet/generate \
            -H 'Content-Type: application/json' \
            -H "Authorization: Bearer $ACCESS_TOKEN" \
            -d '{
              "label": "'"$LABEL"'",
              "passphrase": "'"$PASSPHRASE"'",
              "enterprise": "'"$ENTERPRISE_ID"'",
              "disableTransactionNotifications": true,
              "disableKRSEmail": true
            }'
```
```js JavaScript
    const { BitGo } = require('bitgo');

    const accessToken = '<YOUR_ACCESS_TOKEN>';

    // Initialize the SDK
    const bitgo = new BitGo({
      accessToken: accessToken,
      env: 'test',
    });

    // Generate hot wallet
    async function createHotWalletSimple() {
      const newWallet = await bitgo.coin('tcronos').wallets().generateWallet({
      label: '<DESIRED_WALLET_NAME>',
      passphrase: '<YOUR_BITGO_LOGIN_PASSWORD>',
    });

      console.log(JSON.stringify(newWallet, undefined, 2));
    }
```

## Create Address

```shell cURL
    export COIN="tcronos"
    export WALLET_ID="<YOUR_WALLET_ID>"
    export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"

      curl -X POST \
      https://app.bitgo-test.com/api/v2/$COIN/wallet/$WALLET_ID/address \
      -H 'Content-Type: application/json' \
      -H "Authorization: Bearer $ACCESS_TOKEN"
```
```js JavaScript
    const { BitGo } = require('bitgo');
    const accessToken = '<YOUR_ACCESS_TOKEN>';

    // Initialize the SDK
    const bitgo = new BitGo({
      accessToken: accessToken,
      env: 'custom',
      customRootURI: 'https://app.bitgo.com',
    });

    // Create address
    const wallet = await bitgo.coin('tcronos').wallets().generateWallet({
      label: '<DESIRED_WALLET_NAME>',
      passphrase: '<YOUR_BITGO_LOGIN_PASSPHRASE>',
    });

    const address = await wallet.createAddress(
    );

    // Print address details
    console.log(JSON.stringify(address, undefined, 2));
```

## Estimate Fee

```shell cURL
    export COIN="tcronos"
    export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"

    curl -X GET \
    https://app.bitgo-test.com/api/v2/$COIN/tx/fee \
    -H 'Content-Type: application/json' \
    -H "Authorization: Bearer $ACCESS_TOKEN"
```
```js JavaScript
    const BitGoJS = require('../../../src/index.js');
    const bitgo = new BitGoJS.BitGo({ env: 'test' });
    const accessToken = '<YOUR_ACCESS_TOKEN>';
    const coin = 'tcronos';
    async function getFeeEstimate() {
      try {
        await bitgo.authenticateWithAccessToken({ accessToken });
        const res = await bitgo.coin(coin).feeEstimate({ numBlocks: 2 });
        console.dir(res);
      } catch (err) {
        console.error('Error fetching fee estimate:', err);
      }
    }
    getFeeEstimate();
```

## Transact

```shell cURL
    export BITGO_EXPRESS_HOST="<YOUR_LOCALHOST>"
    export COIN="tcronos"
    export WALLET_ID="<YOUR_WALLET_ID>"
      export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"
        export ADDRESS="<DESTINATION_ADDRESS>"
          export AMOUNT="<AMOUNT_IN_BASE_UNITS>"
            export WALLET_PASSPHRASE="<YOUR_WALLET_PASSPHRASE>"

              curl -X POST \
              http://$BITGO_EXPRESS_HOST/api/v2/$COIN/wallet/$WALLET_ID/sendcoins \
              -H 'Content-Type: application/json' \
              -H "Authorization: Bearer $ACCESS_TOKEN" \
              -d '{
                "address": "'"$ADDRESS"'",
                "amount": "'"$AMOUNT"'",
                "walletPassphrase": "'"$WALLET_PASSPHRASE"'"
              }'
```
```shell cURL (send to many)
    export BITGO_EXPRESS_HOST="<YOUR_LOCALHOST>"
    export COIN="tcronos"
    export WALLET_ID="<YOUR_WALLET_ID>"
      export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"
        export ADDRESS_1="<DESTINATION_ADDRESS_1>"
          export ADDRESS_2="<DESTINATION_ADDRESS_2>"
            export AMOUNT_1="<AMOUNT_1_IN_BASE_UNITS>"
              export AMOUNT_2="<AMOUNT_2_IN_BASE_UNITS>"
                export WALLET_PASSPHRASE="<YOUR_WALLET_PASSPHRASE>"

                  curl -X POST \
                  http://$BITGO_EXPRESS_HOST/api/v2/$COIN/wallet/$WALLET_ID/sendmany \
                  -H 'Content-Type: application/json' \
                  -H "Authorization: Bearer $ACCESS_TOKEN" \
                  -d '{
                    "recipients": [
                  {
                    "address": "'"$ADDRESS_1"'",
                    "amount": "'"$AMOUNT_1"'"
                  },
                  {
                    "address": "'"$ADDRESS_2"'",
                    "amount": "'"$AMOUNT_2"'"
                  }
                    ],
                    "walletPassphrase": "'"$WALLET_PASSPHRASE"'"
                  }'
```
```js JavaScript
    const tx = await fundedWallet.send({
    address: `<DESTINATION_ADDRESS>`,
    amount: `<AMOUNT>`,
    walletPassphrase: process.env.PASSWORD as string,
  });
```
```js JavaScript (send to many)
    let params = {
    recipients: [
  {
    amount: "<AMOUNT_1>",
    address: "<DESTINATION_ADDRESS_1>",
  },
  {
    amount: "<AMOUNT_2>",
    address: "<DESTINATION_ADDRESS_2>",
  },
    ],
    walletPassphrase: "<YOUR_WALLET_PASSPHRASE>",
  };
    wallet.sendMany(params).then(function (transaction) {
    // Print transaction details
    console.dir(transaction);
  });
```