@altiuslabs/tx-sdk 0.1.4 → 0.1.6

package/README.md

@@ -73,10 +73,9 @@ import {
   USDA_ADDRESS,
   FEE_TOKEN_FACTORY_ADDRESS,
   FEE_MANAGER_ADDRESS,
-  ALT_FEE_TOKEN_ADDRESS,
   BASE_FEE_ATTO,
   DEFAULT_GAS_LIMIT,
-} from '@altius/tx-sdk/constants';
+} from '@altiuslabs/tx-sdk/constants';
 ```
 
 ## Security

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@altiuslabs/tx-sdk",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "SDK for signing and sending Altius USD multi-token transactions",
   "type": "module",
   "main": "src/index.js",

package/src/constants.js

@@ -36,11 +36,6 @@ export const FEE_TOKEN_FACTORY_ADDRESS = '0xa17000000000000000000000000000000000
  */
 export const FEE_MANAGER_ADDRESS = '0xFE0000000000000000000000000000000000000001';
 
-/**
- * Alternative fee token for testing (index 2)
- */
-export const ALT_FEE_TOKEN_ADDRESS = '0xa170000000000000000000000000000000000002';
-
 /**
  * Fee token prefix (10 bytes) for validation
  */
@@ -55,7 +50,6 @@ export const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
 export const VALID_ADDRESSES = {
   USDA: USDA_ADDRESS,
   FACTORY: FEE_TOKEN_FACTORY_ADDRESS,
-  ALT_TOKEN: ALT_FEE_TOKEN_ADDRESS,
 };
 
 // Invalid addresses for testing

package/src/index.js

@@ -25,5 +25,8 @@ export { NonceManager, create_nonce_manager } from './nonce.js';
 // High-level client
 export { TxClient, TxClientBuilder, create_tx_client } from './client.js';
 
+// Utilities
+export { keccak256, pad_hex, num_to_hex, rlp_encode, transaction_hash, computeFeeTokenAddress, isReservedAddress } from './utils.js';
+
 // Constants
 export * from './constants.js';

package/src/utils.js

@@ -56,3 +56,64 @@ export function rlp_encode(items) {
 export function transaction_hash(signed_tx) {
   return keccak256(signed_tx);
 }
+
+// ============================================================================
+// Fee Token Address Computation
+// ============================================================================
+
+// Altius fee token prefix (10 bytes): 0xA1700000...
+const FEE_TOKEN_PREFIX_BYTES = [0xA1, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
+
+/**
+ * Compute deterministic fee token address.
+ *
+ * Address = prefix(10B) || keccak256(creator, salt)[:10]
+ *
+ * @param {string} creator - Creator address (0x-prefixed hex)
+ * @param {string} salt - Salt as 0x-prefixed hex (32 bytes) or B256
+ * @returns {{address: string, index: bigint}} Computed address and lower 8 bytes as index
+ */
+export function computeFeeTokenAddress(creator, salt) {
+  // Clean addresses
+  const creatorClean = creator.startsWith('0x') ? creator.slice(2) : creator;
+  const saltClean = salt.startsWith('0x') ? salt.slice(2) : salt;
+
+  // RLP encode (creator, salt) - same as Rust implementation
+  const creatorBuf = Buffer.from(creatorClean, 'hex');
+  const saltBuf = Buffer.from(saltClean, 'hex');
+  const rlpEncoded = RLP.encode([creatorBuf, saltBuf]);
+
+  // Keccak256 hash
+  const hash = sha3.keccak_256(rlpEncoded);
+  const hashBytes = Buffer.from(hash, 'hex');
+
+  // Build address: prefix(10B) + hash[:10](10B)
+  const addressBytes = Buffer.alloc(20);
+  for (let i = 0; i < 10; i++) {
+    addressBytes[i] = FEE_TOKEN_PREFIX_BYTES[i];
+  }
+  for (let i = 0; i < 10; i++) {
+    addressBytes[10 + i] = hashBytes[i];
+  }
+
+  // Compute index from lower 8 bytes
+  const lower8 = hashBytes.slice(0, 8);
+  const index = BigInt('0x' + lower8.toString('hex'));
+
+  return {
+    address: '0x' + addressBytes.toString('hex'),
+    index,
+  };
+}
+
+/**
+ * Check if address is in reserved range (index < 256)
+ * @param {string} address - Address to check
+ * @param {string} creator - Creator address used for computation
+ * @param {string} salt - Salt used for computation
+ * @returns {boolean} True if reserved
+ */
+export function isReservedAddress(address, creator, salt) {
+  const { index } = computeFeeTokenAddress(creator, salt);
+  return index < 256n;
+}