Wrote deployment and stuff

build/cli.js

@@ -0,0 +1,32 @@
+const main = require('../contracts/main');
+const subcommand = require('subcommand');
+const {Address, SendMode, InternalMessage, CommonMessageInfo, StateInit, CellMessage} = require("ton");
+const {getWallet} = require("../contracts/main");
+const {sendInternalMessageWithWallet} = require("../contracts/utils");
+
+
+const argv = process.argv.slice(2);
+let commands = [
+    {
+        name: 'deposit',
+        options: [
+            {
+                name: 'minter',
+                help: 'The jetton address'
+            },
+            {
+                name: 'amount',
+            }
+        ],
+        command: async function deposit(args) {
+            let [walletContract, walletKey] = await getWallet();
+            await sendInternalMessageWithWallet({
+                walletContract, secretKey: walletKey.secretKey, value: (parseFloat(args._[1]) + 0.2) * main.TON(), to: Address.parse(args._[0]),
+                body: main.depositMsg((parseFloat(args._[1]) * main.TON()))
+            })
+        }
+    }
+]
+
+let match = subcommand(commands);
+let opts = match(argv);

build/jetton-wallet.deploy.ts

@@ -1,31 +1,27 @@
 import * as main from "../contracts/main";
-import { Address, toNano, TupleSlice, WalletContract } from "ton";
+import {Address, Cell, toNano, TupleSlice, WalletContract} from "ton";
+import { hex as jettonWalletCodeCell } from "../build/jetton-wallet.compiled.json";
+import { hex as minterCode } from "../build/minter.compiled.json";
 import { sendInternalMessageWithWallet } from "../test/helpers";
+import {minterParams} from "./minter.deploy";
 
 // return the init Cell of the contract storage (according to load_data() contract method)
 export function initData() {
-  return main.data({
+  let ownerAddress = Address.parse("EQD7zbEMaWC2yMgSJXmIF7HbLr1yuBo2GnZF_CJNkUiGSe32");
-    ownerAddress: Address.parseFriendly("EQCD39VS5jcptHL8vMjEXrzGaRcCVYto7HUn4bpAOg8xqB2N").address,
+  let minterAddress = main.getMinterAddress(minterParams(), Cell.fromBoc(minterCode)[0]);
-    counter: 10,
+  return main.walletData({
+    balance: 0,
+    ownerAddress,
+    jettonMasterAddress: minterAddress,
+    jettonWalletCode: Cell.fromBoc(jettonWalletCodeCell)[0],
   });
 }
 
-// return the op that should be sent to the contract on deployment, can be "null" to send an empty message
 export function initMessage() {
-  return main.increment();
+  return null;
 }
 
 // optional end-to-end sanity test for the actual on-chain contract to see it is actually working on-chain
 export async function postDeployTest(walletContract: WalletContract, secretKey: Buffer, contractAddress: Address) {
-  const call = await walletContract.client.callGetMethod(contractAddress, "counter");
-  const counter = new TupleSlice(call.stack).readBigNumber();
-  console.log(`   # Getter 'counter' = ${counter.toString()}`);
 
-  const message = main.increment();
-  await sendInternalMessageWithWallet({ walletContract, secretKey, to: contractAddress, value: toNano(0.02), body: message });
-  console.log(`   # Sent 'increment' op message`);
-
-  const call2 = await walletContract.client.callGetMethod(contractAddress, "counter");
-  const counter2 = new TupleSlice(call2.stack).readBigNumber();
-  console.log(`   # Getter 'counter' = ${counter2.toString()}`);
 }

build/main.deploy.ts

@@ -1,31 +0,0 @@
-import * as main from "../contracts/main";
-import { Address, toNano, TupleSlice, WalletContract } from "ton";
-import { sendInternalMessageWithWallet } from "../test/helpers";
-
-// return the init Cell of the contract storage (according to load_data() contract method)
-export function initData() {
-  return main.data({
-    ownerAddress: Address.parseFriendly("EQCD39VS5jcptHL8vMjEXrzGaRcCVYto7HUn4bpAOg8xqB2N").address,
-    counter: 10,
-  });
-}
-
-// return the op that should be sent to the contract on deployment, can be "null" to send an empty message
-export function initMessage() {
-  return main.increment();
-}
-
-// optional end-to-end sanity test for the actual on-chain contract to see it is actually working on-chain
-export async function postDeployTest(walletContract: WalletContract, secretKey: Buffer, contractAddress: Address) {
-  const call = await walletContract.client.callGetMethod(contractAddress, "counter");
-  const counter = new TupleSlice(call.stack).readBigNumber();
-  console.log(`   # Getter 'counter' = ${counter.toString()}`);
-
-  const message = main.increment();
-  await sendInternalMessageWithWallet({ walletContract, secretKey, to: contractAddress, value: toNano(0.02), body: message });
-  console.log(`   # Sent 'increment' op message`);
-
-  const call2 = await walletContract.client.callGetMethod(contractAddress, "counter");
-  const counter2 = new TupleSlice(call2.stack).readBigNumber();
-  console.log(`   # Getter 'counter' = ${counter2.toString()}`);
-}

build/minter.deploy.ts

@@ -1,31 +1,23 @@
 import * as main from "../contracts/main";
-import { Address, toNano, TupleSlice, WalletContract } from "ton";
+import {Address, beginCell, Cell, toNano, TupleSlice, WalletContract} from "ton";
 import { sendInternalMessageWithWallet } from "../test/helpers";
+import { hex as walletCode } from "../build/jetton-wallet.compiled.json";
+import {encodeOffChainContent} from "../contracts/main";
 
-// return the init Cell of the contract storage (according to load_data() contract method)
+export function minterParams() {
-export function initData() {
+  return {
-  return main.data({
+    adminAddress: Address.parse("EQD7zbEMaWC2yMgSJXmIF7HbLr1yuBo2GnZF_CJNkUiGSe32"),
-    ownerAddress: Address.parseFriendly("EQCD39VS5jcptHL8vMjEXrzGaRcCVYto7HUn4bpAOg8xqB2N").address,
+    supply: 0,
-    counter: 10,
+    content: encodeOffChainContent(""),
-  });
+    wallet_code: Cell.fromBoc(walletCode)[0],
+  };
 }
 
-// return the op that should be sent to the contract on deployment, can be "null" to send an empty message
 export function initMessage() {
-  return main.increment();
+  return null;
 }
 
-// optional end-to-end sanity test for the actual on-chain contract to see it is actually working on-chain
+// return the init Cell of the contract storage (according to load_data() contract method)
-export async function postDeployTest(walletContract: WalletContract, secretKey: Buffer, contractAddress: Address) {
+export function initData() {
-  const call = await walletContract.client.callGetMethod(contractAddress, "counter");
+  return main.minterData(minterParams());
-  const counter = new TupleSlice(call.stack).readBigNumber();
-  console.log(`   # Getter 'counter' = ${counter.toString()}`);
-
-  const message = main.increment();
-  await sendInternalMessageWithWallet({ walletContract, secretKey, to: contractAddress, value: toNano(0.02), body: message });
-  console.log(`   # Sent 'increment' op message`);
-
-  const call2 = await walletContract.client.callGetMethod(contractAddress, "counter");
-  const counter2 = new TupleSlice(call2.stack).readBigNumber();
-  console.log(`   # Getter 'counter' = ${counter2.toString()}`);
 }

contracts/main.fc

@@ -1,104 +0,0 @@
-#pragma version >=0.2.0;
-
-#include "imports/stdlib.fc";
-#include "imports/constants.fc";
-#include "imports/utils.fc";
-
-;; =============== storage =============================
-
-;; storage binary format is defined as TL-B in companion .tlb file
-
-(slice, int) load_data() inline {
-  var ds = get_data().begin_parse();
-  return (
-    ds~load_msg_addr(), ;; owner_address
-    ds~load_uint(64)    ;; counter
-  );
-}
-
-() save_data(slice owner_address, int counter) impure inline {
-  set_data(begin_cell()
-    .store_slice(owner_address)
-    .store_uint(counter, 64)
-    .end_cell());
-}
-
-;; =============== messages =============================
-
-;; message binary format is defined as TL-B in companion .tlb file
-
-() op_withdraw(int withdraw_amount, slice owner_address) impure;
-
-() recv_internal(int msg_value, cell in_msg, slice in_msg_body) impure {
-  ;; parse incoming internal message
-  slice cs = in_msg.begin_parse();
-  int flags = cs~load_uint(4); ;; int_msg_info$0 ihr_disabled:Bool bounce:Bool bounced:Bool
-  slice sender_address = cs~load_msg_addr();
-
-  ;; handle bounced messages
-  if (flags & 1) {
-    return (); ;; ignore
-  }
-
-  ;; load from contract storage
-  var (owner_address, counter) = load_data();
-
-  ;; handle operations
-  int op = in_msg_body~load_uint(32);
-  int query_id = in_msg_body~load_uint(64);
-  
-  if (op == op::increment) {
-    save_data(owner_address, counter + 1);
-    return ();
-  }
-
-  if (op == op::deposit) {
-    ;; empty since ton received (msg_value) is added automatically to contract balance
-    ;; ~dump msg_value; ;; an example of debug output, requires running contract in debug mode
-    return ();
-  }
-  
-  if (op == op::withdraw) {
-    throw_unless(error::access_denied, equal_slices(sender_address, owner_address));
-    int withdraw_amount = in_msg_body~load_coins();
-    op_withdraw(withdraw_amount, owner_address);
-    return ();
-  }
-
-  if (op == op::transfer_ownership) {
-    throw_unless(error::access_denied, equal_slices(sender_address, owner_address));
-    slice new_owner_address = in_msg_body~load_msg_addr();
-    save_data(new_owner_address, counter);
-    return ();
-  }
-
-  throw(error::unknown_op);
-}
-
-() op_withdraw(int withdraw_amount, slice owner_address) impure {
-  var [balance, _] = get_balance();
-  throw_unless(error::insufficient_balance, balance >= withdraw_amount);
-  int return_value = min(withdraw_amount, balance - const::min_tons_for_storage);
-  send_grams(owner_address, return_value);
-}
-
-;; =============== getters =============================
-
-int meaning_of_life() method_id {
-  return 42;
-}
-
-slice owner_address() method_id {
-  var (owner_address, _) = load_data();
-  return owner_address;
-}
-
-int counter() method_id {
-  var (_, counter) = load_data();
-  return counter;
-}
-
-int balance() method_id {
-  var [balance, _] = get_balance();
-  return balance;
-}

contracts/main.tlb

@@ -1,16 +0,0 @@
-// https://ton.org/docs/#/overviews/TL-B
-// base types defined in https://github.com/ton-blockchain/ton/blob/master/crypto/block/block.tlb
-
-// storage (according to save_data() contract method)
-
-storage#_ owner_address:MsgAddress counter:uint64 = Storage
-
-// ops
-
-increment query_id:uint64 = InternalMsgBody
-
-deposit query_id:uint64 = InternalMsgBody
-
-withdraw query_id:uint64 withdraw_amount:Grams = InternalMsgBody
-
-transfer_ownership query_id:uint64 new_owner_address:MsgAddress = InternalMsgBody

contracts/main.ts

@@ -1,25 +1,101 @@
 import BN from "bn.js";
-import { Cell, beginCell, Address } from "ton";
+import {Address, beginCell, Cell, contractAddress, TonClient, WalletContract, WalletV3R2Source} from "ton";
+import {mnemonicToWalletKey} from "ton-crypto";
 
 // encode contract storage according to save_data() contract method
-export function data(params: { ownerAddress: Address; counter: number }): Cell {
+// storage#_ total_supply:Coins admin_address:MsgAddress next_admin_address:MsgAddress content:^Cell jetton_wallet_code:^Cell = Storage;
-  return beginCell().storeAddress(params.ownerAddress).storeUint(params.counter, 64).endCell();
+export function minterData(params: { adminAddress: Address; supply: number, nextAdminAddress?: Address, content: Cell, wallet_code: Cell }): Cell {
+    if (!params.nextAdminAddress) params.nextAdminAddress = params.adminAddress;
+    return beginCell()
+        .storeCoins(params.supply)
+        .storeAddress(params.adminAddress)
+        .storeAddress(params.nextAdminAddress)
+        .storeRef(params.content)
+        .storeRef(params.wallet_code)
+        .endCell();
 }
 
-// message encoders for all ops (see contracts/imports/constants.fc for consts)
+function bufferToChunks(buff: Buffer, chunkSize: number) {
+    let chunks: Buffer[] = []
+    while (buff.byteLength > 0) {
+        chunks.push(buff.slice(0, chunkSize))
+        buff = buff.slice(chunkSize)
+    }
+    return chunks
+}
+
+export function makeSnakeCell(data: Buffer) {
+    let chunks = bufferToChunks(data, 127)
+    let rootCell = new Cell()
+    let curCell = rootCell
+
+    for (let i = 0; i < chunks.length; i++) {
+        let chunk = chunks[i]
+
+        curCell.bits.writeBuffer(chunk)
+
+        if (chunks[i + 1]) {
+            let nextCell = new Cell()
+            curCell.refs.push(nextCell)
+            curCell = nextCell
+        }
+    }
+
+    return rootCell
+}
 
-export function increment(): Cell {
+export function getMinterAddress(params: { adminAddress: Address; supply: number, nextAdminAddress?: Address, content: Cell, wallet_code: Cell }, initCodeCell: Cell): Address {
-  return beginCell().storeUint(0x37491f2f, 32).storeUint(0, 64).endCell();
+    return contractAddress({workchain: 0, initialData: minterData(params), initialCode: initCodeCell});
 }
 
-export function deposit(): Cell {
+const OFF_CHAIN_CONTENT_PREFIX = 0x01
-  return beginCell().storeUint(0x47d54391, 32).storeUint(0, 64).endCell();
+
+export function encodeOffChainContent(content: string) {
+    let data = Buffer.from(content)
+    let offChainPrefix = Buffer.from([OFF_CHAIN_CONTENT_PREFIX])
+    data = Buffer.concat([offChainPrefix, data])
+    return makeSnakeCell(data)
+}
+
+// storage#_ balance:(VarUInteger 16) owner_address:MsgAddressInt jetton_master_address:MsgAddressInt jetton_wallet_code:^Cell = Storage;
+export function walletData(params: { balance: number, ownerAddress: Address, jettonMasterAddress: Address, jettonWalletCode: Cell }): Cell {
+    return beginCell()
+        .storeUint(params.balance, 15)
+        .storeAddress(params.ownerAddress)
+        .storeAddress(params.jettonMasterAddress)
+        .storeRef(params.jettonWalletCode)
+        .endCell();
 }
 
-export function withdraw(params: { withdrawAmount: BN }): Cell {
+
-  return beginCell().storeUint(0x41836980, 32).storeUint(0, 64).storeCoins(params.withdrawAmount).endCell();
+export function TON(): number {
+    return 1000000000;
 }
 
-export function transferOwnership(params: { newOwnerAddress: Address }): Cell {
+// message encoders for all ops (see contracts/imports/constants.fc for consts)
-  return beginCell().storeUint(0x2da38aaf, 32).storeUint(0, 64).storeAddress(params.newOwnerAddress).endCell();
+
+export function depositMsg(amount: number): Cell {
+    return beginCell().storeUint(0x77a33521, 32)
+        .storeUint(0, 64).storeCoins(amount).endCell();
+}
+
+export function withdrawMsg(params: { withdrawAmount: BN }): Cell {
+    return beginCell().storeUint(0x47d1895f, 32).storeUint(0, 64).storeCoins(params.withdrawAmount).endCell();
+}
+
+export async function getWallet(isTestnet: boolean = true) {
+    const client = new TonClient({
+        endpoint: `https://${isTestnet ? "testnet." : ""}toncenter.com/api/v2/jsonRPC`,
+        apiKey: isTestnet ? 'bed2b4589201ff3c575be653593f912a337c08eed416b60b02345763b9ee9c36' : 'a1e8a1055a387515158589dc7e9bad3035e7db2b9f9ea5cdad6b727f71e328db'
+    });
+    let deployerMnemonic = process.env.DEPLOYER_MNEMONIC;
+    if (!deployerMnemonic) throw new Error("DEPLOYER_MNEMONIC env var is not set");
+
+    // open the wallet and make sure it has enough TON
+    const walletKey = await mnemonicToWalletKey(deployerMnemonic.split(" "));
+    let workchain = 0;
+    return [WalletContract.create(client, WalletV3R2Source.create({
+        publicKey: walletKey.publicKey,
+        workchain
+    })), walletKey];
 }

contracts/minter.fc

@@ -170,7 +170,7 @@ int deposit_gas_consumption() asm "35000000 PUSHINT"; ;; 0.035 TON
   }
 
   if (op == op::provide_wallet_address) {
-    throw_unless(75, msg_value > fwd_fee + const::provide_address_gas_consumption);
+    throw_unless(75, msg_value > fwd_fee + gas_consumption());
 
     slice owner_address = in_msg_body~load_msg_addr();
     int include_address? = in_msg_body~load_uint(1);

contracts/utils.ts

@@ -0,0 +1,31 @@
+import { Address, Cell, CellMessage, InternalMessage, CommonMessageInfo, WalletContract, SendMode, Wallet } from "ton";
+import BN from "bn.js";
+
+// helper for end-to-end on-chain tests (normally post deploy) to allow sending InternalMessages to contracts using a wallet
+export async function sendInternalMessageWithWallet(params: { walletContract: WalletContract; secretKey: Buffer; to: Address; value: BN; bounce?: boolean; body?: Cell }) {
+  const message = params.body ? new CellMessage(params.body) : undefined;
+  const seqno = await params.walletContract.getSeqNo();
+  const transfer = params.walletContract.createTransfer({
+    secretKey: params.secretKey,
+    seqno: seqno,
+    sendMode: SendMode.PAY_GAS_SEPARATLY + SendMode.IGNORE_ERRORS,
+    order: new InternalMessage({
+      to: params.to,
+      value: params.value,
+      bounce: params.bounce ?? false,
+      body: new CommonMessageInfo({
+        body: message,
+      }),
+    }),
+  });
+  await params.walletContract.client.sendExternalMessage(params.walletContract, transfer);
+  for (let attempt = 0; attempt < 10; attempt++) {
+    await sleep(2000);
+    const seqnoAfter = await params.walletContract.getSeqNo();
+    if (seqnoAfter > seqno) return;
+  }
+}
+
+function sleep(ms: number) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package.json

@@ -1,5 +1,5 @@
 {
-  "name": "tonb",
+  "name": "bton",
   "description": "",
   "version": "0.0.0",
   "license": "MIT",
@@ -10,10 +10,11 @@
     "build": "ts-node ./build/_build.ts",
     "deploy": "ts-node ./build/_deploy.ts",
     "deploy:testnet": "ts-node ./build/_deploy.ts",
-    "postinstall": "ts-node ./build/_setup.ts"
+    "postinstall": "ts-node ./build/_setup.ts",
+    "cli": "node --no-warnings --loader ts-node/esm build/cli.js "
   },
   "devDependencies": {
-    "@swc/core": "^1.2.177",
+    "@swc/core": "^1.3.25",
     "@types/bn.js": "^5.1.0",
     "@types/chai": "^4.3.0",
     "@types/mocha": "^9.0.0",
@@ -26,10 +27,10 @@
     "mocha": "^9.1.3",
     "prando": "^6.0.1",
     "prettier": "^2.6.2",
-    "ton": "^12.1.3",
+    "ton": "^12.3.3",
     "ton-contract-executor": "^0.4.8",
     "ton-crypto": "^3.1.0",
-    "ts-node": "^10.4.0",
+    "ts-node": "^10.9.1",
     "typescript": "^4.5.4"
   },
   "prettier": {
@@ -46,6 +47,9 @@
     "node": ">=16.15.0"
   },
   "dependencies": {
-    "semver": "^7.3.7"
+    "@tonconnect/protocol": "^2.0.1",
+    "semver": "^7.3.7",
+    "subcommand": "^2.1.1",
+    "ton-compiler": "^2.0.0"
   }
 }

test/helpers.ts

@@ -2,6 +2,7 @@ import BN from "bn.js";
 import { Address, Cell, CellMessage, InternalMessage, CommonMessageInfo, WalletContract, SendMode, Wallet } from "ton";
 import { SmartContract } from "ton-contract-executor";
 import Prando from "prando";
+import { sendInternalMessageWithWallet} from "../contracts/utils";
 
 export const zeroAddress = new Address(0, Buffer.alloc(32, 0));
 
@@ -33,31 +34,4 @@ export function setBalance(contract: SmartContract, balance: BN) {
   });
 }
 
-// helper for end-to-end on-chain tests (normally post deploy) to allow sending InternalMessages to contracts using a wallet
+export { sendInternalMessageWithWallet };
-export async function sendInternalMessageWithWallet(params: { walletContract: WalletContract; secretKey: Buffer; to: Address; value: BN; bounce?: boolean; body?: Cell }) {
-  const message = params.body ? new CellMessage(params.body) : undefined;
-  const seqno = await params.walletContract.getSeqNo();
-  const transfer = params.walletContract.createTransfer({
-    secretKey: params.secretKey,
-    seqno: seqno,
-    sendMode: SendMode.PAY_GAS_SEPARATLY + SendMode.IGNORE_ERRORS,
-    order: new InternalMessage({
-      to: params.to,
-      value: params.value,
-      bounce: params.bounce ?? false,
-      body: new CommonMessageInfo({
-        body: message,
-      }),
-    }),
-  });
-  await params.walletContract.client.sendExternalMessage(params.walletContract, transfer);
-  for (let attempt = 0; attempt < 10; attempt++) {
-    await sleep(2000);
-    const seqnoAfter = await params.walletContract.getSeqNo();
-    if (seqnoAfter > seqno) return;
-  }
-}
-
-function sleep(ms: number) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}