Rename metadata to auxiliary data

src/errors/invalidDataReason.ts

@@ -96,8 +96,8 @@ export enum InvalidDataReason {
   WITHDRAWAL_INVALID_AMOUNT = "invalid withdrawal amount",
   WITHDRAWAL_INVALID_PATH = "invalid withdrawal path",
 
-  METADATA_UNKNOWN_TYPE = "unknown metadata type",
-  METADATA_INVALID_HASH = "invalid metadata hash",
+  AUXILIARY_DATA_UNKNOWN_TYPE = "unknown metadata type",
+  AUXILIARY_DATA_INVALID_HASH = "invalid auxiliary data hash",
 
   VALIDITY_INTERVAL_START_INVALID = "invalid validity interval start",
 

src/interactions/serialization/txInit.ts

@@ -35,7 +35,7 @@ export function serializeTxInit(tx: ParsedTransaction, signingMode: TransactionS
         uint8_to_buf(tx.network.networkId),
         uint32_to_buf(tx.network.protocolMagic),
         _serializeOptionFlag(tx.ttl != null),
-        _serializeOptionFlag(tx.metadata != null),
+        _serializeOptionFlag(tx.auxiliaryData != null),
         _serializeOptionFlag(tx.validityIntervalStart != null),
         _serializeSigningMode(signingMode),
         uint32_to_buf(tx.inputs.length as Uint32_t),

src/interactions/serialization/txOther.ts

@@ -35,11 +35,11 @@ export function serializeTxTtl(
     ]);
 }
 
-export function serializeTxMetadata(
-    metadataHashHex: HexString
+export function serializeTxAuxiliaryData(
+    auxiliaryDataHashHex: HexString
 ) {
     return Buffer.concat([
-        hex_to_buf(metadataHashHex)
+        hex_to_buf(auxiliaryDataHashHex)
     ])
 }
 

src/interactions/signTx.ts

@@ -1,7 +1,7 @@
-import type { ParsedCertificate, ParsedInput, ParsedMetadata, ParsedOutput, ParsedSigningRequest, ParsedTransaction, ParsedWithdrawal, Uint64_str, ValidBIP32Path, Version } from "../types/internal";
+import type { ParsedAuxiliaryData, ParsedCertificate, ParsedInput, ParsedOutput, ParsedSigningRequest, ParsedTransaction, ParsedWithdrawal, Uint64_str, ValidBIP32Path, Version } from "../types/internal";
 import { CertificateType, PoolOwnerType, TX_HASH_LENGTH } from "../types/internal";
 import type { SignedTransactionData } from '../types/public';
-import { TransactionMetadataType, TransactionSigningMode } from '../types/public';
+import { AuxiliaryDataType, TransactionSigningMode } from '../types/public';
 import { assert } from "../utils/assert";
 import { buf_to_hex, } from "../utils/serialize";
 import { INS } from "./common/ins";
@@ -10,7 +10,7 @@ import { ensureLedgerAppVersionCompatible } from "./getVersion";
 import { serializePoolInitialParams, serializePoolMetadata, serializePoolOwner, serializePoolRelay } from "./serialization/poolRegistrationCertificate";
 import { serializeTxCertificate } from "./serialization/txCertificate";
 import { serializeTxInit } from "./serialization/txInit";
-import { serializeTxFee, serializeTxInput, serializeTxMetadata, serializeTxTtl, serializeTxValidityStart, serializeTxWithdrawal, serializeTxWitnessRequest } from "./serialization/txOther";
+import { serializeTxAuxiliaryData, serializeTxFee, serializeTxInput, serializeTxTtl, serializeTxValidityStart, serializeTxWithdrawal, serializeTxWitnessRequest } from "./serialization/txOther";
 import { serializeAssetGroup, serializeToken, serializeTxOutputBasicParams } from "./serialization/txOutput";
 
 const enum P1 {
@@ -222,17 +222,17 @@ function* signTx_setTtl(
   });
 }
 
-function* signTx_setMetadata(
-  metadata: ParsedMetadata
+function* signTx_setAuxiliaryData(
+  auxiliaryData: ParsedAuxiliaryData
 ): Interaction<void> {
   const enum P2 {
     UNUSED = 0x00
   }
-  assert(metadata.type === TransactionMetadataType.ARBITRARY_HASH, 'Metadata type not implemented')
+  assert(auxiliaryData.type === AuxiliaryDataType.ARBITRARY_HASH, 'Metadata type not implemented')
   yield send({
     p1: P1.STAGE_METADATA,
     p2: P2.UNUSED,
-    data: serializeTxMetadata(metadata.metadataHashHex),
+    data: serializeTxAuxiliaryData(auxiliaryData.auxiliaryDataHashHex),
     expectedResponseLength: 0,
   });
 }
@@ -373,8 +373,8 @@ export function* signTransaction(version: Version, request: ParsedSigningRequest
   }
 
   // metadata
-  if (tx.metadata != null) {
-    yield* signTx_setMetadata(tx.metadata);
+  if (tx.auxiliaryData != null) {
+    yield* signTx_setAuxiliaryData(tx.auxiliaryData);
   }
 
   // validity start

src/parsing/transaction.ts

@@ -1,23 +1,23 @@
 import { InvalidData } from "../errors";
 import { InvalidDataReason } from "../errors/invalidDataReason";
-import type { OutputDestination, ParsedAssetGroup, ParsedCertificate, ParsedInput, ParsedMetadata, ParsedOutput, ParsedSigningRequest, ParsedToken, ParsedTransaction, ParsedWithdrawal } from "../types/internal";
+import type { OutputDestination, ParsedAssetGroup, ParsedAuxiliaryData, ParsedCertificate, ParsedInput, ParsedOutput, ParsedSigningRequest, ParsedToken, ParsedTransaction, ParsedWithdrawal } from "../types/internal";
 import { ASSET_NAME_LENGTH_MAX, CertificateType, TOKEN_POLICY_LENGTH, TX_HASH_LENGTH } from "../types/internal";
 import type {
     AssetGroup,
+    AuxiliaryData,
     Certificate,
     Network,
     SignTransactionRequest,
     Token,
     Transaction,
-    TransactionMetadata,
     TxInput,
     TxOutput,
     TxOutputDestination,
     Withdrawal
 } from "../types/public";
 import {
+    AuxiliaryDataType,
     PoolOwnerType,
-    TransactionMetadataType,
     TransactionSigningMode,
     TxOutputDestinationType
 } from "../types/public";
@@ -62,16 +62,16 @@ function parseAssetGroup(assetGroup: AssetGroup): ParsedAssetGroup {
     }
 }
 
-function parseTxMetadata(metadata: TransactionMetadata): ParsedMetadata {
-    switch (metadata.type) {
-        case TransactionMetadataType.ARBITRARY_HASH: {
+function parseAuxiliaryData(auxiliaryData: AuxiliaryData): ParsedAuxiliaryData {
+    switch (auxiliaryData.type) {
+        case AuxiliaryDataType.ARBITRARY_HASH: {
             return {
-                type: TransactionMetadataType.ARBITRARY_HASH,
-                metadataHashHex: parseHexStringOfLength(metadata.params.metadataHashHex, 32, InvalidDataReason.METADATA_INVALID_HASH)
+                type: AuxiliaryDataType.ARBITRARY_HASH,
+                auxiliaryDataHashHex: parseHexStringOfLength(auxiliaryData.params.auxiliaryDataHashHex, 32, InvalidDataReason.AUXILIARY_DATA_INVALID_HASH)
             }
         }
         default:
-            throw new InvalidData(InvalidDataReason.METADATA_UNKNOWN_TYPE)
+            throw new InvalidData(InvalidDataReason.AUXILIARY_DATA_UNKNOWN_TYPE)
     }
 }
 
@@ -101,10 +101,10 @@ export function parseTransaction(tx: Transaction): ParsedTransaction {
     validate(isArray(tx.withdrawals ?? []), InvalidDataReason.WITHDRAWALS_NOT_ARRAY);
     const withdrawals = (tx.withdrawals ?? []).map(w => parseWithdrawal(w))
 
-    // metadata
-    const metadata = tx.metadata == null
+    // auxiliary data
+    const auxiliaryData = tx.auxiliaryData == null
         ? null
-        : parseTxMetadata(tx.metadata)
+        : parseAuxiliaryData(tx.auxiliaryData)
 
     // validity start
     const validityIntervalStart = tx.validityIntervalStart == null
@@ -116,7 +116,7 @@ export function parseTransaction(tx: Transaction): ParsedTransaction {
         inputs,
         outputs,
         ttl,
-        metadata,
+        auxiliaryData,
         validityIntervalStart,
         withdrawals,
         certificates,

src/types/internal.ts

@@ -1,4 +1,4 @@
-import { AddressType, CertificateType, PoolOwnerType, RelayType, TransactionMetadataType, TransactionSigningMode, TxOutputDestinationType } from './public'
+import { AddressType, AuxiliaryDataType, CertificateType, PoolOwnerType, RelayType, TransactionSigningMode, TxOutputDestinationType } from './public'
 
 // Basic primitives
 export type VarlenAsciiString = string & { __type: 'ascii' }
@@ -15,7 +15,7 @@ export type Uint16_t = number & { __type: 'uint16_t' }
 export type Uint8_t = number & { __type: 'uint8_t' }
 
 // Reexport blockchain spec
-export { AddressType, CertificateType, RelayType, PoolOwnerType, TransactionMetadataType, TransactionSigningMode, TxOutputDestinationType }
+export { AddressType, CertificateType, RelayType, PoolOwnerType, AuxiliaryDataType, TransactionSigningMode, TxOutputDestinationType }
 export { Version, DeviceCompatibility } from './public'
 // Our types
 export const KEY_HASH_LENGTH = 28;
@@ -55,9 +55,9 @@ export type ParsedNetwork = {
     networkId: Uint8_t
 }
 
-export type ParsedMetadata = {
-    type: TransactionMetadataType.ARBITRARY_HASH
-    metadataHashHex: FixlenHexString<32>
+export type ParsedAuxiliaryData = {
+    type: AuxiliaryDataType.ARBITRARY_HASH
+    auxiliaryDataHashHex: FixlenHexString<32>
 }
 
 export type ParsedTransaction = {
@@ -68,7 +68,7 @@ export type ParsedTransaction = {
     ttl: Uint64_str | null
     certificates: ParsedCertificate[]
     withdrawals: ParsedWithdrawal[]
-    metadata: ParsedMetadata | null
+    auxiliaryData: ParsedAuxiliaryData | null
     validityIntervalStart: Uint64_str | null
 }
 

src/types/public.ts

@@ -691,36 +691,36 @@ export type SignedTransactionData = {
 };
 
 /**
- * Kind of transaction metatada supplied to Ledger
+ * Kind of transaction auxiliary data supplied to Ledger
  * @category Basic types
- * @see [[TransactionMetadata]]
+ * @see [[AuxiliaryData]]
  */
-export enum TransactionMetadataType {
-    /** Metadata is supplied as raw hash value */
+export enum AuxiliaryDataType {
+    /** Auxiliary data is supplied as raw hash value */
     ARBITRARY_HASH = 'arbitrary_hash',
 
     // CatalystVoting = 'catalyst_voting'
 }
 
 /**
- * Specifies transaction metadata.
- * Metadata can be supplied to Ledger in multiple forms.
+ * Specifies transaction auxiliary data.
+ * Auxiliary data can be supplied to Ledger possibly in multiple forms.
  * @category Basic types
- * @see [[TransactionMetadataType]]
+ * @see [[AuxiliaryDataType]]
  */
-export type TransactionMetadata =
+export type AuxiliaryData =
     {
-        type: TransactionMetadataType.ARBITRARY_HASH
-        params: MetadataArbitraryHashParams
+        type: AuxiliaryDataType.ARBITRARY_HASH
+        params: AuxiliaryDataArbitraryHashParams
     }
 
 /**
- * Metadata is supplied as raw hash. Ledger will just display this hash to the user
- * @see [[TransactionMetadata]]
+ * Auxiliary data is supplied as raw hash. Ledger will just display this hash to the user
+ * @see [[AuxiliaryData]]
  */
-export type MetadataArbitraryHashParams = {
+export type AuxiliaryDataArbitraryHashParams = {
     /** Hash of the transaction metadata */
-    metadataHashHex: string
+    auxiliaryDataHashHex: string
 }
 
 /**
@@ -762,9 +762,9 @@ export type Transaction = {
      */
     withdrawals?: Array<Withdrawal> | null,
     /**
-     * Transaction metadata (if any)
+     * Transaction auxiliary data (if any)
      */
-    metadata?: TransactionMetadata | null,
+    auxiliaryData?: AuxiliaryData | null,
     /**
      * Validity start (block height) if any.
      * Transaction becomes valid only starting from this block height.

test/integration/__fixtures__/signTx.ts

@@ -1,5 +1,5 @@
 import type { SignedTransactionData, Transaction, TxInput, TxOutput, TxOutputDestination } from "../../../src/Ada";
-import { AddressType, CertificateType, Networks, TransactionMetadataType, TxOutputDestinationType, utils } from "../../../src/Ada";
+import { AddressType, AuxiliaryDataType, CertificateType, Networks, TxOutputDestinationType, utils } from "../../../src/Ada";
 import { str_to_path } from "../../../src/utils/address";
 
 export const inputs: Record<
@@ -678,13 +678,13 @@ export const testsShelleyOther: TestcaseShelley[] = [
     },
   },
   {
-    testname: "Should correctly sign tx with nonempty metadata",
+    testname: "Should correctly sign tx with nonempty auxiliary data",
     tx: {
       ...shelleyBase,
-      metadata: {
-        type: TransactionMetadataType.ARBITRARY_HASH,
+      auxiliaryData: {
+        type: AuxiliaryDataType.ARBITRARY_HASH,
         params: {
-          metadataHashHex: "deadbeef".repeat(8)
+          auxiliaryDataHashHex: "deadbeef".repeat(8)
         }
       }
     },
@@ -710,10 +710,10 @@ export const testsShelleyOther: TestcaseShelley[] = [
       ...shelleyBase,
       inputs: [inputs.utxoNonReasonable],
       outputs: [outputs.internalBaseWithStakingPathNonReasonable],
-      metadata: {
-        type: TransactionMetadataType.ARBITRARY_HASH,
+      auxiliaryData: {
+        type: AuxiliaryDataType.ARBITRARY_HASH,
         params: {
-          metadataHashHex: "deadbeef".repeat(8)
+          auxiliaryDataHashHex: "deadbeef".repeat(8)
         },
       }
     },