feat: include Stacks 2.1 stx-transfer-memo in Rosetta token transfer operations (#1290)

* chore: cleanup Rosetta operation type strings

* feat: include `memo` from stx-transfer-memo events in Rosetta token transfer operations

* chore: lint fix

* chore: Rosetta tests for memo in stx-transfer-memo events

* fix: Rosetta memo strings should be decoded from hex

* chore: add `coinbase-pay-to-alt` tx type test for Rosetta parsing

Author: zone117x

src/api/controllers/db-controller.ts

@@ -517,7 +517,7 @@ async function parseRosettaTxDetail(opts: {
     events,
     opts.unlockingEvents
   );
-  const txMemo = parseTransactionMemo(opts.tx);
+  const txMemo = parseTransactionMemo(opts.tx.token_transfer_memo);
   const rosettaTx: RosettaTransaction = {
     transaction_identifier: { hash: opts.tx.tx_id },
     operations: operations,

src/api/rosetta-constants.ts

@@ -46,22 +46,29 @@ export enum RosettaOperationType {
   RevokeDelegateStx = 'revoke_delegate_stx',
 }
 
-export const RosettaOperationTypes = [
-  RosettaOperationType.TokenTransfer,
-  RosettaOperationType.ContractCall,
-  RosettaOperationType.SmartContract,
-  RosettaOperationType.Coinbase,
-  RosettaOperationType.PoisonMicroblock,
-  RosettaOperationType.Fee,
-  RosettaOperationType.Mint,
-  RosettaOperationType.Burn,
-  RosettaOperationType.MinerReward,
-  RosettaOperationType.StxLock, // stx event
-  RosettaOperationType.StxUnlock, // forged event
-  RosettaOperationType.StackStx, // PoX contract function
-  RosettaOperationType.DelegateStx, // PoX contract function
-  RosettaOperationType.RevokeDelegateStx, // PoX contract function
-];
+type RosettaOperationTypeUnion = `${RosettaOperationType}`;
+
+// Function that leverages typescript to ensure a given array contains all values from a type union
+const arrayOfAllOpTypes = <T extends RosettaOperationTypeUnion[]>(
+  array: T & ([RosettaOperationTypeUnion] extends [T[number]] ? unknown : 'Invalid')
+) => array;
+
+export const RosettaOperationTypes = arrayOfAllOpTypes([
+  'token_transfer',
+  'contract_call',
+  'smart_contract',
+  'coinbase',
+  'poison_microblock',
+  'fee',
+  'mint',
+  'burn',
+  'miner_reward',
+  'stx_lock',
+  'stx_unlock',
+  'stack_stx',
+  'delegate_stx',
+  'revoke_delegate_stx',
+]) as RosettaOperationType[];
 
 export const RosettaOperationStatuses = [
   {

src/api/routes/rosetta/construction.ts

@@ -185,7 +185,7 @@ export function createRosettaConstructionRouter(db: PgStore, chainId: ChainID):
       }
 
       let transaction: StacksTransaction;
-      switch (options.type) {
+      switch (options.type as RosettaOperationType) {
         case RosettaOperationType.TokenTransfer:
           // dummy transaction to calculate size
           const dummyTokenTransferTx: UnsignedTokenTransferOptions = {
@@ -328,7 +328,7 @@ export function createRosettaConstructionRouter(db: PgStore, chainId: ChainID):
       }
 
       const request: RosettaConstructionMetadataRequest = req.body;
-      const options: RosettaOptions = req.body.options;
+      const options: RosettaOptions = request.options;
 
       if (options?.sender_address && !isValidC32Address(options.sender_address)) {
         res.status(400).json(RosettaErrors[RosettaErrorsTypes.invalidSender]);
@@ -345,7 +345,7 @@ export function createRosettaConstructionRouter(db: PgStore, chainId: ChainID):
       }
 
       let response = {} as RosettaConstructionMetadataResponse;
-      switch (options.type) {
+      switch (options.type as RosettaOperationType) {
         case RosettaOperationType.TokenTransfer:
           const recipientAddress = options.token_transfer_recipient_address;
           if (options?.decimals !== RosettaConstants.decimals) {
@@ -515,7 +515,7 @@ export function createRosettaConstructionRouter(db: PgStore, chainId: ChainID):
       try {
         const baseTx = rawTxToBaseTx(inputTx);
         const operations = await getOperations(baseTx, db);
-        const txMemo = parseTransactionMemo(baseTx);
+        const txMemo = parseTransactionMemo(baseTx.token_transfer_memo);
         let response: RosettaConstructionParseResponse;
         if (signed) {
           response = {
@@ -642,7 +642,7 @@ export function createRosettaConstructionRouter(db: PgStore, chainId: ChainID):
       }
 
       let transaction: StacksTransaction;
-      switch (options.type) {
+      switch (options.type as RosettaOperationType) {
         case RosettaOperationType.TokenTransfer: {
           const recipientAddress = options.token_transfer_recipient_address;
           if (!recipientAddress) {

src/api/routes/rosetta/mempool.ts

@@ -70,7 +70,7 @@ export function createRosettaMempoolRouter(db: PgStore, chainId: ChainID): expre
       }
 
       const operations = await getOperations(mempoolTxQuery.result, db);
-      const txMemo = parseTransactionMemo(mempoolTxQuery.result);
+      const txMemo = parseTransactionMemo(mempoolTxQuery.result.token_transfer_memo);
       const transaction: RosettaTransaction = {
         transaction_identifier: { hash: tx_id },
         operations: operations,

src/rosetta-helpers.ts

@@ -103,11 +103,19 @@ type RosettaRevokeDelegateContractArgs = {
   result: string;
 };
 
-export function parseTransactionMemo(tx: BaseTx): string | null {
-  if (tx.token_transfer_memo && tx.token_transfer_memo != '') {
+export function parseTransactionMemo(memoHex: string | undefined): string | null {
+  if (memoHex) {
     // Memos are a fixed-length 34 byte array. Any memo representing a string that is
     // less than 34 bytes long will have right-side padded null-bytes.
-    return tx.token_transfer_memo.replace(/\0.*$/g, '');
+    let memoBuffer = hexToBuffer(memoHex);
+    while (memoBuffer.length > 0 && memoBuffer[memoBuffer.length - 1] === 0) {
+      memoBuffer = memoBuffer.slice(0, memoBuffer.length - 1);
+    }
+    if (memoBuffer.length === 0) {
+      return null;
+    }
+    const memoDecoded = memoBuffer.toString('utf8');
+    return memoDecoded;
   }
   return null;
 }
@@ -120,22 +128,22 @@ export async function getOperations(
   stxUnlockEvents?: StxUnlockEvent[]
 ): Promise<RosettaOperation[]> {
   const operations: RosettaOperation[] = [];
-  const txType = getTxTypeString(tx.type_id);
+  const txType = getTxTypeString(tx.type_id) as RosettaOperationType;
   switch (txType) {
-    case 'token_transfer':
+    case RosettaOperationType.TokenTransfer:
       operations.push(makeFeeOperation(tx));
-      operations.push(makeSenderOperation(tx, operations.length));
-      operations.push(makeReceiverOperation(tx, operations.length));
+      operations.push(makeSenderOperation(tx, operations.length, tx.token_transfer_memo));
+      operations.push(makeReceiverOperation(tx, operations.length, tx.token_transfer_memo));
       break;
-    case 'contract_call':
+    case RosettaOperationType.ContractCall:
       operations.push(makeFeeOperation(tx));
       operations.push(await makeCallContractOperation(tx, db, operations.length));
       break;
-    case 'smart_contract':
+    case RosettaOperationType.SmartContract:
       operations.push(makeFeeOperation(tx));
       operations.push(makeDeployContractOperation(tx, operations.length));
       break;
-    case 'coinbase':
+    case RosettaOperationType.Coinbase:
       operations.push(makeCoinbaseOperation(tx, 0));
       if (minerRewards !== undefined) {
         getMinerOperations(minerRewards, operations);
@@ -144,7 +152,7 @@ export async function getOperations(
         processUnlockingEvents(stxUnlockEvents, operations);
       }
       break;
-    case 'poison_microblock':
+    case RosettaOperationType.PoisonMicroblock:
       operations.push(makePoisonMicroblockOperation(tx, 0));
       break;
     default:
@@ -196,8 +204,8 @@ async function processEvents(
               stxAssetEvent.amount,
               () => 'Unexpected nullish amount'
             );
-            operations.push(makeSenderOperation(tx, operations.length));
-            operations.push(makeReceiverOperation(tx, operations.length));
+            operations.push(makeSenderOperation(tx, operations.length, stxAssetEvent.memo));
+            operations.push(makeReceiverOperation(tx, operations.length, stxAssetEvent.memo));
             break;
           case DbAssetEventTypeId.Burn:
             operations.push(makeBurnOperation(stxAssetEvent, baseTx, operations.length));
@@ -254,7 +262,7 @@ function makeStakeLockOperation(
   stake_metadata.unlock_height = tx.unlock_height.toString();
   const lock: RosettaOperation = {
     operation_identifier: { index: index },
-    type: getEventTypeString(tx.event_type),
+    type: RosettaOperationType.StxLock,
     status: getTxStatus(baseTx.status),
     account: {
       address: unwrapOptional(tx.locked_address, () => 'Unexpected nullish locked_address'),
@@ -337,7 +345,7 @@ function makeFeeOperation(tx: BaseTx): RosettaOperation {
 function makeBurnOperation(tx: DbStxEvent, baseTx: BaseTx, index: number): RosettaOperation {
   const burn: RosettaOperation = {
     operation_identifier: { index: index },
-    type: getAssetEventTypeString(tx.asset_event_type_id),
+    type: RosettaOperationType.Burn,
     status: getTxStatus(baseTx.status),
     account: {
       address: unwrapOptional(baseTx.sender_address, () => 'Unexpected nullish sender_address'),
@@ -359,7 +367,7 @@ function makeFtBurnOperation(
 ): RosettaOperation {
   const burn: RosettaOperation = {
     operation_identifier: { index: index },
-    type: getAssetEventTypeString(ftEvent.asset_event_type_id),
+    type: RosettaOperationType.Burn,
     status: getTxStatus(baseTx.status),
     account: {
       address: unwrapOptional(ftEvent.sender, () => 'Unexpected nullish sender_address'),
@@ -379,7 +387,7 @@ function makeFtBurnOperation(
 function makeMintOperation(tx: DbStxEvent, baseTx: BaseTx, index: number): RosettaOperation {
   const mint: RosettaOperation = {
     operation_identifier: { index: index },
-    type: getAssetEventTypeString(tx.asset_event_type_id),
+    type: RosettaOperationType.Mint,
     status: getTxStatus(baseTx.status),
     account: {
       address: unwrapOptional(tx.recipient, () => 'Unexpected nullish sender_address'),
@@ -403,7 +411,7 @@ function makeFtMintOperation(
 ): RosettaOperation {
   const mint: RosettaOperation = {
     operation_identifier: { index: index },
-    type: getAssetEventTypeString(ftEvent.asset_event_type_id),
+    type: RosettaOperationType.Mint,
     status: getTxStatus(baseTx.status),
     account: {
       address: unwrapOptional(ftEvent.recipient, () => 'Unexpected nullish sender_address'),
@@ -423,10 +431,14 @@ function makeFtMintOperation(
   return mint;
 }
 
-function makeSenderOperation(tx: BaseTx, index: number): RosettaOperation {
+function makeSenderOperation(
+  tx: BaseTx,
+  index: number,
+  memo: string | undefined
+): RosettaOperation {
   const sender: RosettaOperation = {
     operation_identifier: { index: index },
-    type: 'token_transfer', //Sender operation should always be token_transfer,
+    type: RosettaOperationType.TokenTransfer, //Sender operation should always be token_transfer,
     status: getTxStatus(tx.status),
     account: {
       address: unwrapOptional(tx.sender_address, () => 'Unexpected nullish sender_address'),
@@ -444,6 +456,13 @@ function makeSenderOperation(tx: BaseTx, index: number): RosettaOperation {
     },
   };
 
+  if (memo) {
+    sender.metadata = {
+      ...sender.metadata,
+      memo: parseTransactionMemo(memo),
+    };
+  }
+
   return sender;
 }
 
@@ -455,7 +474,7 @@ function makeFtSenderOperation(
 ): RosettaOperation {
   const sender: RosettaOperation = {
     operation_identifier: { index: index },
-    type: 'token_transfer',
+    type: RosettaOperationType.TokenTransfer,
     status: getTxStatus(tx.status),
     account: {
       address: unwrapOptional(ftEvent.sender, () => 'Unexpected nullish sender_address'),
@@ -478,11 +497,15 @@ function makeFtSenderOperation(
   return sender;
 }
 
-function makeReceiverOperation(tx: BaseTx, index: number): RosettaOperation {
+function makeReceiverOperation(
+  tx: BaseTx,
+  index: number,
+  memo: string | undefined
+): RosettaOperation {
   const receiver: RosettaOperation = {
     operation_identifier: { index: index },
     related_operations: [{ index: index - 1 }],
-    type: 'token_transfer', //Receiver operation should always be token_transfer
+    type: RosettaOperationType.TokenTransfer, //Receiver operation should always be token_transfer
     status: getTxStatus(tx.status),
     account: {
       address: unwrapOptional(
@@ -503,6 +526,13 @@ function makeReceiverOperation(tx: BaseTx, index: number): RosettaOperation {
     },
   };
 
+  if (memo) {
+    receiver.metadata = {
+      ...receiver.metadata,
+      memo: parseTransactionMemo(memo),
+    };
+  }
+
   return receiver;
 }
 
@@ -515,7 +545,7 @@ function makeFtReceiverOperation(
   const receiver: RosettaOperation = {
     operation_identifier: { index: index },
     related_operations: [{ index: index - 1 }],
-    type: 'token_transfer',
+    type: RosettaOperationType.TokenTransfer,
     status: getTxStatus(tx.status),
     account: {
       address: unwrapOptional(
@@ -545,7 +575,7 @@ function makeFtReceiverOperation(
 function makeDeployContractOperation(tx: BaseTx, index: number): RosettaOperation {
   const deployer: RosettaOperation = {
     operation_identifier: { index: index },
-    type: getTxTypeString(tx.type_id),
+    type: RosettaOperationType.SmartContract,
     status: getTxStatus(tx.status),
     account: {
       address: unwrapOptional(tx.sender_address, () => 'Unexpected nullish sender_address'),
@@ -562,7 +592,7 @@ async function makeCallContractOperation(
 ): Promise<RosettaOperation> {
   const contractCallOp: RosettaOperation = {
     operation_identifier: { index: index },
-    type: getTxTypeString(tx.type_id),
+    type: RosettaOperationType.ContractCall,
     status: getTxStatus(tx.status),
     account: {
       address: unwrapOptional(tx.sender_address, () => 'Unexpected nullish sender_address'),
@@ -598,7 +628,7 @@ function makeCoinbaseOperation(tx: BaseTx, index: number): RosettaOperation {
   // TODO : Add more mappings in operations for coinbase
   const sender: RosettaOperation = {
     operation_identifier: { index: index },
-    type: getTxTypeString(tx.type_id),
+    type: RosettaOperationType.Coinbase,
     status: getTxStatus(tx.status),
     account: {
       address: unwrapOptional(tx.sender_address, () => 'Unexpected nullish sender_address'),
@@ -612,7 +642,7 @@ function makePoisonMicroblockOperation(tx: BaseTx, index: number): RosettaOperat
   // TODO : add more mappings in operations for poison-microblock
   const sender: RosettaOperation = {
     operation_identifier: { index: index },
-    type: getTxTypeString(tx.type_id),
+    type: RosettaOperationType.PoisonMicroblock,
     status: getTxStatus(tx.status),
     account: {
       address: unwrapOptional(tx.sender_address, () => 'Unexpected nullish sender_address'),
@@ -645,7 +675,7 @@ export function getOptionsFromOperations(operations: RosettaOperation[]): Rosett
   const options: RosettaOptions = {};
 
   for (const operation of operations) {
-    switch (operation.type) {
+    switch (operation.type as RosettaOperationType) {
       case RosettaOperationType.Fee:
         options.fee = operation.amount?.value;
         break;