chore: add signer for signed txs

Author: Faizan Dastgir

src/api/routes/rosetta/construction.ts

@@ -1,41 +1,40 @@
-import * as express from 'express';
 import { addAsync, RouterWithAsync } from '@awaitjs/express';
-import { DataStore, DbBlock } from '../../../datastore/common';
 import {
-  RosettaPublicKey,
-  RosettaConstructionDeriveResponse,
   NetworkIdentifier,
-  RosettaOperation,
-  RosettaMaxFeeAmount,
-  RosettaConstructionPreprocessResponse,
-  RosettaOptions,
-  RosettaConstructionMetadataResponse,
+  RosettaConstructionDeriveResponse,
   RosettaConstructionHashRequest,
   RosettaConstructionHashResponse,
+  RosettaConstructionMetadataResponse,
+  RosettaConstructionPreprocessResponse,
+  RosettaMaxFeeAmount,
+  RosettaOperation,
+  RosettaOptions,
+  RosettaPublicKey,
 } from '@blockstack/stacks-blockchain-api-types';
-import { deserializeTransaction } from '@blockstack/stacks-transactions/lib/transaction';
-import { BufferReader } from '@blockstack/stacks-transactions/lib/bufferReader';
-import { AddressHashMode } from '@blockstack/stacks-transactions';
 import {
-  isSingleSig,
   emptyMessageSignature,
+  isSingleSig,
 } from '@blockstack/stacks-transactions/lib/authorization';
-
-import { rosettaValidateRequest, ValidSchema, makeRosettaError } from './../../rosetta-validate';
+import { BufferReader } from '@blockstack/stacks-transactions/lib/bufferReader';
+import { deserializeTransaction } from '@blockstack/stacks-transactions/lib/transaction';
+import * as express from 'express';
+import { StacksCoreRpcClient } from '../../../core-rpc/client';
+import { DataStore, DbBlock } from '../../../datastore/common';
+import { FoundOrNot, hexToBuffer, isValidC32Address } from '../../../helpers';
+import { RosettaConstants, RosettaErrors } from '../../rosetta-constants';
 import {
-  publicKeyToBitcoinAddress,
   bitcoinAddressToSTXAddress,
+  getOperations,
   getOptionsFromOperations,
-  isSymbolSupported,
+  getSingers,
   isDecimalsSupported,
+  isSignedTransaction,
+  isSymbolSupported,
+  publicKeyToBitcoinAddress,
   rawTxToBaseTx,
-  getOperations,
   rawTxToStacksTransaction,
-  isSignedTransaction,
 } from './../../../rosetta-helpers';
-import { isValidC32Address, FoundOrNot, hexToBuffer } from '../../../helpers';
-import { StacksCoreRpcClient } from '../../../core-rpc/client';
-import { RosettaErrors, RosettaConstants } from '../../rosetta-constants';
+import { makeRosettaError, rosettaValidateRequest, ValidSchema } from './../../rosetta-validate';
 
 export function createRosettaConstructionRouter(db: DataStore): RouterWithAsync {
   const router = addAsync(express.Router());
@@ -249,7 +248,6 @@ export function createRosettaConstructionRouter(db: DataStore): RouterWithAsync
       res.status(400).json(makeRosettaError(valid));
       return;
     }
-
     const inputTx = req.body.transaction;
     const singed = req.body.signed;
     const transaction = rawTxToStacksTransaction(inputTx);
@@ -259,9 +257,16 @@ export function createRosettaConstructionRouter(db: DataStore): RouterWithAsync
       return;
     }
     const operations = getOperations(rawTxToBaseTx(inputTx));
-    res.json({
-      operations: operations,
-    });
+    if (singed) {
+      res.json({
+        operations: operations,
+        account_identifier_signers: getSingers(transaction),
+      });
+    } else {
+      res.json({
+        operations: operations,
+      });
+    }
   });
 
   return router;

src/rosetta-helpers.ts

@@ -1,27 +1,37 @@
-import { BaseTx, DbTxStatus, DbTxTypeId } from './datastore/common';
-import { getTxTypeString, getTxStatusString } from './api/controllers/db-controller';
 import {
-  assertNotNullish as unwrapOptional,
-  bufferToHexPrefixString,
-  hexToBuffer,
-} from './helpers';
-import { RosettaOperation, RosettaOptions } from '@blockstack/stacks-blockchain-api-types';
+  RosettaAccountIdentifier,
+  RosettaOperation,
+  RosettaOptions,
+} from '@blockstack/stacks-blockchain-api-types';
+import {
+  addressToString,
+  AuthType,
+  ContractCallPayload,
+  PayloadType,
+  TokenTransferPayload,
+} from '@blockstack/stacks-transactions';
+import {
+  emptyMessageSignature,
+  isSingleSig,
+} from '@blockstack/stacks-transactions/lib/authorization';
+import { BufferReader } from '@blockstack/stacks-transactions/lib/bufferReader';
 import {
-  StacksTransaction,
   deserializeTransaction,
+  StacksTransaction,
 } from '@blockstack/stacks-transactions/lib/transaction';
-import { BufferReader } from '@blockstack/stacks-transactions/lib/bufferReader';
+import { txidFromData } from '@blockstack/stacks-transactions/lib/utils';
 import * as btc from 'bitcoinjs-lib';
 import * as c32check from 'c32check';
-import { RosettaNetworks, RosettaConstants } from './api/rosetta-constants';
-import { readTransaction, TransactionPayloadTypeID } from './p2p/tx';
-import { txidFromData } from '@blockstack/stacks-transactions/lib/utils';
+import { getTxStatusString, getTxTypeString } from './api/controllers/db-controller';
+import { RosettaConstants, RosettaNetworks } from './api/rosetta-constants';
+import { BaseTx, DbTxStatus, DbTxTypeId } from './datastore/common';
 import { getTxSenderAddress, getTxSponsorAddress } from './event-stream/reader';
 import {
-  isSingleSig,
-  emptyMessageSignature,
-} from '@blockstack/stacks-transactions/lib/authorization';
-import { addressToString } from '@blockstack/stacks-transactions/lib/types';
+  assertNotNullish as unwrapOptional,
+  bufferToHexPrefixString,
+  hexToBuffer,
+} from './helpers';
+import { readTransaction, TransactionPayloadTypeID } from './p2p/tx';
 
 enum CoinAction {
   CoinSpent = 'coin_spent',
@@ -348,3 +358,51 @@ export function rawTxToBaseTx(raw_tx: string): BaseTx {
 
   return dbtx;
 }
+
+export function getSingers(transaction: StacksTransaction): RosettaAccountIdentifier[] | undefined {
+  let address;
+  if (transaction.payload.payloadType == PayloadType.TokenTransfer) {
+    address = transaction.payload.recipient.address;
+  } else if (transaction.payload.payloadType == PayloadType.ContractCall) {
+    address = transaction.payload.contractAddress;
+  } else {
+    return;
+  }
+  const { type, version } = address;
+
+  const account_identifier_signers: RosettaAccountIdentifier[] = [];
+  if (transaction.auth.authType == AuthType.Standard) {
+    if (transaction.auth.spendingCondition) {
+      const singer = {
+        address: addressToString({
+          version: version,
+          hash160: transaction.auth.spendingCondition.signer,
+          type: type,
+        }),
+      };
+      account_identifier_signers.push(singer);
+    }
+  } else if (transaction.auth.authType == AuthType.Sponsored) {
+    if (transaction.auth.spendingCondition) {
+      const singer = {
+        address: addressToString({
+          version: version,
+          hash160: transaction.auth.spendingCondition.signer,
+          type: type,
+        }),
+      };
+      account_identifier_signers.push(singer);
+    }
+    if (transaction.auth.sponsorSpendingCondition) {
+      const sponsored = {
+        address: addressToString({
+          version: version,
+          hash160: transaction.auth.sponsorSpendingCondition.signer,
+          type: type,
+        }),
+      };
+      account_identifier_signers.push(sponsored);
+    }
+  }
+  return account_identifier_signers;
+}