dustn

DUSTN

A high level smart contract language based with solidity-like syntax for TON Chain

Dustn compiles to Func 4x smaller bytecode vs Tact

• Inspired by Tact Language

Join

• Dustin Telegram Group
• For contributors, testers and devs, message Web3Mikey

Why?

• We want a developer friendly smart contract
• We want a shorter and optimized code
• We want a smaller bytecode on compilation
• We want a language that writes on both func, fift and base64

Initialize Your Project

npx dustn init

Create a Dustin Smart Contract

npx dustn create ContractName

Compiles the contract

npx dustn compile ContractName

Reference

Data Type	Func Type
address	slice
cell	cell
string	cell
uint256	int
uint128	int
uint64	int
uint32	int
uint16	int
uint8	int
uint1	int
bool	int

• TON Func Reference
• Examples

Create receiver methods on the fly with operation codes for internal functions

  /// Adds const op::mint = "op::mint"c; in the header
  function mint(address sender, address toAddress, uint256 amount) internal {}

  /// Adds int op::mint() asm "0x12345 PUSHINT";
  function mint_12345(address sender, address toAddress, uint256 amount) internal {}

  Automatically generates the crc32c Method HEX ID
  /// Adds int op::mint() asm "0xe4a55bbc PUSHINT";
  function mint_asm(address sender, address toAddress, uint256 amount) internal {}

Features

• Dynamically creates save_data and load_data
• Internal functions as operations
• Optimized getter functions via external
• Extract and fill function parameters from message body
• Instantly generates the opcodes
• Instantly generates operation via internal functions
• Ability to reuse internal functions
• Added support for dictionaries or hashmap

Simple Counter

contract Counter {
  uint32 id;
  uint32 counter;

  function increment_asm(uint32 increasedBy) internal {
    counter += increasedBy;
    id += 1;
  }

  function getCounter() public returns(uint32) {
    return counter;
  }

  function getID() public returns(uint32) {
    return id;
  }
}

To Func

int op::increment() asm "0xe4a55bbc PUSHINT";
       
slice verify_address(slice address) inline {
  throw_unless(136, address.slice_bits() == 267);
  var h = address.preload_uint(11);
  throw_if(137, h == 1279);
  throw_unless(136, h == 1024);
  return address;
}

_ load_data() inline {
  var ds = get_data().begin_parse();
  return (
    ds~load_uint(32),
    ds~load_uint(32)
     
  );
}

() save_data(int $id, int $counter) impure inline {
  set_data(
    begin_cell()
      .store_uint($id, 32)
      .store_uint($counter, 32)
             
      .end_cell()  
  );
}

() internal_increment(int $increasedBy) impure {
  
  (int $id, int $counter) = load_data();
  $counter += $increasedBy;
  $id += 1;
  save_data($id, $counter);
}
    

() recv_internal(int $msgBalance, int $msgValue, cell in_msg_full, slice in_msg_body) impure {
  if (in_msg_body.slice_empty?()) { ;; ignore all empty messages
    return ();
  }

  var cs = in_msg_full.begin_parse();
  var msg_flags = cs~load_uint(4);
  var $bounced = -(msg_flags & 1);
  slice $sender = verify_address(cs~load_msg_addr());

  if ($bounced) {
    return ();
  }

  int $op = in_msg_body~load_uint(32);
  int $queryId = in_msg_body~load_uint(64);
  
  if ($op == op::increment()) {
     
    int $increasedBy = in_msg_body~load_uint(32);
    internal_increment($increasedBy);
    return ();
  }
      
  throw(0xffff);

}

(int) get_counter() method_id {
  
  (_, int $counter) = load_data();
  return $counter;
}

(int) get_id() method_id {
  
  (int $id, _) = load_data();
  return $id;
}

To Base64 Code

te6ccgEBCAEAgAABFP8A9KQT9LzyyAsBAgFiAgMCAs0EBQIBbgYHAFnTYREGOASK3wAOhpgZg42FHImHBpj+mfmMEIclKt3gldSumPmHgCcBhCB/l4QALddqJoaY/pj5gsUADSAIDkZY/lj+T2qkABe1Rz2omhpj+mPmBhAAF7Y//aiaGmP6Y+YGMA==

Bytecode Size: 0.000139 MB

Handcrafted in by Xircus