npm package: @overgold/light-client
Description: ## Установка переменных
Author: overgold
Latest version: 0.0.19

# light client

## Установка переменных

```TS

MAIN_SERVER_ENDPOINT=https://api.chain.overgold.app/
MAIN_WALLET_ENDPOINT=https://overgold.app

BASE_BIP44_PATH="m/44'/118'/0'/0"
BLOCKCHAIN_URL=https://rpc.chain.overgold.app
BECH32_PREFIX=ovg
ASSET=ovg

```

## Установка

```SH
npm install --save @overgold/light-client

```

```SH
yarn add @overgold/light-client

```

## Использование

```TS
import * as lightClient from '@overgold/light-client';

```

### Получить сессию из мнемоники

```TS
type Session = (mnemonic:string) => Promise<{
    data: null;
    error: {
        status: number;
        message: string;
        statusText?: undefined;
    };
} | {
    data: ISession;
    error: null;
} | {
    data: null;
    error: {
        status: number;
        statusText: string;
        message?: undefined;
    };
}>;

interface ISession {
    BECH32_PREFIX: string;
    BLOCKCHAIN_URL: string;
    ASSET: string;
    mnemonic: string;
    signer: AccountData;
    account: DirectSecp256k1HdWallet;
    signingClient: SigningStargateClient;
    message: IBuiltinMessagesFactory;
    getKeyPair: (index?: number) => ECPairInterface;
    getAddress: (index?: number) => string;
    toKeyStoreObject: (password: string) => object;
    toKeyStoreString: (password: string) => string;
}

  const session:Session = await lightClient.getSessionFromMnemonic(mnemonic);
```

### Получить адрес из мнемоники

```TS
  type Address = (mnemonic:string) => Promise<{
    data: null;
    error: {
        status: number;
        message: string;
    };
} | {
    data: {address:string};
    error: null;
}>

  const address:Address = await lightClient.getAccountAddressFromMnemonic(mnemonic);
```

### Получить балансы по адресу

```TS
type Balance = (address:string) => Promise<BalanceResponse>

interface BalanceResponse {
  ovg: {
    amount: number;
  };
  stovg: {
    amount: number;
    stakeAmount: number;
    sellAmount: number;
  };
}

  const balance:Balance = await lightClient.getAccountAllBalance(address);
```

### Валидация адреса

```TS
  type AddressIsValid = (address:string) => boolean

  const accountAddressIsValid:AddressIsValid = lightClient.accountAddressIsValid(address);
```

### Валидация мнемоники

```TS
  type MnemonicIsValid = (mnemonic:string) => boolean

  const mnemonicIsValid:MnemonicIsValid = lightClient.mnemonicIsValid(mnemonic);
```

### Получить транзакцию из блокчейн по хешу

```TS
  type TransactionByHash = (txHash:string) =>Promise<any>

  const getTransactionByHash:TransactionByHash = lightClient.getTransactionByHash(txHash);
```

### Получить курс OVG в указанной валюте

```TS
 interface BalanceResponse {
  price: string;
  date: string;
  currency: string;
}

export type Price = (
  currency?: string,//default 'eur'
) =>Promise<{
    data: null;
    error: {
        status: number;
        message: string;
    };
} | {
    data: {
        gas: BalanceResponse;
        hash: string | null;
    };
    error: null;
}>;

  const getPrice:Price =await lightClient.getPrice(currency);
```

### Запрос информации по ордеру (cardio-to-stake)

```TS

export type Info = (hash: string) => Promise<{
    data: {
      id:number;
      tx_hash:string;
      amount_stake:number;
      amount_eur:number;
      account_address:string;
      status:string;
      email:string;
    };
    error: null;
} | {
    data: null;
    error: {
        status: number;
        statusText: string;
    };
}>;

  const getOrderInfo:Info =await lightClient.getOrderInfo(hash);
```

### Создаем заявку на обмен (cardio-to-stake)

```TS
 interface ConfirmRequest {
  hash: string;
  email: string;
  address: string;
}

export type Confirm = (payload: ConfirmRequest) => Promise<{
    data: {
      tx_hash:string;
    };
    error: null;
} | {
    data: null;
    error: {
        status: number;
        statusText: string;
    };
}>;

  const confirmStakeToCardio:Confirm =await lightClient.confirmStakeToCardio(payload);
```

### Подписать и отправить трансфер по отправке ovg

```TS

interface MakeTransactionSendProps {
  mnemonic: string;
  toAddress: string;
  amount: string;
  denom?: string; //default 'ovg'
  memo?: string; //default ''
  isSimulate?: boolean; //default false
}

type SendOVG = (payload : MakeTransactionSendProps) => Promise<{
    data: null;
    error: {
        status: number;
        message: string;
    };
} | {
    data: {
        gas: number;
        hash: string | null;
    };
    error: null;
}>

const sendOVG:SendOVG = await lightClient.makeTransactionSendOVG({
    mnemonic,
    toAddress,
    amount,
    });
```

### Подписать трансфер по отправке stovg (user-to-stake). Пользователь может отправить только свободный стейк (тот что стоит на выкупе - не может).

```TS
interface MakeTransactionFromUserProps {
  mnemonic: string;
  amount: string;
  memo?: string; //default ''
  isSimulate?: boolean; //default false
}

type SendStOVG = (payload : MakeTransactionFromUserProps) => Promise<{
    data: null;
    error: {
        status: number;
        message: string;
        statusText?: undefined;
    };
} | {
    data: null;
    error: {
        status: number;
        statusText: string;
        message?: undefined;
    };
} | {
    data: {
        gas: number;
        hash: string | null;
    };
    error: null;
}>

  const sendStOVG:SendStOVG = await lightClient.makeTransactionFromUser({
    mnemonic,
    amount,
  })
```