feat(sdk-coin-polyx): add HexTransferBuilder for NEW Polymesh memo encoding (CECHO-1370)

Add HexTransferBuilder that produces the NEW Polymesh memo encoding: UTF-8 bytes
right-padded with 0x00 to 32 bytes, passed as a 0x-prefixed hex string, instead of
the OLD ASCII left-pad format used by TransferBuilder.

Changes:
- src/lib/hexTransferBuilder.ts: new class extending TransferBuilder, overrides memo()
  with NEW encoding; round-trip safe (already-encoded 0x strings stored as-is)
- src/lib/utils.ts: add encodeMemoNew() and isNewMemoEncoding() helpers
- src/lib/index.ts: export HexTransferBuilder
- src/lib/transactionBuilderFactory.ts: add getHexTransferBuilder(); factory.from()
  auto-detects NEW memo encoding (any 0x00 byte) and returns HexTransferBuilder
- src/polyx.ts: add hexTransfer() convenience method alongside stakingBatch()/bondExtra()
- test/unit/transactionBuilder/hexTransferBuilder.ts: 31 unit tests covering memo
  encoding for all memo values, factory.from() routing, full round-trip (build →
  serialize → from() → build produces identical hex), and OLD vs NEW regression checks

Verified on-chain: broadcast transferWithMemo with NEW memo "56594" on Polymesh testnet
Tx: 0x41c453458385d1373343cb8b4fdc872acd73209881fd95f844ce060caab74d95

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: nvrakesh06

modules/sdk-coin-polyx/src/lib/hexTransferBuilder.ts

@@ -0,0 +1,38 @@
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { TransferBuilder } from './transferBuilder';
+
+/**
+ * Builds a POLYX transferWithMemo transaction using the NEW Polymesh memo encoding:
+ * UTF-8 bytes right-padded with 0x00 to 32 bytes, passed as a 0x-prefixed hex string.
+ *
+ * OLD encoding (TransferBuilder): plain string, left-padded with ASCII '0' to 32 chars.
+ * NEW encoding (this class):      0x-prefixed hex, right-padded with 0x00 to 32 bytes.
+ *
+ * Same intended memo produces different on-chain bytes depending on which builder is used.
+ * Use this builder when the recipient or downstream tooling expects Polymesh-native encoding.
+ */
+export class HexTransferBuilder extends TransferBuilder {
+  constructor(_coinConfig: Readonly<CoinConfig>) {
+    super(_coinConfig);
+  }
+
+  /**
+   * Encode memo using the NEW Polymesh format.
+   *
+   * If the value is already a 0x-prefixed 32-byte hex string (e.g. when decoding an
+   * existing NEW-encoded transaction via fromImplementation), it is stored as-is.
+   * Otherwise the text is converted to UTF-8 hex and right-padded with 0x00 to 32 bytes.
+   *
+   * @param memo The intended memo string (e.g. "56594", "testmemo")
+   */
+  memo(memo: string): this {
+    if (memo.startsWith('0x') && memo.length === 66) {
+      // already a fully-encoded 32-byte hex memo — store as-is (round-trip from fromImplementation)
+      this._memo = memo;
+    } else {
+      const textHex = Buffer.from(memo, 'utf8').toString('hex');
+      this._memo = `0x${textHex.padEnd(64, '0')}`;
+    }
+    return this;
+  }
+}

modules/sdk-coin-polyx/src/lib/index.ts

@@ -11,6 +11,7 @@ export {
 export { TransactionBuilderFactory } from './transactionBuilderFactory';
 export { PolyxBaseBuilder } from './baseBuilder';
 export { TransferBuilder } from './transferBuilder';
+export { HexTransferBuilder } from './hexTransferBuilder';
 export { RegisterDidWithCDDBuilder } from './registerDidWithCDDBuilder';
 export { PreApproveAssetBuilder } from './preApproveAssetBuilder';
 export { TokenTransferBuilder } from './tokenTransferBuilder';

modules/sdk-coin-polyx/src/lib/transactionBuilderFactory.ts

@@ -2,6 +2,7 @@ import { BaseTransactionBuilderFactory, NotImplementedError } from '@bitgo/sdk-c
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import { decode } from '@substrate/txwrapper-polkadot';
 import { TransferBuilder } from './transferBuilder';
+import { HexTransferBuilder } from './hexTransferBuilder';
 import { RegisterDidWithCDDBuilder } from './registerDidWithCDDBuilder';
 import { BondExtraBuilder } from './bondExtraBuilder';
 import { BatchStakingBuilder } from './batchStakingBuilder';
@@ -32,6 +33,10 @@ export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
     return new TransferBuilder(this._coinConfig).material(this._material);
   }
 
+  getHexTransferBuilder(): HexTransferBuilder {
+    return new HexTransferBuilder(this._coinConfig).material(this._material);
+  }
+
   getRegisterDidWithCDDBuilder(): RegisterDidWithCDDBuilder {
     return new RegisterDidWithCDDBuilder(this._coinConfig).material(this._material);
   }
@@ -96,6 +101,10 @@ export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
 
     const methodName = decodedTxn.method?.name;
     if (methodName === Interface.MethodNames.TransferWithMemo) {
+      const args = decodedTxn.method.args as Interface.TransferWithMemoArgs;
+      if (utils.isNewMemoEncoding(args.memo)) {
+        return this.getHexTransferBuilder();
+      }
       return this.getTransferBuilder();
     } else if (methodName === MethodNames.RegisterDidWithCDD) {
       return this.getRegisterDidWithCDDBuilder();

modules/sdk-coin-polyx/src/lib/utils.ts

@@ -29,6 +29,33 @@ export class Utils extends SubstrateUtils {
     return POLYX_DID_REGEX.test(did);
   }
 
+  /**
+   * Encode a memo string using the NEW Polymesh format:
+   * UTF-8 bytes right-padded with 0x00 to 32 bytes, returned as a 0x-prefixed hex string.
+   *
+   * @param text The intended memo string
+   * @returns 0x-prefixed 66-character hex string representing the 32-byte encoded memo
+   */
+  encodeMemoNew(text: string): string {
+    const textHex = Buffer.from(text, 'utf8').toString('hex');
+    return `0x${textHex.padEnd(64, '0')}`;
+  }
+
+  /**
+   * Detect whether a decoded 32-byte memo (0x-prefixed hex from txwrapper decode()) uses NEW encoding.
+   * NEW encoding right-pads with 0x00; any null byte means NEW. No null bytes → OLD (ASCII left-padded).
+   *
+   * @param memo 0x-prefixed 66-char hex string as returned by txwrapper decode()
+   */
+  isNewMemoEncoding(memo: string): boolean {
+    if (!memo.startsWith('0x') || memo.length !== 66) return false;
+    const hex = memo.slice(2);
+    for (let i = 0; i < hex.length - 1; i += 2) {
+      if (hex[i] === '0' && hex[i + 1] === '0') return true;
+    }
+    return false;
+  }
+
   getMaterial(networkType: NetworkType): Interface.Material {
     return (networkType === NetworkType.MAINNET ? mainnetMaterial : testnetMaterial) as unknown as Interface.Material;
   }

modules/sdk-coin-polyx/src/polyx.ts

@@ -22,7 +22,7 @@ import { BondExtraBuilder } from './lib/bondExtraBuilder';
 import { POLYX_ADDRESS_FORMAT } from './lib/constants';
 import { getDerivationPath } from '@bitgo/sdk-lib-mpc';
 import BigNumber from 'bignumber.js';
-import { TransactionBuilderFactory, TransferBuilder } from './lib';
+import { TransactionBuilderFactory, TransferBuilder, HexTransferBuilder } from './lib';
 
 export class Polyx extends SubstrateCoin {
   protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;
@@ -75,6 +75,10 @@ export class Polyx extends SubstrateCoin {
     return this.getBuilder().getBondExtraBuilder();
   }
 
+  hexTransfer(): HexTransferBuilder {
+    return this.getBuilder().getHexTransferBuilder();
+  }
+
   /**
    * Retrieves the address format for Polyx.
    *