WavesDAO -> WXDAO funding

docs/wxdao_funding/wxdao_funding.md

@@ -0,0 +1,26 @@
+# WavesDAO -> WXDAO Funding
+
+## Keys
+| key | type | value |
+| :---------------------------------- | --------: | :----------------------------------------------------------- |
+| `%s__mainTreasuryAddress` | `String` | `'3PEwRcYNAUtoFvKpBhKoiwajnZfdoDR6h4h'` |
+| `%s__WavesUSDTPoolAddress` | `String` | `'3PKfrupEydU2nZAghVjZAfvCwMBkzuR1F52'` |
+| `%s__WXDAOcontractAddress` | `String` | `'3PEhMFF2mfSWVxWqbW8guXVYcNeoW77ga7T'` |
+| `%s__WXDAOassetId` | `String` | `'BE4VVq1VsrwGyUWpUkNjVFR5j9vzioiRhrUT52p8RW2m'` |
+| `%s__USDTassetId` | `String` | `'G5WWWzzVsWRyzGf32xojbnfp7gXbWrgqJT8RcVWEfLmC'` |
+| `%s__minClaimAmount` | `Integer` | `30000000000` |
+| `%s__processFeeAmount` | `Integer` | `500000` |
+| `%s__WXDAOpriceCoeff` | `Integer` | `110000000` (SCALE8) |
+| `%s%s%s__history__<action>__<txId>` | `String` | `'%d%d%d__<wavesAmount>__<WXDAOamount>__<processFeeAmount>'` |
+
+
+# Functions
+
+
+## Process
+- Waves amount claimed from WavesDAO should be exceed `minClaimAmount` (*default: 300.0*)
+- `processFee` (*default: 0.005*) Waves amount is sent back to caller
+```
+@Callable(i)
+func process()
+```

migrations/2024_03_29_wxdao_funding/01_wxdao_funding_data_tx.json

@@ -0,0 +1,48 @@
+{
+ "type": 12,
+ "fee": 900000,
+ "version": 2,
+ "senderPublicKey": "5WG53hB4ZK2TWX7UnLeTU4ieDp8Fy4VtaYx6gKFYxGHu",
+ "data": [
+ {
+ "key": "%s__mainTreasuryAddress",
+ "type": "string",
+ "value": "3PEwRcYNAUtoFvKpBhKoiwajnZfdoDR6h4h"
+ },
+ {
+ "key": "%s__WavesUSDTPoolAddress",
+ "type": "string",
+ "value": "3PKfrupEydU2nZAghVjZAfvCwMBkzuR1F52"
+ },
+ {
+ "key": "%s__WXDAOcontractAddress",
+ "type": "string",
+ "value": "3PEhMFF2mfSWVxWqbW8guXVYcNeoW77ga7T"
+ },
+ {
+ "key": "%s__WXDAOassetId",
+ "type": "string",
+ "value": "BE4VVq1VsrwGyUWpUkNjVFR5j9vzioiRhrUT52p8RW2m"
+ },
+ {
+ "key": "%s__USDTassetId",
+ "type": "string",
+ "value": "G5WWWzzVsWRyzGf32xojbnfp7gXbWrgqJT8RcVWEfLmC"
+ },
+ {
+ "key": "%s__minClaimAmount",
+ "type": "integer",
+ "value": 30000000000
+ },
+ {
+ "key": "%s__processFeeAmount",
+ "type": "integer",
+ "value": 500000
+ },
+ {
+ "key": "%s__WXDAOpriceCoeff",
+ "type": "integer",
+ "value": 110000000
+ }
+ ]
+}

ride/wxdao_funding.ride

@@ -0,0 +1,195 @@
+{-# STDLIB_VERSION 6 #-}
+{-# CONTENT_TYPE DAPP #-}
+{-# SCRIPT_TYPE ACCOUNT #-}
+
+let SEP = "__"
+let CONTRACT_NAME = "wxdao_funding.ride"
+let SCALE8 = 100_000_000
+let WAVES = "WAVES"
+
+func wrapErr(s: String) = {
+ CONTRACT_NAME + ": " + s
+}
+
+func throwErr(s: String) = {
+ throw(wrapErr(s))
+}
+
+func keyMainTreasuryAddress() = ["%s", "mainTreasuryAddress"].makeString(SEP)
+func keyWavesUSDTPoolAddress() = ["%s", "WavesUSDTPoolAddress"].makeString(SEP)
+func keyWXDAOAddress() = ["%s", "WXDAOcontractAddress"].makeString(SEP)
+func keyWXDAOassetId() = ["%s", "WXDAOassetId"].makeString(SEP)
+func keyUSDTassetId() = ["%s", "USDTassetId"].makeString(SEP)
+func keyProcessFeeAmount() = ["%s", "processFeeAmount"].makeString(SEP)
+func keyMinClaimAmount() = ["%s", "minClaimAmount"].makeString(SEP)
+func keyWXDAOpriceCoeff() = ["%s", "WXDAOpriceCoeff"].makeString(SEP)
+
+func keyHistory(action: String, txId: String) = ["%s%s%s", "history", action, txId].makeString(SEP)
+
+func formatProcessHistory(claimedWavesAmount: Int, sendWXDAOamount: Int, processFeeAmount: Int) = {
+ [
+ "%d%d%d",
+ claimedWavesAmount.toString(),
+ sendWXDAOamount.toString(),
+ processFeeAmount.toString()
+ ].makeString(SEP)
+}
+
+let mainTreasuryAddressString = this.getStringValue(keyMainTreasuryAddress())
+let mainTreasuryAddressOrFail = mainTreasuryAddressString.addressFromStringValue()
+let wavesUSDTpoolAddressString = this.getStringValue(keyWavesUSDTPoolAddress())
+let wavesUSDTpoolAddressOrFail = wavesUSDTpoolAddressString.addressFromStringValue()
+let wxdaoAddressString = this.getStringValue(keyWXDAOAddress())
+let wxdaoAddressOrFail = wxdaoAddressString.addressFromStringValue()
+
+func stringToAsset(assetIdString: String) = {
+ if (assetIdString == WAVES) then unit else assetIdString.fromBase58String()
+}
+
+func assetToString(assetId: ByteVector|Unit) = {
+ match (assetId) {
+ case b:ByteVector => b.toBase58String()
+ case _ => WAVES
+ }
+}
+
+func getBalance(address: Address, assetIdString: String) = {
+ let assetId = stringToAsset(assetIdString)
+
+ match (assetId) {
+ case b:ByteVector => address.assetBalance(b)
+ case _ => address.wavesBalance().available
+ }
+}
+
+let processFeeAmount = this.getInteger(keyProcessFeeAmount()).valueOrElse(500000)
+let minClaimAmount = this.getInteger(keyMinClaimAmount()).valueOrElse(0)
+let wxdaoPriceCoeff = this.getInteger(keyWXDAOpriceCoeff()).valueOrElse(SCALE8)
+let usdtAssetIdString = this.getStringValue(keyUSDTassetId())
+let wxdaoAssetIdString = this.getStringValue(keyWXDAOassetId())
+let wxdaoAssetId = stringToAsset(wxdaoAssetIdString)
+
+
+##### PROPOSAL VERIFIER #####
+func keyVotingResultAddress() = "contract_voting_result"
+func keyProposalAllowBroadcast(address: Address, txId: ByteVector) =
+ ((("proposal_allow_broadcast_" + toString(address)) + "_") + toBase58String(txId))
+
+let votingResultAddress = match getString(this, keyVotingResultAddress()) {
+ case s: String => 
+ addressFromString(s)
+ case _: Unit => 
+ unit
+ case _ => 
+ throw("Match error")
+}
+##### PROPOSAL VERIFIER #####
+
+func claimWavesFromTreasury() = {
+ strict oldWavesBalance = this.getBalance(WAVES)
+ strict getWavesInvoke = mainTreasuryAddressOrFail.invoke("Claim", [], [])
+ strict newWavesBalance = this.getBalance(WAVES)
+
+ newWavesBalance - oldWavesBalance
+}
+
+func getPoolBalance(poolAddress: Address, assetIdString: String) = {
+ let invokeResult = poolAddress.invoke("getAccBalanceWrapperREADONLY", [assetIdString], [])
+ match (invokeResult) {
+ case balance:Int => balance
+ case _ => "getAccBalanceWrapperREADONLY unexpected value".throwErr()
+ }
+}
+
+func getWavesUSDTPrice() = {
+ let poolWavesBalance = wavesUSDTpoolAddressOrFail.getPoolBalance(WAVES)
+ let poolUsdtBalance = wavesUSDTpoolAddressOrFail.getPoolBalance(usdtAssetIdString)
+
+ strict ch = [
+ poolWavesBalance > 0 || "WAVES/USDT pool Waves balance should be greater that 0".throwErr(),
+ poolUsdtBalance > 0 || "WAVES/USDT pool USDT balance should be greater that 0".throwErr()
+ ]
+
+ fraction(poolUsdtBalance, SCALE8, poolWavesBalance)
+}
+
+func getWXDAOUsdtPrice() = {
+ let priceInvoke = wxdaoAddressOrFail.invoke("call", ["price", []], [])
+ let invokeResult = match (priceInvoke) {
+ case r:List[Any] => {
+ match(r[0]) {
+ case i:Int => fraction(i, wxdaoPriceCoeff, SCALE8)
+ case _ => unit
+ }
+ }
+ case _ => unit
+ }
+ let wxDAOprice = invokeResult.valueOrErrorMessage("Unexpected WXDAO Price invoke result".wrapErr())
+
+ strict ch = [
+ wxDAOprice > 0 || "WXDAO price should be greater than 0".throwErr()
+ ]
+
+ wxDAOprice
+}
+
+func getWavesWXDAOPrice() = {
+ let wavesUsdtPrice = getWavesUSDTPrice()
+ let wxdaoUsdtPrice = getWXDAOUsdtPrice()
+
+ fraction(wavesUsdtPrice, SCALE8, wxdaoUsdtPrice)
+}
+
+func calcWXDAOamount(wavesAmount: Int) = {
+ let price = getWavesWXDAOPrice()
+ let wxDAOamount = fraction(wavesAmount, price, SCALE8)
+
+ strict ch =[
+ wavesAmount > 0 || "wavesAmount should be greater than 0".throwErr(),
+ price > 0 || "price should be greater than 0".throwErr(),
+ wxDAOamount > 0 || "wxDAO swap amount is 0".throwErr()
+ ]
+
+ wxDAOamount
+}
+
+@Callable(i)
+func process() = {
+ strict claimedWavesAmount = claimWavesFromTreasury()
+ strict swapWavesAmount = claimedWavesAmount - processFeeAmount
+ strict wxDAOsendAmount = calcWXDAOamount(swapWavesAmount)
+
+ strict ch = [
+ claimedWavesAmount >= minClaimAmount || 
+ ["not enough claim amount (", claimedWavesAmount.toString(), " < ", minClaimAmount.toString(), ")"].makeString("").throwErr(),
+ swapWavesAmount > 0 || "claimed waves amount should be greater than processing fee".throwErr(),
+ wxDAOsendAmount > 0 || "WXDAO send amount should be greater than 0".throwErr()
+ ]
+
+ let processingCaller = i.originCaller
+
+ [
+ ScriptTransfer(processingCaller, processFeeAmount, stringToAsset(WAVES)),
+ ScriptTransfer(mainTreasuryAddressOrFail, wxDAOsendAmount, wxdaoAssetId),
+ StringEntry(
+ keyHistory("process", i.transactionId.toBase58String()),
+ formatProcessHistory(claimedWavesAmount, wxDAOsendAmount, processFeeAmount)
+ )
+ ]
+}
+
+
+@Verifier(tx)
+func verify () = {
+ let byProposal = match votingResultAddress {
+ case proposalAddress: Address => 
+ valueOrElse(getBoolean(proposalAddress, keyProposalAllowBroadcast(this, tx.id)), false)
+ case _ => 
+ false
+ }
+
+ let byOwner = sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
+ if (byProposal)
+ then true
+ else byOwner
+}

test/components/wxdao_funding/_hooks.mjs

@@ -0,0 +1,101 @@
+import { address, randomSeed, publicKey } from '@waves/ts-lib-crypto';
+import {
+ data,
+ massTransfer,
+ issue,
+} from '@waves/waves-transactions';
+import { format } from 'path';
+import { setScriptFromFile } from '../../utils/utils.mjs';
+
+import {
+ broadcastAndWait, chainId, baseSeed,
+} from '../../utils/api.mjs';
+
+const seedWordsCount = 5;
+const ridePath = '../ride';
+const mockPath = 'components/wxdao_funding/mock';
+const wxdaoFundingPath = format({ dir: ridePath, base: 'wxdao_funding.ride' });
+const wxdaoMockPath = format({ dir: mockPath, base: 'wxdao.mock.ride' });
+const poolMockPath = format({ dir: mockPath, base: 'pool.mock.ride' });
+const mainTreasury = format({ dir: mockPath, base: 'mainTreasury.mock.ride' });
+
+export const mochaHooks = {
+ async beforeAll() {
+ const names = [
+ 'wxdaoFunding',
+ 'wxdao',
+ 'mainTreasury',
+ 'wavesUsdtPool',
+ 'user1',
+ ];
+ this.accounts = Object.fromEntries(names.map((item) => {
+ const itemSeed = randomSeed(seedWordsCount);
+ return [
+ item,
+ { seed: itemSeed, addr: address(itemSeed, chainId), publicKey: publicKey(itemSeed) },
+ ];
+ }));
+ const amount = 100e8;
+ const massTransferTx = massTransfer({
+ transfers: Object.values(this.accounts).map((item) => ({ recipient: item.addr, amount })),
+ chainId,
+ }, baseSeed);
+ await broadcastAndWait(massTransferTx);
+
+ this.wxdaoAssetId = await broadcastAndWait(issue({
+ quantity: 1e6 * 1e8,
+ decimals: 8,
+ name: 'WXDAO',
+ description: 'WXDAO',
+ chainId,
+ }, baseSeed)).then((tx) => tx.id);
+
+ await broadcastAndWait(massTransfer({
+ transfers: Object.values(this.accounts).map((item) => ({ recipient: item.addr, amount })),
+ chainId,
+ assetId: this.wxdaoAssetId,
+ }, baseSeed));
+
+ await broadcastAndWait(data({
+ additionalFee: 4e5,
+ data: [
+ {
+ key: '%s__mainTreasuryAddress',
+ type: 'string',
+ value: this.accounts.mainTreasury.addr,
+ },
+ {
+ key: '%s__WavesUSDTPoolAddress',
+ type: 'string',
+ value: this.accounts.wavesUsdtPool.addr,
+ },
+ {
+ key: '%s__WXDAOcontractAddress',
+ type: 'string',
+ value: this.accounts.wxdao.addr,
+ },
+ {
+ key: '%s__WXDAOassetId',
+ type: 'string',
+ value: this.wxdaoAssetId,
+ },
+ {
+ key: '%s__USDTassetId',
+ type: 'string',
+ value: 'MOCKED_USDT_ASSET_ID',
+ },
+ {
+ key: '%s__WXDAOpriceCoeff',
+ type: 'integer',
+ value: 1_1000_0000, // 110%
+ },
+ ],
+ chainId,
+ }, this.accounts.wxdaoFunding.seed));
+
+ await setScriptFromFile(wxdaoFundingPath, this.accounts.wxdaoFunding.seed);
+ await setScriptFromFile(wxdaoMockPath, this.accounts.wxdao.seed);
+ await setScriptFromFile(poolMockPath, this.accounts.wavesUsdtPool.seed);
+ await setScriptFromFile(mainTreasury, this.accounts.mainTreasury.seed);
+ },
+};

test/components/wxdao_funding/mock/mainTreasury.mock.ride

@@ -0,0 +1,11 @@
+{-# STDLIB_VERSION 6 #-}
+{-# CONTENT_TYPE DAPP #-}
+{-# SCRIPT_TYPE ACCOUNT #-}
+
+# Send 1.5 WAVES
+@Callable(i)
+func Claim() = {
+ [
+ ScriptTransfer(i.caller, 1_5000_0000, unit)
+ ]
+}