@altiuslabs/tx-sdk 0.1.21 → 0.1.23

package/package.json

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

package/src/transaction.js

@@ -23,10 +23,10 @@ export class TxBuilder {
     this._data = '0x';
     this._max_priority_fee_per_gas = 0;
     this._max_fee_per_gas = 0;
-    this._max_fee_per_gas_usd_attodollars = 0;
+    this._max_fee_per_gas_usd_attodollars = 40000000000n; // $0.04/gas default
     this._fee_token = null;
-    this._fee_payer = '0x0000000000000000000000000000000000000000';
-    this._fee_payer_signature = '0x';
+    this._fee_payer = null;
+    this._fee_payer_signature = null;
   }
 
   /**
@@ -158,6 +158,9 @@ export class TxBuilder {
     if (this._nonce === null) throw new Error('nonce is required');
     if (!this._fee_token) throw new Error('fee_token is required');
 
+    // Default fee_payer to zero address (sender-pays)
+    const fee_payer = this._fee_payer || '0x0000000000000000000000000000000000000000';
+
     return {
       chain_id: this._chain_id,
       nonce: this._nonce,
@@ -169,7 +172,7 @@ export class TxBuilder {
       max_fee_per_gas: this._max_fee_per_gas,
       max_fee_per_gas_usd_attodollars: this._max_fee_per_gas_usd_attodollars,
       fee_token: this._fee_token,
-      fee_payer: this._fee_payer || '0x0000000000000000000000000000000000000000',
+      fee_payer,
       fee_payer_signature: this._fee_payer_signature,
     };
   }
@@ -220,16 +223,33 @@ export class TxBuilder {
 
     const tx = this.build();
 
-    // Use sender as fee_payer if not specified
-    const feePayer = tx.fee_payer || wallet.address;
+    // Use sender as fee_payer if not specified (null means use sender)
+    const feePayer = tx.fee_payer === '0x0000000000000000000000000000000000000000' || !tx.fee_payer
+      ? wallet.address
+      : tx.fee_payer;
+
+    // Auto-generate fee_payer_signature if not set and fee_payer equals sender
+    let feePayerSignature = tx.fee_payer_signature;
+    if (!feePayerSignature && feePayer.toLowerCase() === wallet.address.toLowerCase()) {
+      // Compute fee_payer signature hash using sender as the sender
+      const feePayerSigHash = fee_payer_signature_hash(tx, wallet.address);
+      const feePayerSig = await wallet.sign_hash(feePayerSigHash);
+      // Format: 0x + v (1 byte) + r (32 bytes) + s (32 bytes)
+      feePayerSignature = '0x' + feePayerSig.v.toString(16).padStart(2, '0') + feePayerSig.r.slice(2) + feePayerSig.s.slice(2);
+    }
 
     // Convert r, s to 32-byte buffers
     const rBuffer = Buffer.from(sig.r.slice(2), 'hex');
     const sBuffer = Buffer.from(sig.s.slice(2), 'hex');
 
+    // Note: y_parity is used directly as a number in signature_bytes below
+
     // Build signed transaction list (for EIP-2718 encoding)
     // Format matches node's rlp_encode_fields: [chainId, nonce, ..., feePayerSignature, signature]
     // IMPORTANT: Use Buffer for addresses and data to match Rust alloy-rlp encoding
+    //
+    // NOTE: For signature encoding, we use RLP encoding to match Rust alloy's behavior.
+    // The signature (y_parity, r, s) is added to the RLP list and encoded together.
     const signed_fields = [
       BigInt(tx.chain_id),
       BigInt(tx.nonce),
@@ -243,15 +263,16 @@ export class TxBuilder {
       Buffer.from(tx.fee_token.slice(2), 'hex'),  // fee_token as buffer
       Buffer.from(feePayer.slice(2), 'hex'),  // fee_payer as buffer
       BigInt(tx.max_fee_per_gas_usd_attodollars),
-      Buffer.from(tx.fee_payer_signature?.slice(2) || '', 'hex') || Buffer.alloc(0),
-      // Signature: y_parity (1 byte), r (32 bytes), s (32 bytes)
-      y_parity,
-      rBuffer,
-      sBuffer,
+      Buffer.from(feePayerSignature?.slice(2) || '', 'hex') || Buffer.alloc(0),
+      // Signature: y_parity, r, s - RLP encoded as part of the list
+      BigInt(y_parity),
+      Buffer.from(sig.r.slice(2), 'hex'),  // r as 32-byte buffer
+      Buffer.from(sig.s.slice(2), 'hex'),  // s as 32-byte buffer
     ];
 
     // EIP-2718: first byte is type (0x7a), then RLP encoded fields
     const rlp_fields_buf = RLP.encode(signed_fields);
+
     const raw_transaction = '0x7a' + rlp_fields_buf.toString('hex');
 
     const transaction_hash = keccak256(raw_transaction);
@@ -259,6 +280,7 @@ export class TxBuilder {
     return {
       ...tx,
       fee_payer: feePayer,
+      fee_payer_signature: feePayerSignature,
       v: y_parity,
       r: sig.r,
       s: sig.s,

package/src/wallet.js

@@ -23,9 +23,12 @@ export function generate_private_key() {
  */
 export function private_key_to_address(private_key) {
   const pk = private_key.slice(2);
-  const publicKey = secp256k1.getPublicKey(pk, true);
-  // Remove first byte (prefix) and take last 64 bytes (x, y)
-  const hash = keccak256(publicKey.slice(1));
+  // false = uncompressed key (65 bytes starting with 0x04)
+  const publicKey = secp256k1.getPublicKey(pk, false);
+  // Convert hex string to Buffer
+  const publicKeyBuffer = Buffer.from(publicKey, 'hex');
+  // Remove first byte (prefix 0x04 for uncompressed key) and hash
+  const hash = keccak256(publicKeyBuffer.slice(1));
   // Take last 20 bytes
   return '0x' + hash.slice(-40);
 }
@@ -56,7 +59,13 @@ function parse_der(der) {
   offset += 2;
 
   // Get r (may need padding for leading zeros)
-  const rHex = der.slice(offset, offset + rLen * 2);
+  // DER uses signed integers, so if MSB >= 0x80, a 0x00 prefix is added
+  // We need to strip that prefix if present, then pad to 32 bytes
+  let rHex = der.slice(offset, offset + rLen * 2);
+  if (rHex.startsWith('00') && rLen === 33) {
+    // Strip the leading 0x00 added by DER encoding
+    rHex = rHex.slice(2);
+  }
   const r = '0x' + rHex.padStart(64, '0');
   offset += rLen * 2;
 
@@ -68,8 +77,12 @@ function parse_der(der) {
   const sLen = parseInt(der.slice(offset, offset + 2), 16);
   offset += 2;
 
-  // Get s
-  const sHex = der.slice(offset, offset + sLen * 2);
+  // Get s (may need to strip leading 0x00 added by DER encoding)
+  let sHex = der.slice(offset, offset + sLen * 2);
+  if (sHex.startsWith('00') && sLen === 33) {
+    // Strip the leading 0x00 added by DER encoding
+    sHex = sHex.slice(2);
+  }
   const s = '0x' + sHex.padStart(64, '0');
 
   return { r, s };