@evaafi/sdk 0.6.2-c → 0.6.3-a

package/src/rewards/JettonMinter.ts

@@ -0,0 +1,113 @@
+import { Address, beginCell, Cell, Contract, contractAddress, ContractProvider, Sender, SendMode } from '@ton/ton';
+import { OPCODES } from '../constants/general';
+
+export type JettonMinterConfig = {
+    address: Address;
+    content: Cell;
+    walletCode: Cell;
+};
+
+export type MintMessage = {
+    address: Address;
+    forwardValue: bigint;
+    amount: bigint;
+};
+
+export class JettonMinter implements Contract {
+    constructor(
+        readonly address: Address,
+        readonly init?: { code: Cell; data: Cell },
+    ) {}
+
+    static createFromAddress(address: Address) {
+        return new JettonMinter(address);
+    }
+
+    static jettonMinterConfigToCell(config: JettonMinterConfig): Cell {
+        return beginCell()
+            .storeCoins(0)
+            .storeAddress(config.address)
+            .storeRef(config.content)
+            .storeRef(config.walletCode)
+            .endCell();
+    }
+
+    static createFromConfig(config: JettonMinterConfig, code: Cell, workchain = 0) {
+        const data = this.jettonMinterConfigToCell(config);
+        const init = { code, data };
+        return new JettonMinter(contractAddress(workchain, init), init);
+    }
+
+    async sendDeploy(provider: ContractProvider, via: Sender, value: bigint) {
+        await provider.internal(via, {
+            value,
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: beginCell().endCell(),
+        });
+    }
+
+    sendMintMessage(payload: MintMessage) {
+        return beginCell()
+            .storeUint(21, 32)
+            .storeUint(0, 64)
+            .storeAddress(payload.address)
+            .storeCoins(payload.forwardValue)
+            .storeRef(
+                beginCell()
+                    .storeUint(OPCODES.REWARD_JETTON_MINT, 32)
+                    .storeUint(0, 64)
+                    .storeCoins(payload.amount)
+                    .storeAddress(this.address)
+                    .storeAddress(this.address)
+                    .storeCoins(0)
+                    .storeUint(0, 1)
+                    .endCell(),
+            )
+            .endCell();
+    }
+
+    async sendMint(
+        provider: ContractProvider,
+        via: Sender,
+        value: bigint,
+        forwardValue: bigint,
+        recipient: Address,
+        amount: bigint,
+    ) {
+        await provider.internal(via, {
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: beginCell()
+                .storeUint(21, 32)
+                .storeUint(0, 64)
+                .storeAddress(recipient)
+                .storeCoins(forwardValue)
+                .storeRef(
+                    beginCell()
+                        .storeUint(OPCODES.REWARD_JETTON_MINT, 32)
+                        .storeUint(0, 64)
+                        .storeCoins(amount)
+                        .storeAddress(this.address)
+                        .storeAddress(this.address)
+                        .storeCoins(0)
+                        .storeUint(0, 1)
+                        .endCell(),
+                )
+                .endCell(),
+            value: value + forwardValue,
+        });
+    }
+
+    async getWalletAddressOf(provider: ContractProvider, address: Address) {
+        return (
+            await provider.get('get_wallet_address', [
+                { type: 'slice', cell: beginCell().storeAddress(address).endCell() },
+            ])
+        ).stack.readAddress();
+    }
+
+    async getWalletCode(provider: ContractProvider) {
+        let stack = (await provider.get('get_jetton_data', [])).stack;
+        stack.skip(4);
+        return stack.readCell();
+    }
+}

package/src/rewards/JettonWallet.ts

@@ -0,0 +1,77 @@
+import { Address, beginCell, Cell, Contract, contractAddress, ContractProvider, Sender, SendMode } from '@ton/ton';
+import { OPCODES } from '../constants/general';
+
+export type JettonWalletConfig = {
+    owner: Address;
+    minter: Address;
+    walletCode: Cell;
+};
+
+export class JettonWallet implements Contract {
+    constructor(
+        readonly address: Address,
+        readonly init?: { code: Cell; data: Cell },
+    ) {}
+
+    static createFromAddress(address: Address) {
+        return new JettonWallet(address);
+    }
+
+    static jettonWalletConfigToCell(config: JettonWalletConfig): Cell {
+        return beginCell()
+            .storeCoins(0) // baseTrackingAccured always is 0, check smartcontract
+            .storeAddress(config.owner)
+            .storeAddress(config.minter)
+            .storeRef(config.walletCode)
+            .endCell();
+    }
+
+    static createFromConfig(config: JettonWalletConfig, code: Cell, workchain = 0) {
+        const data = this.jettonWalletConfigToCell(config);
+        const init = { code, data };
+        return new JettonWallet(contractAddress(workchain, init), init);
+    }
+
+    async sendDeploy(provider: ContractProvider, via: Sender, value: bigint) {
+        await provider.internal(via, {
+            value,
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: beginCell().endCell(),
+        });
+    }
+
+    async sendTransfer(
+        provider: ContractProvider,
+        via: Sender,
+        value: bigint,
+        forwardValue: bigint,
+        recipient: Address,
+        amount: bigint,
+        forwardPayload: Cell,
+    ) {
+        await provider.internal(via, {
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: beginCell()
+                .storeUint(OPCODES.REWARD_JETTON_TRANSFER, 32)
+                .storeUint(0, 64)
+                .storeCoins(amount)
+                .storeAddress(recipient)
+                .storeAddress(via.address)
+                .storeUint(0, 1)
+                .storeCoins(forwardValue)
+                .storeUint(1, 1)
+                .storeRef(forwardPayload)
+                .endCell(),
+            value: value + forwardValue,
+        });
+    }
+
+    async getJettonBalance(provider: ContractProvider) {
+        let state = await provider.getState();
+        if (state.state.type !== 'active') {
+            return 0n;
+        }
+        let res = await provider.get('get_wallet_data', []);
+        return res.stack.readBigNumber();
+    }
+}

package/src/rewards/RewardMaster.ts

@@ -0,0 +1,110 @@
+import {
+    Address,
+    beginCell,
+    Cell,
+    Contract,
+    contractAddress,
+    ContractProvider,
+    fromNano,
+    Sender,
+    SendMode,
+    StateInit,
+    toNano,
+} from '@ton/ton';
+import { Maybe } from '@ton/ton/dist/utils/maybe';
+import { FEES, OPCODES } from '../constants/general';
+import { EvaaRewardsConfig } from '../types/MasterRewards';
+import { bigIntToBuffer } from '../utils/sha256BigInt';
+
+export class RewardMaster implements Contract {
+    constructor(
+        readonly address: Address,
+        readonly init?: Maybe<StateInit>,
+    ) {}
+
+    static createFromAddress(address: Address) {
+        return new RewardMaster(address);
+    }
+
+    static rewardMasterConfigToCell(config: EvaaRewardsConfig): Cell {
+        return beginCell()
+            .storeAddress(config.adminAddress)
+            .storeCoins(config.availableReward)
+            .storeAddress(null) // The addres null for TON
+            .storeRef(config.rewardUserCode)
+            .storeRef(
+                beginCell()
+                    .storeAddress(config.evaaMasterAddress)
+                    .storeBuffer(bigIntToBuffer(config.asset.assetId), 256 / 8)
+                    .storeBuffer(config.publicKey, 256 / 8)
+                    .endCell(),
+            )
+            .endCell();
+    }
+
+    static createFromConfig(config: EvaaRewardsConfig, workchain = 0) {
+        const data = this.rewardMasterConfigToCell(config);
+        const init = { code: config.rewardMasterCode, data };
+        return new RewardMaster(contractAddress(workchain, init), init);
+    }
+
+    async sendDeploy(provider: ContractProvider, via: Sender, rewardTokenJettonWalletAddress: Address | null) {
+        await provider.internal(via, {
+            value: FEES.REWARD_MASTER_DEPLOY,
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: beginCell().storeUint(1, 32).storeUint(0, 64).storeAddress(rewardTokenJettonWalletAddress).endCell(),
+        });
+    }
+
+    async sendTonTopUp(provider: ContractProvider, via: Sender, topUpRewardAmount: number) {
+        await provider.internal(via, {
+            value: toNano(topUpRewardAmount) + FEES.REWARD_MASTER_TON_TOP_UP,
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: beginCell().storeUint(OPCODES.REWARD_TON_TOP_UP, 32).storeUint(0, 64).endCell(),
+        });
+    }
+
+    private adminWithdrawMessage(destinationAddress: Address, jettonAmount: number) {
+        return beginCell()
+            .storeUint(4, 32)
+            .storeUint(0, 64)
+            .storeAddress(destinationAddress)
+            .storeCoins(toNano(jettonAmount))
+            .endCell();
+    }
+
+    async sendAdminWithdraw(
+        provider: ContractProvider,
+        via: Sender,
+        destinationAddress: Address,
+        jettonAmount: number,
+    ) {
+        await provider.internal(via, {
+            value: FEES.REWARD_MASTER_WITHDRAW,
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: this.adminWithdrawMessage(destinationAddress, jettonAmount),
+        });
+    }
+
+    async getData(provider: ContractProvider) {
+        const result = await provider.get('load_data', []);
+        const data = {
+            // TODO: maybe it will be typed
+            adminAddress: result.stack.readAddress(),
+            availableReward: Number(fromNano(result.stack.readBigNumber())),
+            rewardUserCode: result.stack.readCell(),
+            evaaMasterAddress: result.stack.readAddress(),
+            rewardTokenJettonWalletAddress: result.stack.readAddressOpt(),
+            assetId: Buffer.from(result.stack.readBigNumber().toString(16), 'hex'),
+            publicKey: Buffer.from(result.stack.readBigNumber().toString(16), 'hex'),
+        };
+        return data;
+    }
+
+    async getRewardUserAddress(provider: ContractProvider, userAddress: Address): Promise<Address> {
+        const result = await provider.get('calculate_reward_user_address', [
+            { type: 'slice', cell: beginCell().storeAddress(userAddress).endCell() },
+        ]);
+        return result.stack.readAddress();
+    }
+}

package/src/rewards/RewardUser.ts

@@ -0,0 +1,90 @@
+import { sign } from '@ton/crypto';
+import {
+    Address,
+    beginCell,
+    Cell,
+    Contract,
+    contractAddress,
+    ContractProvider,
+    fromNano,
+    Sender,
+    SendMode,
+    StateInit,
+} from '@ton/ton';
+import { Maybe } from '@ton/ton/dist/utils/maybe';
+import { FEES, OPCODES } from '../constants/general';
+import { EvaaUserRewardsConfig } from '../types/UserRewards';
+import { bigIntToBuffer } from '../utils/sha256BigInt';
+
+export class RewardUser implements Contract {
+    constructor(
+        readonly address: Address,
+        readonly init?: Maybe<StateInit>,
+    ) {}
+
+    static createFromAddress(address: Address) {
+        return new RewardUser(address);
+    }
+
+    static rewardUserConfigToCell(config: EvaaUserRewardsConfig): Cell {
+        return beginCell()
+            .storeAddress(config.userAddress)
+            .storeCoins(0)
+            .storeRef(
+                beginCell()
+                    .storeAddress(config.rewardMasterAddress)
+                    .storeBuffer(bigIntToBuffer(config.asset.assetId), 256 / 8)
+                    .storeBuffer(config.publicKey, 256 / 8)
+                    .endCell(),
+            )
+            .endCell();
+    }
+
+    static createFromConfig(config: EvaaUserRewardsConfig, workchain = 0) {
+        const data = this.rewardUserConfigToCell(config);
+        const init = { code: config.rewardUserCode, data };
+        return new RewardUser(contractAddress(workchain, init), init);
+    }
+
+    async sendDeploy(provider: ContractProvider, via: Sender) {
+        await provider.internal(via, {
+            value: FEES.REWARD_MASTER_DEPLOY,
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: beginCell().endCell(),
+        });
+    }
+
+    claimMessageToCell(claimAmount: bigint): Cell {
+        return beginCell().storeAddress(this.address).storeCoins(claimAmount).endCell();
+    }
+
+    signClaimMessage(claimBody: Cell, privateKey: Buffer): Cell {
+        return beginCell()
+            .storeUint(OPCODES.REWARD_CLAIM, 32)
+            .storeUint(0, 64)
+            .storeBuffer(sign(claimBody.hash(), privateKey))
+            .storeRef(claimBody)
+            .endCell();
+    }
+
+    async sendClaim(provider: ContractProvider, via: Sender, signedClaimMessage: Cell) {
+        await provider.internal(via, {
+            value: FEES.REWARD_USER_CLAIM,
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: signedClaimMessage,
+        });
+    }
+
+    async getData(provider: ContractProvider) {
+        const result = await provider.get('load_data', []);
+        // TODO: maybe it will be typed
+        const data = {
+            userAddress: result.stack.readAddress(),
+            baseTrackingAccrued: Number(fromNano(result.stack.readBigNumber())),
+            rewardMasterAddress: result.stack.readAddress(),
+            assetId: Buffer.from(result.stack.readBigNumber().toString(16), 'hex'),
+            publicKey: Buffer.from(result.stack.readBigNumber().toString(16), 'hex'),
+        };
+        return data;
+    }
+}

package/src/types/Master.ts

@@ -1,4 +1,4 @@
-import { Address, Cell, Dictionary } from '@ton/core';
+import { Address, Cell, Dictionary } from '@ton/core'
 
 export type MasterConstants = {
     FACTOR_SCALE: bigint,

package/src/types/MasterRewards.ts

@@ -0,0 +1,13 @@
+import { Address, Cell } from '@ton/ton';
+import { PoolAssetConfig } from './Master';
+
+export type EvaaRewardsConfig = {
+    workchain?: number;
+    adminAddress: Address;
+    evaaMasterAddress: Address;
+    availableReward: number;
+    asset: PoolAssetConfig;
+    rewardMasterCode: Cell;
+    rewardUserCode: Cell;
+    publicKey: Buffer;
+};

package/src/types/UserRewards.ts

@@ -0,0 +1,10 @@
+import { Address, Cell } from '@ton/ton';
+import { PoolAssetConfig } from './Master';
+
+export type EvaaUserRewardsConfig = {
+    userAddress: Address;
+    rewardUserCode: Cell;
+    rewardMasterAddress: Address;
+    asset: PoolAssetConfig;
+    publicKey: Buffer;
+};

package/src/utils/sha256BigInt.ts

@@ -5,3 +5,11 @@ export function sha256Hash(input: string): bigint {
     const hashHex = hash.toString();
     return BigInt('0x' + hashHex);
 }
+
+export function bigIntToBuffer(value: bigint): Buffer {
+    let hex = value.toString(16);
+    if (hex.length % 2) {
+        hex = '0' + hex;
+    }
+    return Buffer.from(hex, 'hex');
+}

package/src/utils/userJettonWallet.ts

@@ -4,39 +4,45 @@ import { UNDEFINED_ASSET } from '../constants/assets';
 
 function getUserJettonData(ownerAddress: Address, assetName: string, jettonWalletCode: Cell, jettonMasterAddress: Address) {
   switch (assetName) {
-    case 'uTON':    
-      return beginCell()
-        .storeCoins(0)
-        .storeUint(0, 64)
-        .storeAddress(ownerAddress)
-        .storeAddress(jettonMasterAddress)
-        .storeRef(jettonWalletCode)
-        .endCell();
-    case 'DOGS':
-    case 'NOT':
-    case 'USDT':
-      return beginCell()
-        .storeUint(0, 4)
-        .storeCoins(0)
-        .storeAddress(ownerAddress)
-        .storeAddress(jettonMasterAddress)
-        .endCell();
-    case 'tsTON':
-        return beginCell()
-          .storeCoins(0)
-          .storeAddress(ownerAddress)
-          .storeAddress(jettonMasterAddress)
-          .storeRef(jettonWalletCode)
-          .storeCoins(0)
-          .storeUint(0, 48)
-          .endCell();
-    default:
-      return beginCell().storeCoins(0)
-        .storeAddress(ownerAddress)
-        .storeAddress(jettonMasterAddress)
-        .storeRef(jettonWalletCode)
-        .endCell();
-
+      case 'uTON':
+          return beginCell()
+              .storeCoins(0)
+              .storeUint(0, 64)
+              .storeAddress(ownerAddress)
+              .storeAddress(jettonMasterAddress)
+              .storeRef(jettonWalletCode)
+              .endCell();
+      case 'DOGS':
+      case 'NOT':
+      case 'USDT':
+          return beginCell()
+              .storeUint(0, 4)
+              .storeCoins(0)
+              .storeAddress(ownerAddress)
+              .storeAddress(jettonMasterAddress)
+              .endCell();
+      case 'tsTON':
+          return beginCell()
+              .storeCoins(0)
+              .storeAddress(ownerAddress)
+              .storeAddress(jettonMasterAddress)
+              .storeRef(jettonWalletCode)
+              .storeCoins(0)
+              .storeUint(0, 48)
+              .endCell();
+      case 'tgBTC':
+          return beginCell()
+              .storeUint(0, 4)
+              .storeCoins(0)
+              .storeAddress(ownerAddress)
+              .storeAddress(jettonMasterAddress)
+              .endCell();
+      default:
+          return beginCell().storeCoins(0)
+              .storeAddress(ownerAddress)
+              .storeAddress(jettonMasterAddress)
+              .storeRef(jettonWalletCode)
+              .endCell();
   }
 }
 export function getUserJettonWallet(ownerAddress: Address, poolAssetConfig: PoolAssetConfig) {