Magicswap

// getters
public async Task<List<MagicswapPool>> GetAllPools();
public async Task<MagicswapPool> GetPoolById(string id);
public async Task<MagicswapRoute> GetRoute(string tokenInId, string tokenOutId, string amount, bool isExactOut);

// actions
public async Task<Transaction> Swap(SwapBody swapBody);
public async Task<Transaction> AddLiquidity(string poolId, AddLiquidityBody addLiquidityBody);
public async Task<Transaction> RemoveLiquidity(string poolId, RemoveLiquidityBody removeLiquidityBody);

// liquidity helpers
public BigInteger GetQuote(BigInteger amountA, BigInteger reserveA, BigInteger reserveB);
public BigInteger GetAmountMin(BigInteger amount, double slippage);

// allowance helpers
public async Task<BigInteger> GetERC20Allowance(string tokenAddress, string address);
public async Task<bool> IsERC20Approved(string tokenAddress, string address, BigInteger amount);
public async Task<bool> IsERC1155Approved(string tokenAddress, string address);
public async Task<bool> IsERC721Approved(string tokenAddress, string address);

var magicswapRouterAddress = TDK.Common.GetContractAddress(Contract.MagicswapV2Router);
// approving ERC20
var magicAddress = TDK.Common.GetContractAddress(Contract.Magic);
await TDK.Common.ApproveERC20(magicAddress, magicswapRouterAddress, amount);
await TDK.Common.ApproveERC20(poolData.id, magicswapRouterAddress, amount);
// approving ERC1155
await TDK.Common.ApproveERC1155(/* ERC1155 token address */, magicswapRouterAddress);

using Treasure;

// fetch any necessary pool data, including token ids for nfts
var poolData = await TDK.Magicswap.GetPoolById(/* your pool id */);

// calculate swap route by specifying the types of tokens to swap and the desired output amount
var routeData = await TDK.Magicswap.GetRoute(
    tokenInId: poolData.token0.id, // token you want to swap from
    tokenOutId: poolData.token1.id, // token you want to swap to
    amount: "1", // amount of tokens you are swapping or receiving
    isExactOut: true // true if you want to receive `amount` tokens (see below)
);

// let's say the user picked the first one from the list as output
var userSelectedNFTsOutput = new List<NFTInput> {
    new() {
        id = routeData.tokenOut.collectionTokenIds[0],
        quantity = 1,
    }
};

// use route data and user selection to build the body
var swapBody = new SwapBody {
    tokenInId = routeData.tokenIn.id,
    tokenOutId = routeData.tokenOut.id,
    path = routeData.path,
    amountIn = routeData.amountIn,
    nftsOut = userSelectedNFTsOutput,
    isExactOut = true
};
// send request to perform swap (ERC20 to NFT swap in this example)
var transaction = await TDK.Magicswap.Swap(swapBody);

// check the result
var success = transaction.status == "mined";

var poolData = await TDK.Magicswap.GetPoolById(/* your pool id */);
// for tokenA we should know the amount we want to add (amountA = 1 in this case)
// for tokenB we can calculate amountB based on amountA and the pool reserves
var tokenA = poolData.token1;
var tokenB = poolData.token0;
var amountA = new BigInteger(1);
var reserveA = BigInteger.Parse(tokenA.reserve);
var reserveB = BigInteger.Parse(tokenB.reserve);
var amountB = TDK.Magicswap.GetQuote(
    amountA.AdjustDecimals(0, tokenA.decimals),
    reserveA,
    reserveB
);

var addLiquidityBody = new AddLiquidityBody {
    amount0 = amountB.ToString(),
    amount0Min = TDK.Magicswap.GetAmountMin(amountB, 0.01).ToString(),
    nfts1 = new List<NFTInput>() {
        new() {
            id = tokenA.collectionTokenIds[0],
            quantity = (int)amountA,
        }
    }
};

// send request to add liquidity (ERC20⇔NFT pool in this example)
var transaction = await TDK.Magicswap.AddLiquidity(poolData.id, addLiquidityBody);

// check the result
var success = transaction.status == "mined";

var poolData = await TDK.Magicswap.GetPoolById(/* your pool id */);

var reserve0 = BigInteger.Parse(poolData.token0.reserve);
var reserve1 = BigInteger.Parse(poolData.token1.reserve);
var totalSupply = BigInteger.Parse(poolData.totalSupply);

var nftsDesired = new BigInteger(1).AdjustDecimals(0, poolData.token1.decimals);
// calculate LP amount to get the desired amount of nfts (1 in this example).
// the LP amount could otherwise be inputted by the user.
var amountLPWei = BigInteger.DivRem(nftsDesired * totalSupply, reserve1, out BigInteger reminder);
if (reminder > 0) amountLPWei += 1;

var amount0 = amountLPWei * reserve0 / totalSupply;
var amount1 = amountLPWei * reserve1 / totalSupply; // should be 1 nft from our LP calculation

// floor amount1 since token1 is nft
var amount1FlooredNoDecimals = amount1.AdjustDecimals(poolData.token1.decimals, 0);

// use helper to account for slippage for amount0 since its an ERC20 token
var amount0Min = TDK.Magicswap.GetAmountMin(amount0, 0.01);
// dont use helper for amount1 since its NFT, use floored value with decimals instead
var amount1Min = amount1FlooredNoDecimals.AdjustDecimals(0, poolData.token1.decimals);

var removeLiquidityBody = new RemoveLiquidityBody {
    amountLP = amountLPWei.ToString(),
    amount0Min = amount0Min.ToString(),
    amount1Min = amount1Min.ToString(),
    nfts1 = new List<NFTInput>() {
        new() {
            id = poolData.token1.collectionTokenIds[0],
            quantity = (int)amount1FlooredNoDecimals,
        }
    }
};
// send request to remove liquidity (ERC20⇔NFT pool in this example)
var transaction = await TDK.Magicswap.RemoveLiquidity(poolData.id, removeLiquidityBody);

// check the result
var success = transaction.status == "mined";

// setup
var poolData = await TDK.Magicswap.GetPoolById(/* your pool id */);
var tokenAddress = TDK.Common.GetContractAddress(poolData.token0.id); // or poolData.token1.id or poolData.id

// getting token balance (ERC20)
var tokenBalance = await TDK.Common.GetFormattedERC20Balance(tokenAddress, TDK.Identity.Address, 18);
Debug.Log($"Balance: {tokenBalance}");

// getting token allowance (ERC20)
var tokenAllowance = await TDK.Magicswap.GetERC20Allowance(tokenAddress, TDK.Identity.Address);
Debug.Log($"Allowance: {Thirdweb.Utils.ToEth(tokenAllowance.ToString())}");

// getting token approval (ERC1155)
var tokenIsApproved = await TDK.Magicswap.IsERC1155Approved(tokenAddress, TDK.Identity.Address);
Debug.Log(tokenIsApproved ? "Token is approved" : "Token is not approved");