feat: add TON blockchain support

jest.config.js

@@ -7,10 +7,13 @@ module.exports = {
   reporters: ["default", "jest-junit"],
   rootDir: "packages",
   testMatch: ["<rootDir>/**/*.test.ts"],
-  transformIgnorePatterns: ["node_modules/(?!(@shapeshiftoss/bitcoinjs-lib|valibot)/.*)"],
+  transformIgnorePatterns: [
+    "node_modules/(?!(@shapeshiftoss/bitcoinjs-lib|valibot|@ton/ton|@ton/core|@ton/crypto|axios)/.*)",
+  ],
   moduleNameMapper: {
     "^@shapeshiftoss/hdwallet-(.*)": "<rootDir>/hdwallet-$1/src",
     "^valibot$": require.resolve("valibot"),
+    "^@ton/ton$": "<rootDir>/hdwallet-native/__mocks__/@ton/ton.js",
   },
   globals: {
     "ts-jest": {

packages/hdwallet-core/src/index.ts

@@ -20,6 +20,7 @@ export * from "./solana";
 export * from "./starknet";
 export * from "./sui";
 export * from "./near";
+export * from "./ton";
 export * from "./transport";
 export * from "./tron";
 export * from "./utils";

packages/hdwallet-core/src/ton.ts

@@ -0,0 +1,100 @@
+import { addressNListToBIP32, slip44ByCoin } from "./utils";
+import { BIP32Path, HDWallet, HDWalletInfo, PathDescription } from "./wallet";
+
+export interface TonGetAddress {
+  addressNList: BIP32Path;
+  showDisplay?: boolean;
+}
+
+export interface TonRawMessage {
+  targetAddress: string;
+  sendAmount: string;
+  payload: string;
+  stateInit?: string;
+}
+
+export interface TonSignTx {
+  addressNList: BIP32Path;
+  /** Raw message bytes to sign (BOC serialized) - used for simple transfers */
+  message?: Uint8Array;
+  /** Raw messages from external protocols like Stonfi - used for complex swaps */
+  rawMessages?: TonRawMessage[];
+  /** Sequence number for the wallet */
+  seqno?: number;
+  /** Transaction expiration timestamp */
+  expireAt?: number;
+}
+
+export interface TonSignedTx {
+  signature: string;
+  serialized: string;
+}
+
+export interface TonGetAccountPaths {
+  accountIdx: number;
+}
+
+export interface TonAccountPath {
+  addressNList: BIP32Path;
+}
+
+export interface TonWalletInfo extends HDWalletInfo {
+  readonly _supportsTonInfo: boolean;
+
+  /**
+   * Returns a list of bip32 paths for a given account index in preferred order
+   * from most to least preferred.
+   */
+  tonGetAccountPaths(msg: TonGetAccountPaths): Array<TonAccountPath>;
+
+  /**
+   * Returns the "next" account path, if any.
+   */
+  tonNextAccountPath(msg: TonAccountPath): TonAccountPath | undefined;
+}
+
+export interface TonWallet extends TonWalletInfo, HDWallet {
+  readonly _supportsTon: boolean;
+
+  tonGetAddress(msg: TonGetAddress): Promise<string | null>;
+  tonSignTx(msg: TonSignTx): Promise<TonSignedTx | null>;
+}
+
+export function tonDescribePath(path: BIP32Path): PathDescription {
+  const pathStr = addressNListToBIP32(path);
+  const unknown: PathDescription = {
+    verbose: pathStr,
+    coin: "Ton",
+    isKnown: false,
+  };
+
+  // TON uses a 3-level path like Stellar: m/44'/607'/<account>'
+  const slip44 = slip44ByCoin("Ton");
+  if (slip44 === undefined) return unknown;
+  if (path.length != 3) return unknown;
+  if (path[0] != 0x80000000 + 44) return unknown;
+  if (path[1] != 0x80000000 + slip44) return unknown;
+  if ((path[2] & 0x80000000) >>> 0 !== 0x80000000) return unknown;
+
+  const index = path[2] & 0x7fffffff;
+  return {
+    verbose: `TON Account #${index}`,
+    accountIdx: index,
+    wholeAccount: true,
+    coin: "Ton",
+    isKnown: true,
+  };
+}
+
+// TON uses a 3-level hardened derivation path: m/44'/607'/<account>'
+// This follows the same pattern as Stellar (SEP-0005) since TON uses Ed25519
+// https://github.com/satoshilabs/slips/blob/master/slip-0044.md (607 = TON)
+export function tonGetAccountPaths(msg: TonGetAccountPaths): Array<TonAccountPath> {
+  const slip44 = slip44ByCoin("Ton");
+  if (slip44 === undefined) return [];
+  return [
+    {
+      addressNList: [0x80000000 + 44, 0x80000000 + slip44, 0x80000000 + msg.accountIdx],
+    },
+  ];
+}

packages/hdwallet-core/src/utils.ts

@@ -161,6 +161,7 @@ export const slip44Table = Object.freeze({
   Tron: 195,
   Sui: 784,
   Near: 397,
+  Ton: 607,
   // EVM chains all use the same SLIP44
   Ethereum: 60,
   Avalanche: 60,

packages/hdwallet-core/src/wallet.ts

@@ -17,6 +17,7 @@ import { StarknetWallet, StarknetWalletInfo } from "./starknet";
 import { SuiWallet, SuiWalletInfo } from "./sui";
 import { TerraWallet, TerraWalletInfo } from "./terra";
 import { ThorchainWallet, ThorchainWalletInfo } from "./thorchain";
+import { TonWallet, TonWalletInfo } from "./ton";
 import { Transport } from "./transport";
 import { TronWallet, TronWalletInfo } from "./tron";
 
@@ -300,6 +301,14 @@ export function infoSui(info: HDWalletInfo): info is SuiWalletInfo {
   return isObject(info) && (info as any)._supportsSuiInfo;
 }
 
+export function supportsTon(wallet: HDWallet): wallet is TonWallet {
+  return isObject(wallet) && (wallet as any)._supportsTon;
+}
+
+export function infoTon(info: HDWalletInfo): info is TonWalletInfo {
+  return isObject(info) && (info as any)._supportsTonInfo;
+}
+
 export function supportsDebugLink(wallet: HDWallet): wallet is DebugLinkWallet {
   return isObject(wallet) && (wallet as any)._supportsDebugLink;
 }

packages/hdwallet-native/__mocks__/@ton/ton.js

@@ -0,0 +1,10 @@
+module.exports = {
+  WalletContractV4: {
+    create: jest.fn().mockReturnValue({
+      address: { toString: jest.fn().mockReturnValue("mock-address") },
+      init: { code: null, data: null },
+      createTransfer: jest.fn(),
+    }),
+  },
+  TonClient: jest.fn(),
+};

packages/hdwallet-native/package.json

@@ -20,6 +20,9 @@
     "@shapeshiftoss/bitcoinjs-lib": "7.0.0-shapeshift.2",
     "@shapeshiftoss/hdwallet-core": "1.62.39",
     "@shapeshiftoss/proto-tx-builder": "0.10.0",
+    "@ton/core": "^0.62.1",
+    "@ton/crypto": "^3.3.0",
+    "@ton/ton": "^16.1.0",
     "@zxing/text-encoding": "^0.9.0",
     "bchaddrjs": "^0.4.9",
     "bech32": "^1.1.4",

packages/hdwallet-native/src/crypto/isolation/adapters/index.ts

@@ -10,4 +10,5 @@ export { default as Solana } from "./solana";
 export { default as Starknet } from "./starknet";
 export { default as Sui } from "./sui";
 export { default as Near } from "./near";
+export { default as Ton } from "./ton";
 export { default as Tron } from "./tron";

packages/hdwallet-native/src/crypto/isolation/adapters/ton.ts

@@ -0,0 +1,214 @@
+import * as core from "@shapeshiftoss/hdwallet-core";
+import { Address, beginCell, Cell, internal, MessageRelaxed, SendMode, storeMessage } from "@ton/core";
+import { WalletContractV4 } from "@ton/ton";
+
+import { Isolation } from "../..";
+
+const ED25519_PUBLIC_KEY_SIZE = 32;
+
+export interface TonTransactionParams {
+  from: string;
+  to: string;
+  value: string;
+  seqno: number;
+  expireAt: number;
+  memo?: string;
+  contractAddress?: string;
+  type?: "transfer" | "jetton_transfer";
+}
+
+export class TonAdapter {
+  protected readonly nodeAdapter: Isolation.Adapters.Ed25519;
+
+  constructor(nodeAdapter: Isolation.Adapters.Ed25519) {
+    this.nodeAdapter = nodeAdapter;
+  }
+
+  async getAddress(addressNList: core.BIP32Path): Promise<string> {
+    const nodeAdapter = await this.nodeAdapter.derivePath(core.addressNListToHardenedBIP32(addressNList));
+    const publicKey = await nodeAdapter.getPublicKey();
+
+    if (publicKey.length !== ED25519_PUBLIC_KEY_SIZE) {
+      throw new Error(`Invalid Ed25519 public key size: ${publicKey.length}`);
+    }
+
+    const wallet = WalletContractV4.create({
+      workchain: 0,
+      publicKey: Buffer.from(publicKey),
+    });
+
+    return wallet.address.toString({ bounceable: false });
+  }
+
+  async getPublicKey(addressNList: core.BIP32Path): Promise<string> {
+    const nodeAdapter = await this.nodeAdapter.derivePath(core.addressNListToHardenedBIP32(addressNList));
+    const publicKey = await nodeAdapter.getPublicKey();
+    return Buffer.from(publicKey).toString("hex");
+  }
+
+  async createSignedTransferBoc(params: TonTransactionParams, addressNList: core.BIP32Path): Promise<string> {
+    const derivedNodeAdapter = await this.nodeAdapter.derivePath(core.addressNListToHardenedBIP32(addressNList));
+    const publicKey = await derivedNodeAdapter.getPublicKey();
+
+    const wallet = WalletContractV4.create({
+      workchain: 0,
+      publicKey: Buffer.from(publicKey),
+    });
+
+    const destination = Address.parse(params.to);
+
+    let internalMessage: MessageRelaxed;
+
+    if (params.type === "jetton_transfer" && params.contractAddress) {
+      const jettonWalletAddress = Address.parse(params.contractAddress);
+      const forwardPayload = params.memo
+        ? beginCell().storeUint(0, 32).storeStringTail(params.memo).endCell()
+        : beginCell().endCell();
+
+      const jettonTransferBody = beginCell()
+        .storeUint(0x0f8a7ea5, 32)
+        .storeUint(0, 64)
+        .storeCoins(BigInt(params.value))
+        .storeAddress(destination)
+        .storeAddress(Address.parse(params.from))
+        .storeBit(false)
+        .storeCoins(BigInt(1))
+        .storeBit(true)
+        .storeRef(forwardPayload)
+        .endCell();
+
+      internalMessage = internal({
+        to: jettonWalletAddress,
+        value: BigInt(100000000),
+        bounce: true,
+        body: jettonTransferBody,
+      });
+    } else {
+      internalMessage = internal({
+        to: destination,
+        value: BigInt(params.value),
+        bounce: false,
+        body: params.memo ? beginCell().storeUint(0, 32).storeStringTail(params.memo).endCell() : beginCell().endCell(),
+      });
+    }
+
+    const signer = async (message: Cell): Promise<Buffer> => {
+      const hash = message.hash();
+      const signature = await derivedNodeAdapter.node.sign(hash);
+      return Buffer.from(signature);
+    };
+
+    const transfer = await wallet.createTransfer({
+      seqno: params.seqno,
+      signer,
+      messages: [internalMessage],
+      sendMode: SendMode.PAY_GAS_SEPARATELY + SendMode.IGNORE_ERRORS,
+      timeout: params.expireAt,
+    });
+
+    const externalMessage = beginCell()
+      .store(
+        storeMessage({
+          info: {
+            type: "external-in",
+            dest: wallet.address,
+            importFee: BigInt(0),
+          },
+          init: params.seqno === 0 ? wallet.init : null,
+          body: transfer,
+        })
+      )
+      .endCell();
+
+    return externalMessage.toBoc().toString("base64");
+  }
+
+  async signTransaction(message: Uint8Array, addressNList: core.BIP32Path): Promise<string> {
+    const nodeAdapter = await this.nodeAdapter.derivePath(core.addressNListToHardenedBIP32(addressNList));
+    const signature = await nodeAdapter.node.sign(message);
+    return Buffer.from(signature).toString("hex");
+  }
+
+  async createSignedRawTransferBoc(
+    rawMessages: core.TonRawMessage[],
+    seqno: number,
+    expireAt: number,
+    addressNList: core.BIP32Path
+  ): Promise<string> {
+    const derivedNodeAdapter = await this.nodeAdapter.derivePath(core.addressNListToHardenedBIP32(addressNList));
+    const publicKey = await derivedNodeAdapter.getPublicKey();
+
+    const wallet = WalletContractV4.create({
+      workchain: 0,
+      publicKey: Buffer.from(publicKey),
+    });
+
+    const internalMessages: MessageRelaxed[] = rawMessages.map((msg) => {
+      const destination = Address.parse(msg.targetAddress);
+      const value = BigInt(msg.sendAmount);
+
+      let body: Cell;
+      if (msg.payload && msg.payload.length > 0) {
+        const payloadBuffer = Buffer.from(msg.payload, "hex");
+        body = Cell.fromBoc(payloadBuffer)[0];
+      } else {
+        body = beginCell().endCell();
+      }
+
+      let init: { code: Cell; data: Cell } | undefined;
+      if (msg.stateInit && msg.stateInit.length > 0) {
+        const stateInitBuffer = Buffer.from(msg.stateInit, "hex");
+        const stateInitCell = Cell.fromBoc(stateInitBuffer)[0];
+        const stateInitSlice = stateInitCell.beginParse();
+        const hasCode = stateInitSlice.loadBit();
+        const hasData = stateInitSlice.loadBit();
+        if (hasCode && hasData) {
+          init = {
+            code: stateInitSlice.loadRef(),
+            data: stateInitSlice.loadRef(),
+          };
+        }
+      }
+
+      return internal({
+        to: destination,
+        value,
+        bounce: true,
+        body,
+        init,
+      });
+    });
+
+    const signer = async (message: Cell): Promise<Buffer> => {
+      const hash = message.hash();
+      const signature = await derivedNodeAdapter.node.sign(hash);
+      return Buffer.from(signature);
+    };
+
+    const transfer = await wallet.createTransfer({
+      seqno,
+      signer,
+      messages: internalMessages,
+      sendMode: SendMode.PAY_GAS_SEPARATELY + SendMode.IGNORE_ERRORS,
+      timeout: expireAt,
+    });
+
+    const externalMessage = beginCell()
+      .store(
+        storeMessage({
+          info: {
+            type: "external-in",
+            dest: wallet.address,
+            importFee: BigInt(0),
+          },
+          init: seqno === 0 ? wallet.init : null,
+          body: transfer,
+        })
+      )
+      .endCell();
+
+    return externalMessage.toBoc().toString("base64");
+  }
+}
+
+export default TonAdapter;