From 1f6b51073f845cfa452773f0953053cc0c93cca6 Mon Sep 17 00:00:00 2001 From: owen05 Date: Sun, 28 Mar 2021 11:27:07 +0800 Subject: [PATCH] dsp ing --- test/DSP/funding.test.ts | 204 +++++++++++++++++++++++++++++++++++++++ test/DSP/trader.test.ts | 202 ++++++++++++++++++++++++++++++++++++++ test/utils/Contracts.ts | 2 + test/utils/DSPContext.ts | 154 +++++++++++++++++++++++++++++ 4 files changed, 562 insertions(+) create mode 100644 test/DSP/funding.test.ts create mode 100644 test/DSP/trader.test.ts create mode 100644 test/utils/DSPContext.ts diff --git a/test/DSP/funding.test.ts b/test/DSP/funding.test.ts new file mode 100644 index 0000000..acfdb1a --- /dev/null +++ b/test/DSP/funding.test.ts @@ -0,0 +1,204 @@ +/* + + Copyright 2020 DODO ZOO. + SPDX-License-Identifier: Apache-2.0 + +*/ + +// import * as assert from 'assert'; + +import { decimalStr, MAX_UINT256 } from '../utils/Converter'; +import { logGas } from '../utils/Log'; +import { DVMContext, getDVMContext } from '../utils/DVMContext'; +import { assert } from 'chai'; +import BigNumber from 'bignumber.js'; +const truffleAssert = require('truffle-assertions'); + +let lp: string; +let trader: string; + +async function init(ctx: DVMContext): Promise { + lp = ctx.SpareAccounts[0]; + trader = ctx.SpareAccounts[1]; + + await ctx.mintTestToken(lp, decimalStr("10"), decimalStr("1000")); + await ctx.mintTestToken(trader, decimalStr("10"), decimalStr("1000")); +} + +describe("Funding", () => { + let snapshotId: string; + let ctx: DVMContext; + + before(async () => { + ctx = await getDVMContext(); + await init(ctx); + }); + + beforeEach(async () => { + snapshotId = await ctx.EVM.snapshot(); + }); + + afterEach(async () => { + await ctx.EVM.reset(snapshotId); + }); + + describe("buy shares", () => { + + it("buy shares from init states", async () => { + + await ctx.transferBaseToDVM(lp, decimalStr("10")) + await logGas(ctx.DVM.methods.buyShares(lp), ctx.sendParam(lp), "buy shares"); + + // vault balances + assert.equal( + await ctx.BASE.methods.balanceOf(ctx.DVM.options.address).call(), + decimalStr("10") + ); + assert.equal( + await ctx.QUOTE.methods.balanceOf(ctx.DVM.options.address).call(), + decimalStr("0") + ); + assert.equal( + await ctx.DVM.methods._BASE_RESERVE_().call(), + decimalStr("10") + ) + assert.equal( + await ctx.DVM.methods._QUOTE_RESERVE_().call(), + decimalStr("0") + ) + + // shares number + assert.equal(await ctx.DVM.methods.balanceOf(lp).call(), decimalStr("10")) + }); + + it("buy shares from init states with quote != 0", async () => { + await ctx.transferBaseToDVM(lp, decimalStr("10")) + await ctx.transferQuoteToDVM(lp, decimalStr("100")) + await ctx.DVM.methods.buyShares(lp).send(ctx.sendParam(lp)); + assert.equal(await ctx.DVM.methods.balanceOf(lp).call(), decimalStr("10")) + assert.equal(await ctx.DVM.methods.getMidPrice().call(), "102078438912577213500") + }) + + it("buy shares with balanced input", async () => { + await ctx.transferBaseToDVM(lp, decimalStr("10")) + await ctx.DVM.methods.buyShares(lp).send(ctx.sendParam(lp)) + + await ctx.transferQuoteToDVM(trader, decimalStr("200")) + await ctx.DVM.methods.sellQuote(trader).send(ctx.sendParam(trader)) + + var vaultBaseBalance = new BigNumber(await ctx.BASE.methods.balanceOf(ctx.DVM.options.address).call()) + var vaultQuoteBalance = new BigNumber(await ctx.QUOTE.methods.balanceOf(ctx.DVM.options.address).call()) + var increaseRatio = new BigNumber("0.1") + + await ctx.transferBaseToDVM(trader, vaultBaseBalance.multipliedBy(increaseRatio).toFixed(0)) + await ctx.transferQuoteToDVM(trader, vaultQuoteBalance.multipliedBy(increaseRatio).toFixed(0)) + await ctx.DVM.methods.buyShares(trader).send(ctx.sendParam(trader)) + + assert.equal( + await ctx.BASE.methods.balanceOf(ctx.DVM.options.address).call(), + "8852116395368015179" + ); + assert.equal( + await ctx.QUOTE.methods.balanceOf(ctx.DVM.options.address).call(), + "220000000000000000000" + ); + + assert.equal(await ctx.DVM.methods.balanceOf(trader).call(), "999999999999999990") + }) + + it("buy shares with unbalanced input (less quote)", async () => { + await ctx.transferBaseToDVM(lp, decimalStr("10")) + await ctx.DVM.methods.buyShares(lp).send(ctx.sendParam(lp)) + + await ctx.transferQuoteToDVM(trader, decimalStr("200")) + await ctx.DVM.methods.sellQuote(trader).send(ctx.sendParam(trader)) + + var vaultBaseBalance = new BigNumber(await ctx.BASE.methods.balanceOf(ctx.DVM.options.address).call()) + var vaultQuoteBalance = new BigNumber(await ctx.QUOTE.methods.balanceOf(ctx.DVM.options.address).call()) + var increaseRatio = new BigNumber("0.1") + + await ctx.transferBaseToDVM(trader, vaultBaseBalance.multipliedBy(increaseRatio).toFixed(0)) + await ctx.transferQuoteToDVM(trader, vaultQuoteBalance.multipliedBy(increaseRatio).div(2).toFixed(0)) + await ctx.DVM.methods.buyShares(trader).send(ctx.sendParam(trader)) + + assert.equal(await ctx.DVM.methods.balanceOf(trader).call(), "500000000000000000") + }) + + it("buy shares with unbalanced input (less base)", async () => { + await ctx.transferBaseToDVM(lp, decimalStr("10")) + await ctx.DVM.methods.buyShares(lp).send(ctx.sendParam(lp)) + + await ctx.transferQuoteToDVM(trader, decimalStr("200")) + await ctx.DVM.methods.sellQuote(trader).send(ctx.sendParam(trader)) + + var vaultBaseBalance = new BigNumber(await ctx.BASE.methods.balanceOf(ctx.DVM.options.address).call()) + var vaultQuoteBalance = new BigNumber(await ctx.QUOTE.methods.balanceOf(ctx.DVM.options.address).call()) + var increaseRatio = new BigNumber("0.1") + + await ctx.transferBaseToDVM(trader, vaultBaseBalance.multipliedBy(increaseRatio).div(2).toFixed(0)) + await ctx.transferQuoteToDVM(trader, vaultQuoteBalance.multipliedBy(increaseRatio).toFixed(0)) + await ctx.DVM.methods.buyShares(trader).send(ctx.sendParam(trader)) + + assert.equal(await ctx.DVM.methods.balanceOf(trader).call(), "499999999999999990") + }) + }); + + describe("sell shares", () => { + it("not the last one sell shares", async () => { + await ctx.transferBaseToDVM(lp, decimalStr("10")) + await ctx.transferQuoteToDVM(lp, decimalStr("100")) + await ctx.DVM.methods.buyShares(lp).send(ctx.sendParam(lp)) + + await ctx.transferBaseToDVM(trader, decimalStr("1")) + await ctx.transferQuoteToDVM(trader, decimalStr("10")) + await ctx.DVM.methods.buyShares(trader).send(ctx.sendParam(trader)) + + var vaultShares = new BigNumber(await ctx.DVM.methods.balanceOf(lp).call()) + var bob = ctx.SpareAccounts[5] + await ctx.DVM.methods.sellShares(vaultShares.div(2).toFixed(0), bob, 0, 0, "0x", MAX_UINT256).send(ctx.sendParam(lp)) + assert.equal(await ctx.BASE.methods.balanceOf(bob).call(), decimalStr("5")) + assert.equal(await ctx.QUOTE.methods.balanceOf(bob).call(), decimalStr("50")) + + await ctx.DVM.methods.sellShares(vaultShares.div(2).toFixed(0), bob, 0, 0, "0x", MAX_UINT256).send(ctx.sendParam(lp)) + assert.equal(await ctx.BASE.methods.balanceOf(bob).call(), decimalStr("10")) + assert.equal(await ctx.QUOTE.methods.balanceOf(bob).call(), decimalStr("100")) + }) + + it("the last one sell shares", async () => { + await ctx.transferBaseToDVM(lp, decimalStr("10")) + await ctx.transferQuoteToDVM(lp, decimalStr("100")) + await ctx.DVM.methods.buyShares(lp).send(ctx.sendParam(lp)) + + var vaultShares = await ctx.DVM.methods.balanceOf(lp).call() + var bob = ctx.SpareAccounts[5] + await ctx.DVM.methods.sellShares(vaultShares, bob, 0, 0, "0x", MAX_UINT256).send(ctx.sendParam(lp)) + assert.equal(await ctx.BASE.methods.balanceOf(bob).call(), decimalStr("10")) + assert.equal(await ctx.QUOTE.methods.balanceOf(bob).call(), decimalStr("100")) + }) + + it("revert cases", async () => { + await ctx.transferBaseToDVM(lp, decimalStr("10")) + await ctx.transferQuoteToDVM(lp, decimalStr("100")) + await ctx.DVM.methods.buyShares(lp).send(ctx.sendParam(lp)) + + var vaultShares = await ctx.DVM.methods.balanceOf(lp).call() + var bob = ctx.SpareAccounts[5] + await truffleAssert.reverts( + ctx.DVM.methods.sellShares(new BigNumber(vaultShares).multipliedBy(2), bob, 0, 0, "0x", MAX_UINT256).send(ctx.sendParam(lp)), + "DLP_NOT_ENOUGH" + ) + await truffleAssert.reverts( + ctx.DVM.methods.sellShares(vaultShares, bob, decimalStr("100"), 0, "0x", MAX_UINT256).send(ctx.sendParam(lp)), + "WITHDRAW_NOT_ENOUGH" + ) + await truffleAssert.reverts( + ctx.DVM.methods.sellShares(vaultShares, bob, 0, decimalStr("10000"), "0x", MAX_UINT256).send(ctx.sendParam(lp)), + "WITHDRAW_NOT_ENOUGH" + ) + await truffleAssert.reverts( + ctx.DVM.methods.sellShares(vaultShares, bob, 0, decimalStr("10000"), "0x", "0").send(ctx.sendParam(lp)), + "TIME_EXPIRED" + ) + }) + }) +}); diff --git a/test/DSP/trader.test.ts b/test/DSP/trader.test.ts new file mode 100644 index 0000000..7fa5d4d --- /dev/null +++ b/test/DSP/trader.test.ts @@ -0,0 +1,202 @@ +/* + + Copyright 2020 DODO ZOO. + SPDX-License-Identifier: Apache-2.0 + +*/ + +// import * as assert from 'assert'; + +import { decimalStr, gweiStr } from '../utils/Converter'; +import { logGas } from '../utils/Log'; +import { DSPContext, getDSPContext } from '../utils/DSPContext'; +import { assert } from 'chai'; +const truffleAssert = require('truffle-assertions'); + +let lp: string; +let trader: string; + +async function init(ctx: DSPContext): Promise { + lp = ctx.Deployer + trader = ctx.SpareAccounts[1]; + + await ctx.mintTestToken(lp, decimalStr("1000"), decimalStr("1000")); + await ctx.mintTestToken(trader, decimalStr("1000"), decimalStr("1000")); + + await ctx.transferBaseToDSP(lp, decimalStr("1000")) + await ctx.transferQuoteToDSP(lp, decimalStr("1000")) + await ctx.DSP.methods.buyShares(lp).send(ctx.sendParam(lp)) +} + +describe("DSP Trader", () => { + let snapshotId: string; + let ctx: DSPContext; + + before(async () => { + ctx = await getDSPContext(); + await init(ctx); + }); + + beforeEach(async () => { + snapshotId = await ctx.EVM.snapshot(); + }); + + afterEach(async () => { + await ctx.EVM.reset(snapshotId); + }); + + describe("trade", () => { + + it("first buy and then sell", async () => { + // buy at R=1 + await ctx.transferQuoteToDSP(trader, decimalStr("100")) + await logGas(ctx.DSP.methods.sellQuote(trader), ctx.sendParam(trader), "sellQuote - buy at R=1") + var balances = await ctx.getBalances(trader) + + console.log("Balance:", balances); + // assert.equal(balances.traderBase, "10986174542266106307") + // assert.equal(balances.traderQuote, decimalStr("900")) + // assert.equal(balances.DPPBase, "9012836315765723075") + // assert.equal(balances.DPPQuote, decimalStr("1100")) + // assert.equal(balances.maintainerBase, "989141968170618") + // assert.equal(balances.maintainerQuote, "0") + + // buy at R>1 + await ctx.transferQuoteToDSP(trader, decimalStr("100")) + await logGas(ctx.DSP.methods.sellQuote(trader), ctx.sendParam(trader), "sellQuote - buy at R>1") + balances = await ctx.getBalances(trader) + console.log("Balance:", balances); + + // assert.equal(balances.traderBase, "11946772292527553373") + // assert.equal(balances.traderQuote, decimalStr("800")) + // assert.equal(balances.DPPBase, "8051275077289369844") + // assert.equal(balances.DPPQuote, decimalStr("1200")) + // assert.equal(balances.maintainerBase, "1952630183076783") + // assert.equal(balances.maintainerQuote, "0") + + // sell at R>1 and R not change state + await ctx.transferBaseToDSP(trader, decimalStr("100")) + await logGas(ctx.DSP.methods.sellBase(trader), ctx.sendParam(trader), "sellBase - sell at R>1 and R not change state") + balances = await ctx.getBalances(trader) + console.log("Balance:", balances); + // assert.equal(balances.traderBase, "10946772292527553373") + // assert.equal(balances.traderQuote, "903421814651005338950") + // assert.equal(balances.DPPBase, "9051275077289369844") + // assert.equal(balances.DPPQuote, "1096474452335302579467") + // assert.equal(balances.maintainerBase, "1952630183076783") + // assert.equal(balances.maintainerQuote, "103733013692081583") + + + // sell at R>1 and R change state + await ctx.transferBaseToDSP(trader, decimalStr("200")) + + await logGas(ctx.DSP.methods.sellBase(trader), ctx.sendParam(trader), "sellBase - sell at R>1 and R change state") + balances = await ctx.getBalances(trader) + console.log("Balance:", balances); + + // assert.equal(balances.traderBase, "8946772292527553373") + // assert.equal(balances.traderQuote, "1102638273848343281094") + // assert.equal(balances.DPPBase, "11051275077289369844") + // assert.equal(balances.DPPQuote, "897058177231046545105") + // assert.equal(balances.maintainerBase, "1952630183076783") + // assert.equal(balances.maintainerQuote, "303548920610173801") + + var PMMStat = await ctx.DSP.methods.getPMMState().call() + console.log("PMMStat:", PMMStat) + // assert.equal(PMMStat.R, "2") + // assert.equal(PMMStat.B0, "10005950249348099200") + }); + + it("first sell and then buy", async () => { + // sell at R=1 + await ctx.transferBaseToDSP(trader, decimalStr("1")) + await logGas(ctx.DSP.methods.sellBase(trader), ctx.sendParam(trader), "sellBase - sell at R=1") + var balances = await ctx.getBalances(trader) + console.log("balances:",balances) + + // assert.equal(balances.traderBase, decimalStr("9")) + // assert.equal(balances.traderQuote, "1098617454226610630663") + // assert.equal(balances.DPPBase, decimalStr("11")) + // assert.equal(balances.DPPQuote, "901283631576572307521") + // assert.equal(balances.maintainerBase, "0") + // assert.equal(balances.maintainerQuote, "98914196817061816") + + // buy at R>1 + await ctx.transferBaseToDSP(trader, decimalStr("1")) + await logGas(ctx.DSP.methods.sellBase(trader), ctx.sendParam(trader), "sellBase - buy at R>1") + balances = await ctx.getBalances(trader) + console.log("balances:", balances) + + // assert.equal(balances.traderBase, decimalStr("8")) + // assert.equal(balances.traderQuote, "1194677229252755337109") + // assert.equal(balances.DPPBase, decimalStr("12")) + // assert.equal(balances.DPPQuote, "805127507728936984519") + // assert.equal(balances.maintainerBase, "0") + // assert.equal(balances.maintainerQuote, "195263018307678372") + + // sell at R>1 and R not change state + await ctx.transferQuoteToDSP(trader, decimalStr("1")) + await logGas(ctx.DSP.methods.sellQuote(trader), ctx.sendParam(trader), "sell at R>1 and R not change state") + balances = await ctx.getBalances(trader) + console.log("balances:", balances) + + // assert.equal(balances.traderBase, "9034218146510053391") + // assert.equal(balances.traderQuote, "1094677229252755337109") + // assert.equal(balances.DPPBase, "10964744523353025794") + // assert.equal(balances.DPPQuote, "905127507728936984519") + // assert.equal(balances.maintainerBase, "1037330136920815") + // assert.equal(balances.maintainerQuote, "195263018307678372") + + // sell at R>1 and R change state + await ctx.transferQuoteToDSP(trader, decimalStr("2")) + await logGas(ctx.DSP.methods.sellQuote(trader), ctx.sendParam(trader), "sell at R>1 and R change state") + balances = await ctx.getBalances(trader) + console.log("balances:", balances) + + // assert.equal(balances.traderBase, "11026382738483432812") + // assert.equal(balances.traderQuote, "894677229252755337109") + // assert.equal(balances.DPPBase, "8970581772310465451") + // assert.equal(balances.DPPQuote, "1105127507728936984519") + // assert.equal(balances.maintainerBase, "3035489206101737") + // assert.equal(balances.maintainerQuote, "195263018307678372") + + var PMMStat = await ctx.DSP.methods.getPMMState().call() + console.log("PMMStat:", PMMStat) + + // assert.equal(PMMStat.R, "1") + // assert.equal(PMMStat.Q0, "1000595024934809920179") + }); + + it("flash loan", async () => { + // buy + await ctx.transferQuoteToDSP(trader, decimalStr("200")) + + // buy failed + await truffleAssert.reverts(ctx.DSP.methods.flashLoan("1946763594380080790", "0", trader, "0x").send(ctx.sendParam(trader)), "FLASH_LOAN_FAILED") + + // buy succeed + await ctx.DSP.methods.flashLoan("1946763594380080789", "0", trader, "0x").send(ctx.sendParam(trader)) + + // trader balances + assert.equal( + await ctx.BASE.methods.balanceOf(trader).call(), + "11946763594380080789" + ); + + // sell + await ctx.transferBaseToDSP(trader, decimalStr("1")) + + // sell failed + await truffleAssert.reverts(ctx.DSP.methods.flashLoan("0", "103421810640399874606", trader, "0x").send(ctx.sendParam(trader)), "FLASH_LOAN_FAILED") + + // sell succeed + await ctx.DSP.methods.flashLoan("0", "103421810640399874605", trader, "0x").send(ctx.sendParam(trader)) + + // trader balances + assert.equal( + await ctx.QUOTE.methods.balanceOf(trader).call(), + "903421810640399874605" + ); + }) + }); +}); diff --git a/test/utils/Contracts.ts b/test/utils/Contracts.ts index 4b298e2..e560aad 100644 --- a/test/utils/Contracts.ts +++ b/test/utils/Contracts.ts @@ -38,6 +38,8 @@ export const EXTERNAL_VALUE_NAME = "ExternalValue" export const FEE_RATE_MODEL_NAME = "FeeRateModel" export const DPP_NAME = "DPP" export const DPP_FACTORY_NAME = "DPPFactory" +export const DSP_NAME = "DSP" +export const DSP_FACTORY_NAME = "DSPFactory" export const SMART_APPROVE = "DODOApprove" export const SMART_APPROVE_PROXY = "DODOApproveProxy" export const DODO_SELL_HELPER = "DODOSellHelper" diff --git a/test/utils/DSPContext.ts b/test/utils/DSPContext.ts new file mode 100644 index 0000000..4c9457c --- /dev/null +++ b/test/utils/DSPContext.ts @@ -0,0 +1,154 @@ +/* + + Copyright 2020 DODO ZOO. + SPDX-License-Identifier: Apache-2.0 + +*/ + +import BigNumber from 'bignumber.js'; +import Web3 from 'web3'; +import { Contract } from 'web3-eth-contract'; + +import * as contracts from './Contracts'; +import { decimalStr, MAX_UINT256 } from './Converter'; +import { EVM, getDefaultWeb3 } from './EVM'; +import * as log from './Log'; + +BigNumber.config({ + EXPONENTIAL_AT: 1000, + DECIMAL_PLACES: 80, +}); + +export interface DSPContextBalances { + traderBase: string, + traderQuote: string, + DPPBase: string, + DPPQuote: string, + maintainerBase: string, + maintainerQuote: string +} + +export interface DSPContextInitConfig { + lpFeeRate: string; + mtFeeRate: string; + k: string; + i: string; +} + +/* + price curve when k=0.1 + +──────────────────────+───────────────+ + | purchase percentage | avg slippage | + +──────────────────────+───────────────+ + | 1% | 0.1% | + | 5% | 0.5% | + | 10% | 1.1% | + | 20% | 2.5% | + | 50% | 10% | + | 70% | 23.3% | + +──────────────────────+───────────────+ +*/ +export let DefaultDSPContextInitConfig = { + lpFeeRate: decimalStr("0.002"), + mtFeeRate: decimalStr("0.001"), + k: decimalStr("0.1"), + i: decimalStr("1"), +}; + +export class DSPContext { + EVM: EVM; + Web3: Web3; + DSP: Contract; + BASE: Contract; + QUOTE: Contract; + Deployer: string; + Maintainer: string; + MtFeeRate: string; + SpareAccounts: string[]; + + mtFeeRateModel: Contract; + + + constructor() { } + + async init(config: DVMContextInitConfig) { + this.EVM = new EVM(); + this.Web3 = getDefaultWeb3(); + + this.DSP = await contracts.newContract(contracts.DSP_NAME) + var mtFeeRateModel = await contracts.newContract(contracts.FEE_RATE_MODEL_NAME) + this.mtFeeRateModel = mtFeeRateModel; + this.MtFeeRate = mtFeeRateModel.options.address + + this.BASE = await contracts.newContract( + contracts.MINTABLE_ERC20_CONTRACT_NAME, + ["TestBase", "BASE", 18] + ); + this.QUOTE = await contracts.newContract( + contracts.MINTABLE_ERC20_CONTRACT_NAME, + ["TestQuote", "QUOTE", 18] + ); + + const allAccounts = await this.Web3.eth.getAccounts(); + this.Deployer = allAccounts[0]; + this.Maintainer = allAccounts[1]; + this.SpareAccounts = allAccounts.slice(2, 10); + + await this.DSP.methods.init( + this.Maintainer, + this.BASE.options.address, + this.QUOTE.options.address, + 0, + mtFeeRateModel.options.address, + config.i, + config.k, + true + ).send(this.sendParam(this.Deployer)) + + console.log(log.blueText("[Init DSP context]")); + } + + sendParam(sender, value = "0") { + return { + from: sender, + gas: process.env["COVERAGE"] ? 10000000000 : 7000000, + gasPrice: process.env.GAS_PRICE, + value: decimalStr(value), + }; + } + + async mintTestToken(to: string, base: string, quote: string) { + await this.BASE.methods.mint(to, base).send(this.sendParam(this.Deployer)); + await this.QUOTE.methods + .mint(to, quote) + .send(this.sendParam(this.Deployer)); + } + + async transferBaseToDSP(account: string, amount: string) { + await this.BASE.methods.transfer(this.DSP.options.address, amount).send(this.sendParam(account)) + } + + async transferQuoteToDSP(account: string, amount: string) { + await this.QUOTE.methods.transfer(this.DSP.options.address, amount).send(this.sendParam(account)) + } + + async getBalances(trader: string) { + var balances: DSPContextBalances = { + traderBase: await this.BASE.methods.balanceOf(trader).call(), + traderQuote: await this.QUOTE.methods.balanceOf(trader).call(), + DPPBase: await this.BASE.methods.balanceOf(this.DSP.options.address).call(), + DPPQuote: await this.QUOTE.methods.balanceOf(this.DSP.options.address).call(), + maintainerBase: await this.BASE.methods.balanceOf(this.Maintainer).call(), + maintainerQuote: await this.QUOTE.methods.balanceOf(this.Maintainer).call() + }; + return balances; + } +} + +export async function getDSPContext( + config: DSPContextInitConfig = DefaultDSPContextInitConfig +): Promise { + var context = new DSPContext(); + await context.init(config); + return context; +}