@altiuslabs/tx-sdk 0.1.21 → 0.1.22

package/package.json

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

package/src/transaction.js

@@ -23,7 +23,7 @@ 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';
@@ -227,9 +227,14 @@ export class TxBuilder {
     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),
@@ -244,14 +249,15 @@ export class TxBuilder {
       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,
+      // 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);

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 };