ed updates complete for now, updated passing test suite, padded byte on sig for trx, built-in digest prep bytes depending on keytype

Author: joshglogau

package.json

@@ -1,7 +1,7 @@
 {
     "name": "@wireio/core",
     "description": "Library for working with Wire powered blockchains.",
-    "version": "0.1.8",
+    "version": "0.2.0",
     "homepage": "https://github.com/Wire-Network/sdk-core",
     "license": "FSL-1.1-Apache-2.0",
     "main": "lib/core.js",

src/api/client.ts

@@ -265,25 +265,22 @@ export class APIClient {
     async buildSignedTransaction(action: AnyAction | AnyAction[], opts?: TransactionExtraOptions): Promise<SignedTransaction> {
         if (!this.signer) throw new Error('No signer function provided in APIClient options');
 
-        const keyType = opts && opts.key_type ? opts.key_type : this.signer.keyType;
+        const keyType = this.signer.keyType;
         const actions = await this.anyToAction(action);
         const info = await this.v1.chain.get_info();
         const header = info.getTransactionHeader();
         const transaction = Transaction.from({
             ...header, actions,
-            context_free_actions: (opts && opts.context_free_actions) ? opts.context_free_actions : [],
-            transaction_extensions: [{ type: 1, data: [] }]
+            context_free_actions: (opts && opts.context_free_actions) ? opts.context_free_actions : []
         });
-        const msgDigest = transaction.signingDigest(info.chain_id);
-        let msgBytes: Uint8Array = msgDigest.array;
-
-        // Handle keytype specific digest preparation
-        switch (keyType) {
-            case KeyType.EM: // Prefix with 0x and arrayify
-                msgBytes = ethers.utils.arrayify('0x' + msgDigest.hexString);
-                break;
+
+        if (keyType === KeyType.ED) {
+            const pubKey = opts && opts.pub_key;
+            if (!pubKey) throw new Error('ED signature requires a pubKey to be passed in TransactionExtraOptions');
+            transaction.extPubKey(pubKey);
         }
 
+        const { msgBytes } = transaction.signingDigest(info.chain_id, keyType);
         const sigBytes = await this.signer.sign(msgBytes).catch(err => { throw new Error(err) });
         const signature = Signature.fromRaw(sigBytes, keyType);
         return SignedTransaction.from({ ...transaction, signatures: [signature] });

src/api/types.ts

@@ -1,7 +1,7 @@
 export * as v1 from './v1/types';
 export * as v2 from './v2/types';
 
-import { ActionType, KeyType, NameType } from '../chain';
+import { ActionType, KeyType, NameType, PublicKeyType } from '../chain';
 import { TableIndexType, TableIndexTypes } from './v1/types';
 export interface GetRowsOptions {
     contract: NameType;
@@ -26,5 +26,5 @@ export interface GetRowsOptions {
 export type TransactionExtraOptions = {
     wait_final?: boolean;
     context_free_actions?: ActionType[];
-    key_type? : KeyType
+    pub_key?: PublicKeyType
 };

src/chain/public-key.ts

@@ -101,6 +101,12 @@ export class PublicKey implements ABISerializableObject {
 
     /** Return key in modern Antelope/EOSIO format (`PUB_<type>_<base58data>`) */
     toString() {
+        // Ensure the key is compressed
+        if ((this.type === KeyType.K1 || this.type === KeyType.R1 || this.type === KeyType.EM) &&
+            this.data.array.length !== 33) {
+            throw new Error(`Expected 33-byte compressed key for ${this.type}, got ${this.data.array.length}`);
+        }
+
         return `PUB_${this.type}_${Base58.encodeRipemd160Check(this.data, this.type)}`;
     }
 

src/chain/signature.ts

@@ -27,16 +27,12 @@ export type SignatureParts = {
 export class Signature implements ABISerializableObject {
     static abiName = 'signature';
 
-    /** Type, e.g. `K1` or `ED` */
     type: KeyType;
-    /** Signature data. */
     data: Bytes;
 
     /** Create Signature object from representing types. */
     static from(value: SignatureType): Signature {
-        if (isInstanceOf(value, Signature)) {
-            return value;
-        }
+        if (isInstanceOf(value, Signature)) return value;
 
         if (typeof value === 'object' && 'r' in value && 's' in value) {
             // ED25519 is pure 64-byte r||s
@@ -79,16 +75,14 @@ export class Signature implements ABISerializableObject {
         }
 
         const type = KeyType.from(parts[1]);
-        // 65 for all wire-format curves (we now pad ED to 65 bytes)
-        const size =
-            (type === KeyType.K1 ||
-                type === KeyType.R1 ||
-                type === KeyType.EM ||
-                type === KeyType.ED)
+        // 65 for ECDSA, 64 for ED
+        const length =
+            type === KeyType.K1 || type === KeyType.R1 || type === KeyType.EM
                 ? 65
-                : undefined;
-
-        const data = Base58.decodeRipemd160Check(parts[2], size, type);
+                : type === KeyType.ED
+                    ? 64
+                    : undefined;
+        const data = Base58.decodeRipemd160Check(parts[2], length, type);
         return new Signature(type, data);
     }
 
@@ -107,8 +101,9 @@ export class Signature implements ABISerializableObject {
             return new Signature(KeyType.WA, data);
         }
 
-        const length = 65;
-        return new Signature(type, new Bytes(decoder.readArray(length)));
+        const length = (type === KeyType.ED) ? 64 : 65;
+        const bytes = decoder.readArray(length);
+        return new Signature(type, new Bytes(bytes));
     }
 
     /**
@@ -133,11 +128,7 @@ export class Signature implements ABISerializableObject {
         // ED25519: the raw is already [r‖s]
         if (type === KeyType.ED) {
             if (raw.length !== 64) throw new Error(`ED raw sig must be 64 bytes, got ${raw.length}`);
-            // ► pad to 65 bytes with a zero at the end:
-            const wire = new Uint8Array(65);
-            wire.set(raw, 0);
-            wire[64] = 0;
-            return new Signature(type, new Bytes(wire));
+            return new Signature(type, new Bytes(raw));
         }
 
         // ECDSA/EIP-191: raw should be 65 bytes [r‖s‖v]
@@ -177,35 +168,8 @@ export class Signature implements ABISerializableObject {
      *               - ED:       64 bytes `[r(32)‖s(32)]`
      */
     constructor(type: KeyType, data: Bytes | Uint8Array) {
-        let wire: Uint8Array;
-
-        if (type === KeyType.ED) {
-            const arr = data instanceof Bytes ? data.array : data;
-
-            if (arr.length === 64) {
-                // pad to 65 so toString() and from() agree
-                wire = new Uint8Array(65);
-                wire.set(arr, 0);
-                wire[64] = 0;
-            } else if (arr.length === 65) {
-                // already padded
-                wire = arr;
-            } else {
-                throw new Error(`ED signature must be 64 or 65 bytes, got ${arr.length}`);
-            }
-        } else {
-            // everything else: expect exactly 65 bytes already in wire-format
-            const arr = data instanceof Bytes ? data.array : data;
-            
-            if (arr.length !== 65) {
-                throw new Error(`Expected 65-byte wire format for ${type}, got ${arr.length}`);
-            }
-
-            wire = arr;
-        }
-
         this.type = type;
-        this.data = new Bytes(wire);
+        this.data = data instanceof Bytes ? data : new Bytes(data);
     }
 
     equals(other: SignatureType): boolean {
@@ -251,11 +215,9 @@ export class Signature implements ABISerializableObject {
         const rawMsg = Bytes.from(message).array;
 
         switch (this.type) {
-            case KeyType.ED: {
-                // ED25519: storage is [r||s||0], TweetNaCl needs exactly 64 bytes [r||s] - strip padded 0
-                const sig64 = this.data.array.subarray(0, 64);
-                return Crypto.verify(sig64, rawMsg, publicKey.data.array, this.type);
-            }
+            case KeyType.ED:
+                // ED25519: raw `[r‖s]`
+                return Crypto.verify(this.data.array, rawMsg, publicKey.data.array, this.type);
 
             case KeyType.EM: {
                 // 1) unwrap wire [vWire‖r‖s]
@@ -306,7 +268,9 @@ export class Signature implements ABISerializableObject {
                 break;
             }
 
-            case KeyType.K1 || KeyType.R1: {
+            case KeyType.K1:
+            // eslint-disable-next-line padding-line-between-statements, no-fallthrough
+            case KeyType.R1: {
                 // wire[0] = k1V + 31
                 const k1V = wire[0] - 31; // 0 or 1
                 raw = new Uint8Array(65);
@@ -343,4 +307,37 @@ export class Signature implements ABISerializableObject {
     toJSON(): string {
         return this.toString();
     }
+}
+
+/**
+ * Pads an ED25519 signature for transaction wire-format.
+ * @param sig - The presumed 64 byte r|s signature to pad.
+ * @returns The padded 65 byte signature used for wire transactions.
+ */
+export function padEdForTx(sig: Signature): Signature {
+    if (sig.type !== KeyType.ED) return sig;
+    const arr = sig.data.array;
+    if (arr.length === 65) return sig;
+    if (arr.length !== 64) throw new Error(`ED sig must be 64 or 65, got ${arr.length}`);
+    const padded = new Uint8Array(65);
+    padded.set(arr, 0);
+    padded[64] = 0;
+
+    return new Signature(KeyType.ED, new Bytes(padded));
+}
+
+/**
+ * Strips the ED25519 padding from a signature.
+ * @param sig - The signature to strip.
+ * @returns The stripped signature.
+ */
+export function stripEdPad(sig: Signature): Signature {
+    if (sig.type !== KeyType.ED) return sig;
+    const a = sig.data.array;
+
+    if (a.length === 65 && a[64] === 0) {
+        return new Signature(KeyType.ED, a.subarray(0, 64));
+    }
+
+    return sig;
 }

src/chain/transaction.ts

@@ -1,7 +1,7 @@
 import pako from 'pako';
 
 import {abiEncode} from '../serializer/encoder';
-import {Signature, SignatureType} from './signature';
+import {padEdForTx, Signature, SignatureType, stripEdPad} from './signature';
 import {abiDecode} from '../serializer/decoder';
 
 import {
@@ -13,8 +13,11 @@ import {
     BytesType,
     Checksum256,
     Checksum256Type,
+    KeyType,
     Name,
     NameType,
+    PublicKey,
+    PublicKeyType,
     Struct,
     TimePointSec,
     TimePointType,
@@ -27,13 +30,18 @@ import {
     VarUInt,
     VarUIntType,
 } from '../';
+import { ethers } from 'ethers';
 
 @Struct.type('transaction_extension')
 export class TransactionExtension extends Struct {
     @Struct.field('uint16') declare type: UInt16;
     @Struct.field('bytes') declare data: Bytes;
 }
 
+export enum TransactionExtensionType {
+    PubKey = 0x8000,
+    // Add other extension types here as needed
+}
 export interface TransactionHeaderFields {
     /** The time at which a transaction expires. */
     expiration: TimePointType;
@@ -96,6 +104,11 @@ export interface AnyTransaction extends TransactionHeaderFields {
 
 export type TransactionType = Transaction | TransactionFields;
 
+export interface SigningDigest {
+    msgDigest : Checksum256;
+    msgBytes : Uint8Array; // Optionally formatted based on key type
+}
+
 @Struct.type('transaction')
 export class Transaction extends TransactionHeader {
     /** The context free actions in the transaction. */
@@ -151,9 +164,35 @@ export class Transaction extends TransactionHeader {
         return Checksum256.hash(abiEncode({object: this}));
     }
 
-    signingDigest(chainId: Checksum256Type): Checksum256 {
+    /**
+     * Computes the signing digest and message bytes for this transaction.
+     *
+     * @param chainId - The chain ID to use for the signing digest.
+     * @param keyType - (Optional) The key type of the signer. If provided, the message bytes (`msgBytes`)
+     *   are formatted according to the expected format for the given key type.
+     *   - For `KeyType.EM`, the digest is prefixed with `0x` and arrayified.
+     *   - For `KeyType.ED`, the digest's hex string is encoded as UTF-8 bytes.
+     *   - If not provided, the default digest bytes are used.
+     * @returns An object containing the signing digest (`msgDigest`) and the formatted message bytes (`msgBytes`).
+     */
+    signingDigest(chainId: Checksum256Type, keyType?: KeyType): SigningDigest {
         const data = this.signingData(chainId);
-        return Checksum256.hash(data);
+        const msgDigest = Checksum256.hash(data);
+        const msgDigestHex = msgDigest.hexString.toLowerCase();
+        let msgBytes: Uint8Array = msgDigest.array;
+
+        // Prepare custom msgBytes based on key type
+        switch (keyType) {
+            case KeyType.EM: // Prefix with 0x and arrayify
+                msgBytes = ethers.utils.arrayify('0x' + msgDigestHex);
+                break;
+
+            case KeyType.ED: // Encode as UTF-8 bytes for Phantom signing
+                msgBytes = new TextEncoder().encode(msgDigestHex);
+                break;
+        }
+
+        return { msgDigest, msgBytes };
     }
 
     signingData(chainId: Checksum256Type): Bytes {
@@ -162,6 +201,24 @@ export class Transaction extends TransactionHeader {
         data = data.appending(new Uint8Array(32));
         return data;
     }
+
+    extPubKey(pubKeys: PublicKeyType | PublicKeyType[]) {
+        if (!Array.isArray(pubKeys)) pubKeys = [pubKeys];
+
+        for (const pkey of pubKeys) {
+            const pubKey = PublicKey.from(pkey);
+            const rawKey = pubKey.data.array;
+            const keyTypeTag = KeyType.indexFor(pubKey.type);
+            const tag = Uint8Array.from([keyTypeTag]);
+            
+            const ext = TransactionExtension.from({
+                type: TransactionExtensionType.PubKey,
+                data: Buffer.concat([tag, rawKey]),
+            });
+            
+            this.transaction_extensions.push(ext);
+        }
+    }
 }
 
 export interface SignedTransactionFields extends TransactionFields {
@@ -234,6 +291,9 @@ export class PackedTransaction extends Struct {
     }
 
     static fromSigned(signed: SignedTransaction, compression: CompressionType = 1) {
+        // Pad ED sigs to 65 bytes, return unmodified K1/R1/EM sigs
+        const wireSigs = signed.signatures.map(padEdForTx);
+
         // Encode data
         let packed_trx: Bytes = abiEncode({object: Transaction.from(signed)});
         let packed_context_free_data: Bytes = abiEncode({
@@ -256,7 +316,7 @@ export class PackedTransaction extends Struct {
 
         return this.from({
             compression,
-            signatures: signed.signatures,
+            signatures: wireSigs,
             packed_context_free_data,
             packed_trx,
         }) as PackedTransaction;
@@ -286,11 +346,11 @@ export class PackedTransaction extends Struct {
         // TODO: decode context free data
         return SignedTransaction.from({
             ...transaction,
-            signatures: this.signatures,
+            signatures: this.signatures.map(stripEdPad),
         });
     }
 }
-
+    
 @Struct.type('transaction_receipt')
 export class TransactionReceipt extends Struct {
     @Struct.field('string') declare status: string;