Lending Function

Mint

---

Supplying asset to lending pool and enable user to interest earning from supplied liquidity.

public fun mint<T>(
    version: &Version,
    market: &mut Market,
    coin: Coin<T>,
    clock: &Clock,
    ctx: &mut TxContext,
  ): Coin<MarketCoin<T>> { }

Parameters

Name	Type	Description
version	Version	The version control object, contract version must match with this
market	Market	The Scallop market object, it contains base assets, and related protocol configs
coin	Coin	The base asset to be supplied to the market
clock	Clock	The SUI system Clock object

Return Values

Name	Type	Description
MarketCoin	Coin	The yield bearing coin also an coin that proof user has supplied asset on Scallop.

💡 Note: If the yield-bearing coin is transferred to another address, it means that you have moved your supplied asset to that address, and the current address can no longer withdraw the assets. Only the receiving address can withdraw the assets.

Events

• MintEvent is emited when ****the supply tx success

Errors

• 73729: Currently market not active.

• 81922: Asset supply already reach limit cap.

Example:

Move

module protocol::foo {

  use sui::clock::{Self, Clock};
  use sui::tx_context::{Self ,TxContext};
  use sui::coin::{Self, Coin};

  use scallop_protocol::mint::mint;
  use scallop_protocol::Market as ScallopMarket;
  use scallop_protocol::Version as ScallopVersion;

  public fun doFoo<T>(
    scallop_version: &ScallopVersion,
    scallop_market: &mut ScallopMarket,
    coin: Coin<T>,
    clock: &Clock,
    ctx: &mut TxContext
  ): Coin<MarketCoin<T>> {
     scallop_protocol::mint::mint<T>(
	scallop_version,
	scallop_market,
	coin,
	clock,
	ctx,
      )
  }
}

Typescript

import { getFullnodeUrl, SuiClient, } from '@mysten/sui.js/client';
import { SUI_CLOCK_OBJECT_ID } from '@mysten/sui.js/utils';
import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';

const keypair = new Ed25519Keypair();
const address = keypair.getPublicKey().toSuiAddress();

const rpcUrl = getFullnodeUrl('mainnet');
const client = new SuiClient({ url: rpcUrl });
 
const SCALLOP_MARKET_OBJECT = "0xa757975255146dc9686aa823b7838b507f315d704f428cbadad2f4ea061939d9";
const SCALLOP_VERSION_OBJECT = "0x07871c4b3c847a0f674510d4978d5cf6f960452795e8ff6f189fd2088a3f6ac7";

const txb = new TransactionBlock();
txb.setSender();
const [sui] = txb.splitCoins(txb.gas, [1e9]);

const sCoin = txb.moveCall({
  target: "0xa45b8ffca59e5b44ec7c04481a04cb620b0e07b2b183527bca4e5f32372c5f1a::mint::mint",
  arguments: [
    txb.object(SCALLOP_VERSION_OBJECT),
    txb.object(SCALLOP_MARKET_OBJECT),
    sui,
    txb.object(SUI_CLOCK_OBJECT_ID),
  ],
  typeArguments: ["0x2::sui::SUI"],
});

txb.transferObjects([sCoin], txb.pure(address));

await client.signAndExecuteTransaction({
  signer: getKeyPair(keypair),
  transaction: txb,
  requestType: 'WaitForLocalExecution',
  options: {
    showEffects: true,
  },
});

Redeem

---

Withdraw assets from Scallop on Lending Pools, but there’s one thing to remember here is you need your sCoin object to withdraw assets from pool.

public fun redeem<T>(
  version: &Version,
  market: &mut Market,
  coin: Coin<MarketCoin<T>>,
  clock: &Clock,
  ctx: &mut TxContext,
): Coin<T> { }

Paremeters:

Name	Type	Description
version	Version	The version control object, contract version must match with this
market	Market	The Scallop market object, it contains base assets, and related protocol configs
coin	Coin<MarketCoin>	The sCoin object to exchange for underlying base asset
clock	Clock	The SUI system Clock object

Return Value:

Name	Type	Description
Coin	Coin	The redeemed underlying asset

Events

• RedeemEvent is emited when ****the withdraw tx success

Errors

• 2050: The marketcoin used to redeem the assets is to small.

• 81924: Reserve not enough.

• 81921: Pool liquidity not enough to redeemed underlying assets.

Example:

Move

module protocol::foo {

  use sui::tx_context::{Self ,TxContext};
  use sui::coin::{Self, Coin};
  use sui::coin::{Self, Coin};

  use scallop_protocol::mint::mint;
  use scallop_protocol::Market as ScallopMarket;
  use scallop_protocol::Version as ScallopVersion;

  public fun doFoo<T>(
    scallop_version: &ScallopVersion,
    scallop_market: &mut ScallopMarket,
    s_coin: Coin<MarketCoin<T>>,
    clock: &Clock,
    ctx: &mut TxContext
  ): Coin<MarketCoin<T>> {
     scallop_protocol::redeem::redeem<T>(
	scallop_version,
	scallop_market,
	s_coin,
	clock,
	ctx,
     )
  }
}

Typescript

import { getFullnodeUrl, SuiClient, } from '@mysten/sui.js/client';
import { SUI_CLOCK_OBJECT_ID } from '@mysten/sui.js/utils';
import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';

const keypair = new Ed25519Keypair();
const address = keypair.getPublicKey().toSuiAddress();

const rpcUrl = getFullnodeUrl('mainnet');
const client = new SuiClient({ url: rpcUrl });
 
const SCALLOP_MARKET_OBJECT = "0xa757975255146dc9686aa823b7838b507f315d704f428cbadad2f4ea061939d9";
const SCALLOP_VERSION_OBJECT = "0x07871c4b3c847a0f674510d4978d5cf6f960452795e8ff6f189fd2088a3f6ac7";

const getSCoin = await client.getCoins({
  owner: address,
 coinType: "0xefe8b36d5b2e43728cc323298626b83177803521d195cfb11e15b910e892fddf::reserve::MarketCoin<0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI>"
});

const sCoinObjects = getScoin.map((scoin) => scoin.coinObjectId);
if(sCoinObjects.length > 0) {
  const txb = new TransactionBlock();
  txb.setSender();

  if(sCoinObjects.length > 1) {
    txb.merge(sCoinObjects[0], sCoinObjects.slice(1, sCoinObjects.length);
  }

  const [sSUI] = txb.splitCoins(sCoinObjects[0], [1e9]);
  const sCoin = txb.moveCall({
   target: "0xa45b8ffca59e5b44ec7c04481a04cb620b0e07b2b183527bca4e5f32372c5f1a::redeem::redeem",
   arguments: [
     txb.object(SCALLOP_VERSION_OBJECT),
     txb.object(SCALLOP_MARKET_OBJECT),
     sSUI,
     txb.object(SUI_CLOCK_OBJECT_ID),
   ],
   typeArguments: ["0xefe8b36d5b2e43728cc323298626b83177803521d195cfb11e15b910e892fddf::reserve::MarketCoin<0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI>"],
  });

  txb.transferObjects([sCoin], txb.pure(address));

  await client.signAndExecuteTransaction({
    signer: getKeyPair(keypair),
    transaction: txb,
    requestType: 'WaitForLocalExecution',
    options: {
	showEffects: true,
    },
 });
}