Acala Stablecoin
To interact with Acala or Karura from Javascript you can use
@polkadot/api
along with @acala-network/api
. You can learn more about @polkadot/api
[here]. (https://polkadot.js.org/docs/api).These functions only read information from the chain, and thus don't require signing transactions with a private key. Read more about state queries here: State queries docs
Returns amount of
collateral
and amount of minted stablecoin as debit
for specific collateral type and account.Note⚠debit
reflects the only amount of minted kUSD. The amount of debt is higher as it includes accumulated interest. To calculate the total amount to payback you need to usedebitExchangeRate
parameter (the example for fetchingdebitExchangeRate
is shown below).
positions(currencyId: CurrencyId, accountId: AccountId):
Promise<{collateral: number, debit: number}>
Arguments
Name | Type | Text |
---|---|---|
currencyId | CurrencyId | collateral currency Id |
accountId | AccountId | account to fetch vaults for, can be passed as string |
Example:
const result = await api.query.loans.positions(
{ TOKEN: "KSM" },
"<ACCOUNT>"
);
console.log(result.toHuman());
Returns total amount of
collateral
and amount of borrowed stablecoin as debit
for specific collateral type.totalPositions(currencyId: CurrencyId):
Promise<{collateral: number, debit: number}>
Arguments
Name | Type | Text |
---|---|---|
currencyId | CurrencyId | identificator for currency used as collateral |
Example:
const result = await api.query.loans.totalPositions(
{ TOKEN: "KSM" }
);
console.log(result.toHuman());
Each accepted by Karura Collateral Type can have different risk parameters. These values are controlled by Karura Governance.
collateralParams(currencyId: CurrencyId):
Promise<{
maximumTotalDebitValue: number,
interestRatePerSec: number,
liquidationRatio: number,
liquidationPenalty: number,
requiredCollateralRatio: number,
}>
Arguments
Name | Type | Text |
---|---|---|
currencyId | CurrencyId | identificator for currency used as collateral |
Return values
Name | Type | Text |
---|---|---|
maximumTotalDebitValue | Number | maximum amount of KUSD that can be borrowed for one vault |
interestRatePerSec | Percent | the percentage of borrowed kUSD to be paid each next block. This amount should be added to globalInterestRatePerSec to calculate the debt |
liquidationRatio | Percent | collateral ratio (collateral value / debt value) reaching which the vault gets liquidated |
liquidationPenalty | Percent | penalty that is charged from the vault if the vault gets liquidated |
requiredCollateralRatio | Percent | Minimum collateral ratio till which user can borrow kUSD |
Example:
const result = await api.query.cdpEngine.collateralParams({
TOKEN: "KSM"
});
console.log(result.toHuman());
This parameter is used to calculate the debt. The amount of minted kUSD should be multiplied by this parameter. As the Interest rate is accumulated depends on block number, it makes sense to fetch this parameter for a certain block.
debitExchangeRate(currencyId: CurrencyId):
Promise<number}>
Arguments
Name | Type | Text |
---|---|---|
currencyId | CurrencyId | identificator for currency used as collateral |
Example:
const result = await api.query.cdpEngine.debitExchangeRate.at(
'<BLOCK_HASH'
{ TOKEN: "KSM" }
);
console.log(result.toHuman());
These transactions write data on-chain and require a private key to sign the transaction. To perform run test code snippets ensure that you have
SEED_PHRASE
environment variable defined in your .env
file.All operations: creating a vault, adding/removing collateral, borrowing, paying back kUSD can be done using a single method:
honzon.adjustLoan
adjustLoan(currency_id: CurrencyId, collateral_adjustment: Number, debit_adjustment: Number): Extrinsic
Arguments
Name | Type | Text |
---|---|---|
currencyId | CurrencyId | collateral CurrencyId |
collateral_adjustment | Signed Amount | positive means to deposit collateral currency into Vault, negative means withdraw collateral currency from the Vault |
debit_adjustment | Signed Amount | positive means to mint some amount of stablecoin to the caller; negative means that caller will pay back stablecoin to the Vault |
Example
const currencyId = { TOKEN: "KSM" };
const collateralAdjustment = <DESIRED_ADJUSTMENT>;
const debitAdjustment = <DESIRED_ADJUSTMENT>;
const extrinsic = api.tx.honzon.adjustLoan(
currencyId,
collateralAdjustment,
debitAdjustment
);
const hash = await extrinsic.signAndSend(signer);
console.log('hash', hash.toHuman());
Notethe supply amount should be denormalised with KAR decimals for this example⚠
Sets permission to transfer caller's loan to another Account (
to
).authorize(curencyId: CurrencyId, to: AccountId): Extrinsic
Returns
Extrinsic
type that should be signed with a private key.Arguments
Name | Type | Text |
---|---|---|
currencyId | CurrencyId | collateral CurrencyId |
to | AccountId | sets permission to transfer loan for this accountId |
Example:
const accountId = "<ACCOUNT_ID>";
const extrinsic = api.tx.honzon.authorize(
{ TOKEN: "KSM" },
accountId
);
const hash = await extrinsic.signAndSend(signer);
console.log("hash", hash.toHuman());
Removes permission to transfer caller's loan to another Account (
to
). This method can be used to decline previously given permission.unauthorize(curencyId: CurrencyId, to: AccountId): Extrinsic
Returns
Extrinsic
type that should be signed with a private key.Arguments
Name | Type | Text |
---|---|---|
currencyId | CurrencyId | collateral CurrencyId |
to | AccountId | removes permission to transfer loan for this accountId |
Example:
const accountId = "<ACCOUNT_ID>";
const extrinsic = api.tx.honzon.unauthorize(
{ TOKEN: "KSM" },
accountId
);
const hash = await extrinsic.signAndSend(signer);
console.log("hash", hash.toHuman());
Removes permission to transfer caller's vault to ALL accounts for all Collateral types. This method can be used to decline previously given permission.
unauthorizeAll(): Extrinsic
Returns
Extrinsic
type that should be signed with a private key.Example:
const extrinsic = api.tx.honzon.unauthorizeAll();
const hash = await extrinsic.signAndSend(signer);
console.log("hash", hash.toHuman());
Transfers Vault to the caller's account if it has permissions (if
authorize
was called previously by from
account).transferLoanFrom(currency_id, from): Extrinsic
Returns
Extrinsic
type that should be signed with a private key.Arguments
Name | Type | Text |
---|---|---|
currencyId | CurrencyId | collateral CurrencyId |
from | AccountId | transfers collateral from this account to the caller |
Example:
const fromAccountId = "<ACCOUNT_ID>";
const extrinsic = api.tx.honzon.transferLoanFrom(
{ TOKEN: "KSM" },
fromAccountId
);
const hash = await extrinsic.signAndSend(signer);
console.log("hash", hash.toHuman());
This action can be done with
adjustLoan
, but there is a shortcut created for this purpose which is applied only to safe vaults (where the collateral ratio is above liquidation level) and where the debt amount is positive.This method closes the caller's Vault by selling a sufficient amount of collateral on Karura Dex.
closeLoanHasDebitByDex(
currency_id: CurrencyId,
max_collateral_amount: number,
maybe_path?: CurrencyId[]
): Extrinsic
Returns
Extrinsic
type that should be signed with a private key.Arguments
Name | Type | Text |
---|---|---|
currencyId | CurrencyId | collateral CurrencyId |
max_collateral_amount | number | the maximum collateral that's allowed to be swapped in DeX to pay back the Vault |
maybe_path | CurrencyId[] | swap path that can be used for swapping collateral for kUSD in DeX |
Example:
const extrinsic = api.tx.honzon.closeLoanHasDebitByDex(
{ TOKEN: "KSM" },
// large number, allows swapping almost any amount
1 * 10 ** 30,
[{ TOKEN: "KSM" }, { TOKEN: "KUSD" }]
);
const hash = await extrinsic.signAndSend(signer);
console.log("hash", hash.toHuman());
Last modified 1yr ago