feat: refactor tests and environment (#4)

Author: Kaladin13

package.json

@@ -27,6 +27,7 @@
         "@ton/sandbox": "^0.27.0",
         "@ton/test-utils": "^0.4.2",
         "@ton/ton": "^13.9.0",
+        "@tondevwallet/traces": "^0.1.6",
         "@types/jest": "^29.2.4",
         "@types/node": "^18.11.14",
         "@types/qs": "^6.9.7",

sources/contracts/ammPool.tact

@@ -44,8 +44,8 @@ message(0x178d4519) MintViaJettonTransferInternal {
 contract AmmPool(
     leftVault: Address,
     rightVault: Address, // To be deterministic, rightVault address must be greater than leftVault address
-    leftSide: Int as uint256, // Should be deployed with 0
-    rightSide: Int as uint256, // Should be deployed with 0
+    leftSideReserve: Int as uint256, // Should be deployed with 0
+    rightSideReserve: Int as uint256, // Should be deployed with 0
     // LP tokens-related fields
     totalSupply: Int as coins, // Should be deployed with 0
 ) {
@@ -68,18 +68,20 @@ contract AmmPool(
         let leftSideReceived = msg.leftAmount;
         let rightSideReceived = msg.rightAmount;
         // Both sides are 0 in this case.
-        if (self.leftSide == 0) {
-            self.leftSide = msg.leftAmount;
-            self.rightSide = msg.rightAmount;
+        if (self.leftSideReserve == 0) {
+            // TODO: check bug here
+            self.leftSideReserve = msg.leftAmount;
+            self.rightSideReserve = msg.rightAmount;
         } else {
             // Liquidity provide contract does not allow to add 0 tokens on one side.
             // Probably the rate has changed, so we must return extra tokens.
-            if (msg.rightAmount / msg.leftAmount > self.rightSide / self.leftSide) {
-                let expectedRightAmount = muldiv(msg.leftAmount, self.rightSide, self.leftSide);
+            if (msg.rightAmount / msg.leftAmount > self.rightSideReserve / self.leftSideReserve) {
+                let expectedRightAmount = muldiv(msg.leftAmount, self.rightSideReserve, self.leftSideReserve);
                 rightSideReceived = expectedRightAmount;
                 message(MessageParameters {
-                    value: 0,
-                    mode: SendRemainingValue,
+                    // TODO: think about the value here and in lp minting
+                    value: context().value / 2,
+                    mode: SendPayFwdFeesSeparately,
                     to: self.rightVault,
                     body: PayoutFromPool {
                         otherVault: self.leftVault,
@@ -88,11 +90,11 @@ contract AmmPool(
                     }.toCell(),
                 });
             } else {
-                let expectedLeftAmount = muldiv(msg.rightAmount, self.leftSide, self.rightSide);
+                let expectedLeftAmount = muldiv(msg.rightAmount, self.leftSideReserve, self.rightSideReserve);
                 leftSideReceived = expectedLeftAmount;
                 message(MessageParameters {
-                    value: 0,
-                    mode: SendRemainingValue,
+                    value: context().value / 2,
+                    mode: SendPayFwdFeesSeparately,
                     to: self.leftVault,
                     body: PayoutFromPool {
                         otherVault: self.rightVault,
@@ -103,7 +105,7 @@ contract AmmPool(
             }
         }
 
-        //TODO Consider checking overflow
+        // TODO Consider checking overflow
         let liquidityTokensToMint = sqrt(leftSideReceived * rightSideReceived);
 
         self.totalSupply += liquidityTokensToMint;
@@ -114,11 +116,11 @@ contract AmmPool(
 
         self.totalSupply += liquidityTokensToMint;
 
-        //Mint LP tokens
+        // Mint LP tokens, amm pool acts as the jetton minter for lp jettons
         deploy(DeployParameters {
-            value: 0,
+            value: context().value / 2 - 1,
             bounce: true,
-            mode: SendRemainingValue,
+            mode: SendPayFwdFeesSeparately,
             init: getJettonWalletInit(msg.depositor),
             body: MintViaJettonTransferInternal {
                 queryId: 0,
@@ -138,8 +140,8 @@ contract AmmPool(
         // Workchain 0 is basechain
         require(sender.workchain == Basechain && sender.address == wallet.hash!!, "Invalid sender of JettonBurn notification");
 
-        let amountOfLeftToPay = muldiv(msg.amount, self.leftSide, self.totalSupply);
-        let amountOfRightToPay = muldiv(msg.amount, self.rightSide, self.totalSupply);
+        let amountOfLeftToPay = muldiv(msg.amount, self.leftSideReserve, self.totalSupply);
+        let amountOfRightToPay = muldiv(msg.amount, self.rightSideReserve, self.totalSupply);
 
         self.totalSupply -= msg.amount;
         let halfOfMsgValue = context().value / 2;
@@ -189,13 +191,13 @@ contract AmmPool(
         if (sender == self.leftVault) {
             inVault = self.leftVault;
             outVault = self.rightVault;
-            inBalance = self.leftSide;
-            outBalance = self.rightSide;
+            inBalance = self.leftSideReserve;
+            outBalance = self.rightSideReserve;
         } else {
             inVault = self.rightVault;
             outVault = self.leftVault;
-            inBalance = self.rightSide;
-            outBalance = self.leftSide;
+            inBalance = self.rightSideReserve;
+            outBalance = self.leftSideReserve;
             vaultOrderSwap = true;
         }
 
@@ -237,20 +239,20 @@ contract AmmPool(
         });
 
         if (vaultOrderSwap) {
-            self.leftSide = newAmountOut;
-            self.rightSide = newAmountIn;
+            self.leftSideReserve = newAmountOut;
+            self.rightSideReserve = newAmountIn;
         } else {
-            self.leftSide = newAmountIn;
-            self.rightSide = newAmountOut;
+            self.leftSideReserve = newAmountIn;
+            self.rightSideReserve = newAmountOut;
         }
     }
 
     get fun getLeftSide(): Int {
-        return self.leftSide;
+        return self.leftSideReserve;
     }
 
     get fun getRightSide(): Int {
-        return self.rightSide;
+        return self.rightSideReserve;
     }
 
     get fun get_wallet_address(ownerAddress: Address): Address {
@@ -266,13 +268,13 @@ contract AmmPool(
         if (vaultAddress == self.leftVault) {
             inVault = self.leftVault;
             outVault = self.rightVault;
-            inBalance = self.leftSide;
-            outBalance = self.rightSide;
+            inBalance = self.leftSideReserve;
+            outBalance = self.rightSideReserve;
         } else {
             inVault = self.rightVault;
             outVault = self.leftVault;
-            inBalance = self.rightSide;
-            outBalance = self.leftSide;
+            inBalance = self.rightSideReserve;
+            outBalance = self.leftSideReserve;
         }
         let amountInWithFee = muldiv(amountIn, 1000 - self.PoolFee, 1000);
         let newAmountIn = inBalance + amountInWithFee;

sources/contracts/liquidityDeposit.tact

@@ -8,8 +8,8 @@ message(0xe7a3475f) PartHasBeenDeposited {
 contract LiquidityDepositContract(
     leftVault: Address, // To be deterministic, leftVault address must be less than rightVault address
     rightVault: Address,
-    leftSide: Int as uint256,
-    rightSide: Int as uint256,
+    leftSideAmount: Int as uint256,
+    rightSideAmount: Int as uint256,
     depositor: Address, // This and the next field are kind of salt, so several similar contracts can exist
     contractId: Int as uint64,
     status: Int as uint3, // Should be deployed with 0.
@@ -23,12 +23,12 @@ contract LiquidityDepositContract(
         require(sender == self.leftVault || sender == self.rightVault, "Sender must be a vault");
         if (sender == self.leftVault) {
             // TODO maybe here we should check that it is not already filled and revert on errors.
-            require(msg.amount == self.leftSide, "Amount must be equal to leftSide");
+            require(msg.amount == self.leftSideAmount, "Amount must be equal to leftSide");
             require(msg.depositor == self.depositor, "Depositor must be the same");
             self.status |= 1;
         } else {
             // TODO maybe here we should check that it is not already filled and revert on errors.
-            require(msg.amount == self.rightSide, "Amount must be equal to rightSide");
+            require(msg.amount == self.rightSideAmount, "Amount must be equal to rightSide");
             require(msg.depositor == self.depositor, "Depositor must be the same");
             self.status |= 2;
         }
@@ -39,8 +39,8 @@ contract LiquidityDepositContract(
                 mode: SendRemainingBalance + SendDestroyIfZero, // We don't need to keep this contract alive
                 init: initOf AmmPool(self.leftVault, self.rightVault, 0, 0, 0),
                 body: LiquidityDeposit {
-                    leftAmount: self.leftSide,
-                    rightAmount: self.rightSide,
+                    leftAmount: self.leftSideAmount,
+                    rightAmount: self.rightSideAmount,
                     depositor: self.depositor,
                     contractId: self.contractId,
                 }.toCell(),

sources/contracts/math.tact

@@ -1,11 +1,11 @@
-struct SortedAddresses{
+struct SortedAddresses {
     lower: Address;
     higher: Address;
 }
 
 inline fun sortAddresses(a: Address, b: Address): SortedAddresses {
-    if(parseStdAddress(a.asSlice()).address < parseStdAddress(b.asSlice()).address) {
-        return SortedAddresses{lower: a, higher: b};
+    if (parseStdAddress(a.asSlice()).address < parseStdAddress(b.asSlice()).address) {
+        return SortedAddresses { lower: a, higher: b };
     }
-    return SortedAddresses{lower: b, higher: a};
+    return SortedAddresses { lower: b, higher: a };
 }

sources/contracts/vanityContract.tact

@@ -1,12 +1,12 @@
-message initVanityContract {
+message(0xedafb633) InitVanityContract {
     code: Cell;
     data: Cell;
 }
 
 contract VanityContract(
-    codeDataHash: Int as uint256; 
+    codeDataHash: Int as uint256,
 ) {
-    receive(msg: initVanityContract) {
+    receive(msg: InitVanityContract) {
         require(msg.code.hash() ^ msg.data.hash() == self.codeDataHash, "Code or data not matched");
         setCode(msg.code);
         setData(msg.data);

sources/contracts/vaults/jettonVault.tact

@@ -8,7 +8,7 @@ struct JettonMasterState {
     jettonMasterData: Cell?;
 }
 
-// TEP-74 JettonNotify
+// Compatible with TEP-74 JettonNotify, but with forwardPayload serialized as expected fields
 message(0x7362d09c) JettonNotifyWithActionRequest {
     queryId: Int as uint64;
     amount: Int as coins;
@@ -19,7 +19,7 @@ message(0x7362d09c) JettonNotifyWithActionRequest {
     actionPayload: Cell; // Obligatory ref
 }
 
-// TEP-74 JettonTransfer
+// TEP-74 JettonTransfer with better DEX naming
 message(0xf8a7ea5) SendViaJettonTransfer {
     queryId: Int as uint64;
     amount: Int as coins;
@@ -40,6 +40,7 @@ contract JettonVault(
         if (!self.inited) {
             // Theoretically, data can be null, but I think it's not possible, so we won't accept such jettons
             if (msg.init.jettonMasterCode != null && msg.init.jettonMasterData != null) {
+                // on-chain hack, dependent on the jetton minter state init
                 let myJettonWallet = calculateJettonWallet(myAddress(), msg.init.jettonMasterData, msg.init.jettonMasterCode, self.jettonMaster);
 
                 if (myJettonWallet == sender() &&
@@ -67,8 +68,10 @@ contract JettonVault(
 
     receive(msg: PayoutFromPool) {
         require(self.inited, "Jetton vault not inited");
+
         let sortedAddresses = sortAddresses(myAddress(), msg.otherVault);
         let poolInit = initOf AmmPool(sortedAddresses.lower, sortedAddresses.higher, 0, 0, 0);
+
         require(poolInit.hasSameBasechainAddress(sender()), "Sender must be pool");
 
         message(MessageParameters {
@@ -82,6 +85,7 @@ contract JettonVault(
                 destination: msg.receiver,
                 forwardTonAmount: 1,
                 forwardPayload: sliceWithOneZeroBit(),
+                customPayload: null,
             }.toCell(),
         });
     }

sources/contracts/vaults/vaultInterface.tact

@@ -4,6 +4,7 @@ struct SwapRequest {
     // Or we can specify ammPool address here, which I think is better
     destinationVault: Address;
     minAmountOut: Int as uint256;
+    // amountIn is part of the jetton notification
     timeout: Int as uint32;
 }
 

sources/scripts/deploy.ts

@@ -8,7 +8,7 @@ import {JettonVault} from "../output/DEX_JettonVault"
 import {LiquidityDepositContract} from "../output/DEX_LiquidityDepositContract"
 import {ExtendedJettonWallet} from "../wrappers/ExtendedJettonWallet"
 import {storeJettonTransfer} from "../output/Jetton_JettonMinter"
-import {createJettonVaultLiquidityDeposit} from "../utils/testUtils"
+import {createJettonVaultLiquidityDepositPayload} from "../utils/testUtils"
 import {AmmPool} from "../output/DEX_AmmPool"
 
 const main = async () => {
@@ -158,7 +158,7 @@ const main = async () => {
                 responseDestination: deployerWallet.address,
                 customPayload: null,
                 forwardTonAmount: toNano(0.5),
-                forwardPayload: createJettonVaultLiquidityDeposit(
+                forwardPayload: createJettonVaultLiquidityDepositPayload(
                     LPprovider.address,
                     jettonMinterACode!!,
                     jettonMinterAData!!,
@@ -177,7 +177,7 @@ const main = async () => {
                 responseDestination: deployerWallet.address,
                 customPayload: null,
                 forwardTonAmount: toNano(0.5),
-                forwardPayload: createJettonVaultLiquidityDeposit(
+                forwardPayload: createJettonVaultLiquidityDepositPayload(
                     LPprovider.address,
                     jettonMinterBCode!!,
                     jettonMinterBData!!,