@sign-global/tokentable 0.0.4 → 0.0.6

package/src/airdrop/core/ton/v21/wrappers/MerkleTokenDistributor.ts

@@ -0,0 +1,346 @@
+import {
+  Address,
+  beginCell,
+  Builder,
+  Cell,
+  Contract,
+  contractAddress,
+  ContractProvider,
+  Dictionary,
+  Sender,
+  SendMode,
+  Slice,
+  toNano,
+  TupleItem
+} from '@ton/core';
+import { CodeType, dateToUnixTimestamp, intToString, OpCode, stringToInt, unixTimestampToDate } from '../utils';
+
+export type MerkleTokenDistributorConfig = {
+  version: string;
+  adminAddress: Address;
+  root: bigint;
+  deployer: Address;
+  startTime: Date;
+  endTime: Date;
+  leafCode: Cell;
+  claimFee?: bigint;
+  claimFeeAddress?: Address;
+  paused?: boolean;
+  feelessThreshold?: bigint;
+};
+
+export function tokenDistributorConfigToCell(config: MerkleTokenDistributorConfig): Cell {
+  const {
+    version,
+    adminAddress,
+    deployer,
+    endTime,
+    leafCode,
+    root,
+    startTime,
+    claimFee,
+    claimFeeAddress,
+    paused = false,
+    feelessThreshold = 0
+  } = config;
+  let c2 = beginCell()
+    .storeCoins(claimFee ?? 0)
+    .storeUint(claimFeeAddress ? 1 : 0, 1);
+
+  if (claimFeeAddress) {
+    c2 = c2.storeAddress(claimFeeAddress);
+  }
+
+  c2 = c2
+    .storeUint(paused ? 1 : 0, 1)
+    .storeCoins(feelessThreshold)
+    .storeCoins(0);
+
+  const c1 = beginCell()
+    .storeAddress(deployer)
+    .storeUint(dateToUnixTimestamp(startTime), 32)
+    .storeUint(dateToUnixTimestamp(endTime), 32)
+    .storeRef(leafCode)
+    .endCell();
+
+  return beginCell()
+    .storeUint(stringToInt(version), 64)
+    .storeAddress(adminAddress)
+    .storeUint(root, 256)
+    .storeRef(c1)
+    .storeRef(c2.endCell())
+    .endCell();
+}
+
+export type TokenDistributorEntry = {
+  address: Address;
+  claimableAmount: bigint;
+  claimableTimestamp: number;
+};
+
+export const tokenDistributorEntryValue = {
+  serialize: (src: TokenDistributorEntry, buidler: Builder) => {
+    buidler.storeAddress(src.address).storeCoins(src.claimableAmount).storeUint(src.claimableTimestamp, 32);
+  },
+  parse: (src: Slice) => {
+    return {
+      address: src.loadAddress(),
+      claimableAmount: src.loadCoins(),
+      claimableTimestamp: src.loadUint(32)
+    };
+  }
+};
+
+export function generateEntriesDictionary(entries: TokenDistributorEntry[]): Dictionary<bigint, TokenDistributorEntry> {
+  const dict: Dictionary<bigint, TokenDistributorEntry> = Dictionary.empty(
+    Dictionary.Keys.BigUint(64),
+    tokenDistributorEntryValue
+  );
+
+  for (let i = 0; i < entries.length; i++) {
+    dict.set(BigInt(i), entries[i]);
+  }
+
+  return dict;
+}
+
+export class MerkleTokenDistributor implements Contract {
+  constructor(readonly address: Address, readonly init?: { code: Cell; data: Cell }) {}
+
+  static createFromAddress(address: Address) {
+    return new MerkleTokenDistributor(address);
+  }
+
+  static createFromConfig(config: MerkleTokenDistributorConfig, code: Cell, workchain = 0) {
+    const data = tokenDistributorConfigToCell(config);
+    const init = { code, data };
+    return new MerkleTokenDistributor(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 getVersion(provider: ContractProvider): Promise<string> {
+    const result = await provider.get('get_version', []);
+
+    return intToString(Number(result.stack.readBigNumber()));
+  }
+
+  async getLeafAddress(provider: ContractProvider, index: bigint): Promise<Address> {
+    const arg: TupleItem = {
+      value: index,
+      type: 'int'
+    };
+    const result = await provider.get('get_leaf_address', [arg]);
+
+    return result.stack.readAddress();
+  }
+
+  async getRoot(provider: ContractProvider): Promise<bigint> {
+    const result = await provider.get('get_root', []);
+
+    return result.stack.readBigNumber();
+  }
+
+  async getTime(provider: ContractProvider): Promise<[Date, Date] | [null, null]> {
+    const result = await provider.get('get_time', []);
+    const stack = result.stack;
+
+    try {
+      return [unixTimestampToDate(stack.readNumber()), unixTimestampToDate(stack.readNumber())];
+    } catch (e) {
+      return [null, null];
+    }
+  }
+
+  async getAdminAddress(provider: ContractProvider): Promise<Address> {
+    const result = await provider.get('get_admin_address', []);
+
+    return result.stack.readAddress();
+  }
+
+  async getClaimFee(provider: ContractProvider): Promise<bigint> {
+    const result = await provider.get('get_claim_fee', []);
+
+    return result.stack.readBigNumber();
+  }
+
+  async getClaimFeeAddress(provider: ContractProvider): Promise<Address | null> {
+    const result = await provider.get('get_claim_fee_address', []);
+
+    try {
+      return result.stack.readAddress();
+    } catch (e) {
+      return null;
+    }
+  }
+
+  async getPaused(provider: ContractProvider): Promise<boolean> {
+    const result = await provider.get('get_paused', []);
+
+    return result.stack.readNumber() === 1;
+  }
+
+  async getFeelessThreshold(provider: ContractProvider): Promise<bigint> {
+    const result = await provider.get('get_feeless_threshold', []);
+
+    return result.stack.readBigNumber();
+  }
+
+  async getAccumulatedFees(provider: ContractProvider): Promise<bigint> {
+    const result = await provider.get('get_accumulated_fees', []);
+
+    return result.stack.readBigNumber();
+  }
+
+  async getBalance(provider: ContractProvider): Promise<bigint> {
+    const result = await provider.get('get_ton_balance', []);
+
+    return result.stack.readBigNumber();
+  }
+
+  async sendChangeAdmin(provider: ContractProvider, via: Sender, newAdmin: Address) {
+    const messageBody = beginCell().storeUint(OpCode.ChangeAdmin, 32).storeUint(0, 64).storeAddress(newAdmin).endCell();
+    const result = await provider.internal(via, {
+      value: '0.01',
+      body: messageBody
+    });
+
+    return result;
+  }
+
+  async sendChangeCode(provider: ContractProvider, via: Sender, codeType: CodeType, newCode: Cell) {
+    const messageBody = beginCell()
+      .storeUint(OpCode.ChangeCode, 32)
+      .storeUint(0, 64)
+      .storeUint(codeType, 32)
+      .storeRef(newCode)
+      .endCell();
+    const result = await provider.internal(via, {
+      value: '0.01',
+      body: messageBody
+    });
+
+    return result;
+  }
+
+  async sendChangeVersion(provider: ContractProvider, via: Sender, version: string) {
+    const messageBody = beginCell()
+      .storeUint(OpCode.ChangeVersion, 32)
+      .storeUint(0, 64)
+      .storeUint(stringToInt(version), 64)
+      .endCell();
+    const result = await provider.internal(via, {
+      value: '0.01',
+      body: messageBody
+    });
+
+    return result;
+  }
+
+  async sendWithdraw(provider: ContractProvider, via: Sender, amount: string) {
+    const messageBody = beginCell()
+      .storeUint(OpCode.Withdraw, 32)
+      .storeUint(0, 64)
+      .storeCoins(toNano(amount))
+      .endCell();
+    const result = await provider.internal(via, {
+      value: '0.01',
+      body: messageBody
+    });
+
+    return result;
+  }
+
+  async sendWithdrawFees(provider: ContractProvider, via: Sender) {
+    const messageBody = beginCell().storeUint(OpCode.WithdrawFees, 32).storeUint(0, 64).endCell();
+    const result = await provider.internal(via, {
+      value: '0.1',
+      body: messageBody
+    });
+
+    return result;
+  }
+
+  async sendSetBaseParams(provider: ContractProvider, via: Sender, startTime: Date, endTime: Date, root: bigint) {
+    const messageBody = beginCell()
+      .storeUint(OpCode.SetBaseParams, 32)
+      .storeUint(0, 64)
+      .storeUint(dateToUnixTimestamp(startTime), 32)
+      .storeUint(dateToUnixTimestamp(endTime), 32)
+      .storeUint(root, 256)
+      .endCell();
+    const result = await provider.internal(via, {
+      value: '0.01',
+      body: messageBody
+    });
+    return result;
+  }
+
+  async sendSetClaimFee(provider: ContractProvider, via: Sender, claimFee: bigint) {
+    const messageBody = beginCell().storeUint(OpCode.SetClaimFee, 32).storeUint(0, 64).storeCoins(claimFee).endCell();
+    const result = await provider.internal(via, {
+      value: '0.01',
+      body: messageBody
+    });
+
+    return result;
+  }
+
+  async sendSetClaimFeeAddress(provider: ContractProvider, via: Sender, claimFeeAddress: Address) {
+    const messageBody = beginCell()
+      .storeUint(OpCode.SetClaimFeeAddress, 32)
+      .storeUint(0, 64)
+      .storeAddress(claimFeeAddress)
+      .endCell();
+    const result = await provider.internal(via, {
+      value: '0.01',
+      body: messageBody
+    });
+
+    return result;
+  }
+
+  async sendSetPaused(provider: ContractProvider, via: Sender, paused: boolean) {
+    const messageBody = beginCell()
+      .storeUint(OpCode.SetPaused, 32)
+      .storeUint(0, 64)
+      .storeUint(paused ? 1 : 0, 1)
+      .endCell();
+    const result = await provider.internal(via, {
+      value: '0.01',
+      body: messageBody
+    });
+
+    return result;
+  }
+
+  async sendSetFeelessThreshold(provider: ContractProvider, via: Sender, feelessThreshold: bigint) {
+    const messageBody = beginCell()
+      .storeUint(OpCode.SetFeelessThreshold, 32)
+      .storeUint(0, 64)
+      .storeCoins(feelessThreshold)
+      .endCell();
+    const result = await provider.internal(via, {
+      value: '0.01',
+      body: messageBody
+    });
+
+    return result;
+  }
+
+  async sendClearClaimFeeAddress(provider: ContractProvider, via: Sender) {
+    const messageBody = beginCell().storeUint(OpCode.ClearClaimFeeAddress, 32).storeUint(0, 64).endCell();
+    const result = await provider.internal(via, {
+      value: '0.01',
+      body: messageBody
+    });
+
+    return result;
+  }
+}

package/src/airdrop/core/ton/v21/wrappers/index.ts

@@ -0,0 +1,2 @@
+export * from './Leaf';
+export * from './MerkleTokenDistributor';