feat(sdk-coin-ton): add jetton skeleton

Chinmay-Sharma1 · Chinmay-Sharma1 · commit a17ad7e254c6 · 2025-08-04T23:22:53.000+05:30
Ticket: WIN-3198 TICKET: WIN-3198
diff --git a/modules/bitgo/src/v2/coinFactory.ts b/modules/bitgo/src/v2/coinFactory.ts
@@ -6,6 +6,7 @@ import { AlgoToken } from '@bitgo/sdk-coin-algo';
 import { Bcha, Tbcha } from '@bitgo/sdk-coin-bcha';
 import { HbarToken } from '@bitgo/sdk-coin-hbar';
 import { Near, TNear, Nep141Token } from '@bitgo/sdk-coin-near';
+import { JettonToken } from '@bitgo/sdk-coin-ton';
 import { SolToken } from '@bitgo/sdk-coin-sol';
 import { TrxToken } from '@bitgo/sdk-coin-trx';
 import { CoinFactory, CoinConstructor } from '@bitgo/sdk-core';
@@ -35,6 +36,7 @@ import {
   CosmosTokenConfig,
   VetTokenConfig,
   TaoTokenConfig,
+  JettonTokenConfig,
 } from '@bitgo/statics';
 import {
   Ada,
@@ -519,6 +521,10 @@ export function registerCoinConstructors(coinFactory: CoinFactory, coinMap: Coin
   VetToken.createTokenConstructors().forEach(({ name, coinConstructor }) =>
     coinFactory.register(name, coinConstructor)
   );
+
+  JettonToken.createTokenConstructors([...tokens.bitcoin.ton.tokens, ...tokens.testnet.ton.tokens]).forEach(
+    ({ name, coinConstructor }) => coinFactory.register(name, coinConstructor)
+  );
 }
 
 export function getCoinConstructor(coinName: string): CoinConstructor | undefined {
@@ -963,6 +969,9 @@ export function getTokenConstructor(tokenConfig: TokenConfig): CoinConstructor |
     case 'zeta':
     case 'tzeta':
       return CosmosToken.createTokenConstructor(tokenConfig as CosmosTokenConfig);
+    case 'ton':
+    case 'tton':
+      return JettonToken.createTokenConstructor(tokenConfig as JettonTokenConfig);
     default:
       return undefined;
   }
diff --git a/modules/sdk-coin-ton/src/index.ts b/modules/sdk-coin-ton/src/index.ts
@@ -2,3 +2,4 @@ export * from './lib';
 export * from './register';
 export * from './ton';
 export * from './tton';
+export * from './jettonToken';
diff --git a/modules/sdk-coin-ton/src/jettonToken.ts b/modules/sdk-coin-ton/src/jettonToken.ts
@@ -0,0 +1,105 @@
+import BigNumber from 'bignumber.js';
+import { BitGoBase, CoinConstructor, NamedCoinConstructor, VerifyTransactionOptions } from '@bitgo/sdk-core';
+import { coins, JettonTokenConfig, NetworkType, tokens } from '@bitgo/statics';
+
+import { Transaction } from './lib';
+import { Ton } from './ton';
+
+export class JettonToken extends Ton {
+  public readonly tokenConfig: JettonTokenConfig;
+
+  constructor(bitgo: BitGoBase, tokenConfig: JettonTokenConfig) {
+    const staticsCoin = tokenConfig.network === NetworkType.MAINNET ? coins.get('ton') : coins.get('tton');
+    super(bitgo, staticsCoin);
+    this.tokenConfig = tokenConfig;
+  }
+
+  static createTokenConstructor(config: JettonTokenConfig): CoinConstructor {
+    return (bitgo: BitGoBase) => new JettonToken(bitgo, config);
+  }
+
+  static createTokenConstructors(
+    tokenConfig: JettonTokenConfig[] = [...tokens.bitcoin.ton.tokens, ...tokens.testnet.ton.tokens]
+  ): NamedCoinConstructor[] {
+    const tokensCtors: NamedCoinConstructor[] = [];
+    for (const token of tokenConfig) {
+      const tokenConstructor = JettonToken.createTokenConstructor(token);
+      tokensCtors.push({ name: token.type, coinConstructor: tokenConstructor });
+    }
+    return tokensCtors;
+  }
+
+  get name(): string {
+    return this.tokenConfig.name;
+  }
+
+  get coin(): string {
+    return this.tokenConfig.coin;
+  }
+
+  get contractAddress(): string {
+    return this.tokenConfig.contractAddress;
+  }
+
+  get decimalPlaces(): number {
+    return this.tokenConfig.decimalPlaces;
+  }
+
+  getChain(): string {
+    return this.tokenConfig.type;
+  }
+
+  getBaseChain(): string {
+    return this.coin;
+  }
+
+  getFullName(): string {
+    return 'Jetton Token';
+  }
+
+  getBaseFactor(): number {
+    return Math.pow(10, this.tokenConfig.decimalPlaces);
+  }
+
+  async verifyTransaction(params: VerifyTransactionOptions): Promise<boolean> {
+    const { txPrebuild: txPrebuild, txParams: txParams } = params;
+    const rawTx = txPrebuild.txHex;
+    let totalAmount = new BigNumber(0);
+    if (!rawTx) {
+      throw new Error('missing required tx prebuild property txHex');
+    }
+    const coinConfig = coins.get(this.getChain());
+    const transaction = new Transaction(coinConfig);
+    transaction.fromRawTransaction(Buffer.from(rawTx, 'hex').toString('base64'));
+    const explainedTx = transaction.explainTransaction();
+    if (txParams.recipients !== undefined) {
+      txParams.recipients.forEach((recipient) => {
+        if (recipient.tokenName && recipient.tokenName !== coinConfig.name) {
+          throw new Error('incorrect token name specified in recipients');
+        }
+        recipient.tokenName = coinConfig.name;
+      });
+      const filteredRecipients = txParams.recipients?.map((recipient) => ({
+        address: recipient.address,
+        amount: recipient.amount,
+        tokenName: recipient.tokenName,
+      }));
+      const filteredOutputs = explainedTx.outputs.map((output) => ({
+        address: output.address,
+        amount: output.amount,
+        tokenName: output.tokenName,
+      }));
+      const outputsMatch = JSON.stringify(filteredRecipients) === JSON.stringify(filteredOutputs);
+      if (!outputsMatch) {
+        throw new Error('Tx outputs does not match with expected txParams recipients');
+      }
+      for (const recipient of txParams.recipients) {
+        totalAmount = totalAmount.plus(recipient.amount);
+      }
+      if (!totalAmount.isEqualTo(explainedTx.outputAmount)) {
+        throw new Error('Tx total amount does not match with expected total amount field');
+      }
+    }
+    return true;
+  }
+}
diff --git a/modules/sdk-coin-ton/src/register.ts b/modules/sdk-coin-ton/src/register.ts
@@ -1,8 +1,15 @@
 import { BitGoBase } from '@bitgo/sdk-core';
 import { Ton } from './ton';
 import { Tton } from './tton';
+import { JettonToken } from './jettonToken';
 
 export const register = (sdk: BitGoBase): void => {
   sdk.register('ton', Ton.createInstance);
   sdk.register('tton', Tton.createInstance);
+
+  // Register Jetton tokens
+  const tokens = JettonToken.createTokenConstructors();
+  tokens.forEach((token) => {
+    sdk.register(token.name, token.coinConstructor);
+  });
 };
diff --git a/modules/statics/src/account.ts b/modules/statics/src/account.ts
@@ -153,6 +153,10 @@ export interface Nep141TokenConstructorOptions extends AccountConstructorOptions
   storageDepositAmount: string;
 }
 
+export interface JettonTokenConstructorOptions extends AccountConstructorOptions {
+  contractAddress: string;
+}
+
 export interface VetTokenConstructorOptions extends AccountConstructorOptions {
   contractAddress: string;
   gasTankToken?: string;
@@ -630,6 +634,17 @@ export class Nep141Token extends AccountCoinToken {
   }
 }
 
+export class JettonToken extends AccountCoinToken {
+  public contractAddress: string;
+  constructor(options: JettonTokenConstructorOptions) {
+    super({
+      ...options,
+    });
+
+    this.contractAddress = options.contractAddress;
+  }
+}
+
 export class VetToken extends AccountCoinToken {
   public contractAddress: string;
   public gasTankToken?: string;
@@ -3069,6 +3084,95 @@ export function sip10Token(
  * @param network? Optional token network. Defaults to the testnet Stacks network.
  * @param features? Features of this coin. Defaults to the DEFAULT_FEATURES defined in `AccountCoin`
  */
+/**
+ * Factory function for jetton token instances.
+ *
+ * @param id uuid v4
+ * @param name unique identifier of the token
+ * @param fullName Complete human-readable name of the token
+ * @param decimalPlaces Number of decimal places this token supports (divisibility exponent)
+ * @param contractAddress Contract address of this token
+ * @param asset Asset which this coin represents. This is the same for both mainnet and testnet variants of a coin.
+ * @param features Features of this coin. Defaults to the DEFAULT_FEATURES defined in `AccountCoin`
+ * @param prefix Optional token prefix. Defaults to empty string
+ * @param suffix Optional token suffix. Defaults to token name.
+ * @param network Optional token network. Defaults to TON main network.
+ * @param primaryKeyCurve The elliptic curve for this chain/token
+ */
+export function jettonToken(
+  id: string,
+  name: string,
+  fullName: string,
+  decimalPlaces: number,
+  contractAddress: string,
+  asset: UnderlyingAsset,
+  features: CoinFeature[] = AccountCoin.DEFAULT_FEATURES,
+  prefix = '',
+  suffix: string = name.toUpperCase(),
+  network: AccountNetwork = Networks.main.ton,
+  primaryKeyCurve: KeyCurve = KeyCurve.Ed25519
+) {
+  return Object.freeze(
+    new JettonToken({
+      id,
+      name,
+      fullName,
+      network,
+      contractAddress,
+      prefix,
+      suffix,
+      features,
+      decimalPlaces,
+      asset,
+      isToken: true,
+      primaryKeyCurve,
+      baseUnit: BaseUnit.TON,
+    })
+  );
+}
+
+/**
+ * Factory function for testnet jetton token instances.
+ *
+ * @param id uuid v4
+ * @param name unique identifier of the token
+ * @param fullName Complete human-readable name of the token
+ * @param decimalPlaces Number of decimal places this token supports (divisibility exponent)
+ * @param contractAddress Contract address of this token
+ * @param asset Asset which this coin represents. This is the same for both mainnet and testnet variants of a coin.
+ * @param features Features of this coin. Defaults to the DEFAULT_FEATURES defined in `AccountCoin`
+ * @param prefix Optional token prefix. Defaults to empty string
+ * @param suffix Optional token suffix. Defaults to token name.
+ * @param network Optional token network. Defaults to the testnet TON network.
+ */
+export function tjettonToken(
+  id: string,
+  name: string,
+  fullName: string,
+  decimalPlaces: number,
+  contractAddress: string,
+  asset: UnderlyingAsset,
+  features: CoinFeature[] = AccountCoin.DEFAULT_FEATURES,
+  prefix = '',
+  suffix: string = name.toUpperCase(),
+  network: AccountNetwork = Networks.test.ton,
+  primaryKeyCurve: KeyCurve = KeyCurve.Ed25519
+) {
+  return jettonToken(
+    id,
+    name,
+    fullName,
+    decimalPlaces,
+    contractAddress,
+    asset,
+    features,
+    prefix,
+    suffix,
+    network,
+    primaryKeyCurve
+  );
+}
+
 export function tsip10Token(
   id: string,
   name: string,
diff --git a/modules/statics/src/tokenConfig.ts b/modules/statics/src/tokenConfig.ts
@@ -15,6 +15,7 @@ import {
   Erc20Coin,
   Erc721Coin,
   HederaToken,
+  JettonToken,
   Nep141Token,
   OpethERC20Token,
   PolygonERC20Token,
@@ -120,6 +121,10 @@ export type Nep141TokenConfig = BaseNetworkConfig & {
   storageDepositAmount: string;
 };
 
+export type JettonTokenConfig = BaseNetworkConfig & {
+  contractAddress: string;
+};
+
 export type VetTokenConfig = BaseNetworkConfig & {
   contractAddress: string;
 };
@@ -149,7 +154,8 @@ export type TokenConfig =
   | Nep141TokenConfig
   | CosmosTokenConfig
   | VetTokenConfig
-  | TaoTokenConfig;
+  | TaoTokenConfig
+  | JettonTokenConfig;
 
 export interface Tokens {
   bitcoin: {
@@ -238,6 +244,9 @@ export interface Tokens {
     cosmos: {
       tokens: CosmosTokenConfig[];
     };
+    ton: {
+      tokens: JettonTokenConfig[];
+    };
   };
   testnet: {
     eth: {
@@ -325,6 +334,9 @@ export interface Tokens {
     cosmos: {
       tokens: CosmosTokenConfig[];
     };
+    ton: {
+      tokens: JettonTokenConfig[];
+    };
   };
 }
 
@@ -942,6 +954,25 @@ function getCosmosTokenConfig(coin: CosmosChainToken): CosmosTokenConfig {
   };
 }
 
+function getJettonTokenConfig(coin: JettonToken): JettonTokenConfig {
+  return {
+    type: coin.name,
+    coin: coin.network.type === NetworkType.MAINNET ? 'ton' : 'tton',
+    network: coin.network.type === NetworkType.MAINNET ? 'Mainnet' : 'Testnet',
+    name: coin.fullName,
+    contractAddress: coin.contractAddress,
+    decimalPlaces: coin.decimalPlaces,
+  };
+}
+
+const getFormattedJettonTokens = (customCoinMap = coins) =>
+  customCoinMap.reduce((acc: JettonTokenConfig[], coin) => {
+    if (coin instanceof JettonToken) {
+      acc.push(getJettonTokenConfig(coin));
+    }
+    return acc;
+  }, []);
+
 export const getFormattedTokens = (coinMap = coins): Tokens => {
   const formattedAptNFTCollections = getFormattedAptNFTCollections(coinMap);
   return {
@@ -1035,6 +1066,9 @@ export const getFormattedTokens = (coinMap = coins): Tokens => {
       cosmos: {
         tokens: getFormattedCosmosChainTokens(coinMap).filter((token) => token.network === 'Mainnet'),
       },
+      ton: {
+        tokens: getFormattedJettonTokens(coinMap).filter((token) => token.network === 'Mainnet'),
+      },
     },
     testnet: {
       eth: {
@@ -1126,6 +1160,9 @@ export const getFormattedTokens = (coinMap = coins): Tokens => {
       cosmos: {
         tokens: getFormattedCosmosChainTokens(coinMap).filter((token) => token.network === 'Testnet'),
       },
+      ton: {
+        tokens: getFormattedJettonTokens(coinMap).filter((token) => token.network === 'Testnet'),
+      },
     },
   };
 };
@@ -1227,6 +1264,8 @@ export function getFormattedTokenConfigForCoin(coin: Readonly<BaseCoin>): TokenC
     return getCosmosTokenConfig(coin);
   } else if (coin instanceof VetToken) {
     return getVetTokenConfig(coin);
+  } else if (coin instanceof JettonToken) {
+    return getJettonTokenConfig(coin);
   }
   return undefined;
 }
