algosdk 2.9.0 → 3.0.0-beta.1

package/src/mnemonic/mnemonic.ts

@@ -1,19 +1,19 @@
 /* eslint-disable no-bitwise */
-import english from './wordlists/english';
-import * as nacl from '../nacl/naclWrappers';
-import * as address from '../encoding/address';
-import Account from '../types/account';
+import english from './wordlists/english.js';
+import * as nacl from '../nacl/naclWrappers.js';
+import { Address } from '../encoding/address.js';
+import Account from '../types/account.js';
 
 export const FAIL_TO_DECODE_MNEMONIC_ERROR_MSG = 'failed to decode mnemonic';
 export const NOT_IN_WORDS_LIST_ERROR_MSG =
   'the mnemonic contains a word that is not in the wordlist';
 
 // https://stackoverflow.com/a/51452614
-function toUint11Array(buffer8: Uint8Array | number[]) {
-  const buffer11 = [];
+function toUint11Array(buffer8: Uint8Array | number[]): number[] {
+  const buffer11: number[] = [];
   let acc = 0;
   let accBits = 0;
-  function add(octet) {
+  function add(octet: number) {
     acc |= octet << accBits;
     accBits += 8;
     if (accBits >= 11) {
@@ -33,11 +33,11 @@ function toUint11Array(buffer8: Uint8Array | number[]) {
   return buffer11;
 }
 
-function applyWords(nums: number[]) {
+function applyWords(nums: number[]): string[] {
   return nums.map((n) => english[n]);
 }
 
-function computeChecksum(seed: Uint8Array) {
+function computeChecksum(seed: Uint8Array): string {
   const hashBuffer = nacl.genericHash(seed);
   const uint11Hash = toUint11Array(hashBuffer);
   const words = applyWords(uint11Hash);
@@ -66,11 +66,11 @@ export function mnemonicFromSeed(seed: Uint8Array) {
 
 // from Uint11Array
 // https://stackoverflow.com/a/51452614
-function toUint8Array(buffer11: number[]) {
-  const buffer8 = [];
+function toUint8Array(buffer11: number[]): Uint8Array {
+  const buffer8: number[] = [];
   let acc = 0;
   let accBits = 0;
-  function add(ui11) {
+  function add(ui11: number) {
     acc |= ui11 << accBits;
     accBits += 11;
     while (accBits >= 8) {
@@ -146,8 +146,8 @@ export function seedFromMnemonic(mnemonic: string) {
 export function mnemonicToSecretKey(mn: string): Account {
   const seed = seedFromMnemonic(mn);
   const keys = nacl.keyPairFromSeed(seed);
-  const encodedPk = address.encodeAddress(keys.publicKey);
-  return { addr: encodedPk, sk: keys.secretKey };
+  const addr = new Address(keys.publicKey);
+  return { addr, sk: keys.secretKey };
 }
 
 /**

package/src/multisig.ts

@@ -1,317 +1,119 @@
-import { Buffer } from 'buffer';
-import * as nacl from './nacl/naclWrappers';
-import * as address from './encoding/address';
-import * as encoding from './encoding/encoding';
-import * as txnBuilder from './transaction';
-import * as utils from './utils/utils';
-import AnyTransaction, { EncodedTransaction } from './types/transactions';
-import { MultisigMetadata } from './types/multisig';
+import * as nacl from './nacl/naclWrappers.js';
 import {
-  EncodedMultisig,
-  EncodedSignedTransaction,
-} from './types/transactions/encoded';
+  Address,
+  ALGORAND_ADDRESS_BYTE_LENGTH,
+  ALGORAND_CHECKSUM_BYTE_LENGTH,
+} from './encoding/address.js';
+import * as utils from './utils/utils.js';
+import { EncodedMultisig } from './types/transactions/encoded.js';
 
 /**
  Utilities for manipulating multisig transaction blobs.
  */
 
-export const MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG =
-  'Not enough multisig transactions to merge. Need at least two';
-export const MULTISIG_MERGE_MISMATCH_ERROR_MSG =
-  'Cannot merge txs. txIDs differ';
-export const MULTISIG_MERGE_MISMATCH_AUTH_ADDR_MSG =
-  'Cannot merge txs. Auth addrs differ';
-export const MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG =
-  'Cannot merge txs. Multisig preimages differ';
-export const MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG =
-  'Cannot merge txs. subsigs are mismatched.';
-const MULTISIG_KEY_NOT_EXIST_ERROR_MSG = 'Key does not exist';
-export const MULTISIG_NO_MUTATE_ERROR_MSG =
-  'Cannot mutate a multisig field as it would invalidate all existing signatures.';
-export const MULTISIG_USE_PARTIAL_SIGN_ERROR_MSG =
-  'Cannot sign a multisig transaction using `signTxn`. Use `partialSignTxn` instead.';
-export const MULTISIG_SIGNATURE_LENGTH_ERROR_MSG =
-  'Cannot add multisig signature. Signature is not of the correct length.';
+/**
+ * Required options for creating a multisignature
+ *
+ * Documentation available at: https://developer.algorand.org/docs/get-details/transactions/signatures/#multisignatures
+ */
+export interface MultisigMetadata {
+  /**
+   * Multisig version
+   */
+  version: number;
 
-interface MultisigOptions {
-  rawSig: Uint8Array;
-  myPk: Uint8Array;
-}
+  /**
+   * Multisig threshold value. Authorization requires a subset of signatures,
+   * equal to or greater than the threshold value.
+   */
+  threshold: number;
 
-interface MultisigMetadataWithPks extends Omit<MultisigMetadata, 'addrs'> {
-  pks: Uint8Array[];
+  /**
+   * A list of Algorand addresses representing possible signers for this multisig. Order is important.
+   */
+  addrs: Array<string | Address>;
 }
 
-/**
- * createMultisigTransaction creates a raw, unsigned multisig transaction blob.
- * @param txn - the actual transaction.
- * @param version - multisig version
- * @param threshold - multisig threshold
- * @param pks - ordered list of public keys in this multisig
- * @returns encoded multisig blob
- */
-export function createMultisigTransaction(
-  txn: txnBuilder.Transaction,
-  { version, threshold, addrs }: MultisigMetadata
-) {
-  // construct the appendable multisigned transaction format
-  const pks = addrs.map((addr) => address.decodeAddress(addr).publicKey);
-  const subsigs = pks.map((pk) => ({ pk: Buffer.from(pk) }));
+// Convert "MultisigAddr" UTF-8 to byte array
+const MULTISIG_PREIMG2ADDR_PREFIX = new Uint8Array([
+  77, 117, 108, 116, 105, 115, 105, 103, 65, 100, 100, 114,
+]);
 
-  const msig: EncodedMultisig = {
-    v: version,
-    thr: threshold,
-    subsig: subsigs,
-  };
-  const txnForEncoding = txn.get_obj_for_encoding();
-  const signedTxn: EncodedSignedTransaction = {
-    msig,
-    txn: txnForEncoding,
-  };
+const INVALID_MSIG_VERSION_ERROR_MSG = 'invalid multisig version';
+const INVALID_MSIG_THRESHOLD_ERROR_MSG = 'bad multisig threshold';
+const INVALID_MSIG_PK_ERROR_MSG = 'bad multisig public key - wrong length';
+const UNEXPECTED_PK_LEN_ERROR_MSG = 'nacl public key length is not 32 bytes';
 
-  // if the address of this multisig is different from the transaction sender,
-  // we need to add the auth-addr field
-  const msigAddr = address.fromMultisigPreImg({
-    version,
-    threshold,
-    pks,
+export function pksFromAddresses(addrs: Array<string | Address>): Uint8Array[] {
+  return addrs.map((addr) => {
+    if (typeof addr === 'string') {
+      return Address.fromString(addr).publicKey;
+    }
+    return addr.publicKey;
   });
-  if (
-    address.encodeAddress(txnForEncoding.snd) !==
-    address.encodeAddress(msigAddr)
-  ) {
-    signedTxn.sgnr = Buffer.from(msigAddr);
-  }
-
-  return new Uint8Array(encoding.encode(signedTxn));
 }
 
 /**
- * createMultisigTransactionWithSignature creates a multisig transaction blob with an included signature.
- * @param txn - the actual transaction to sign.
- * @param rawSig - a Buffer raw signature of that transaction
- * @param myPk - a public key that corresponds with rawSig
+ * fromMultisigPreImg takes multisig parameters and returns a 32 byte typed array public key,
+ * representing an address that identifies the "exact group, version, and public keys" that are required for signing.
+ * Hash("MultisigAddr" || version uint8 || threshold uint8 || PK1 || PK2 || ...)
+ * Encoding this output yields a human readable address.
  * @param version - multisig version
  * @param threshold - multisig threshold
- * @param pks - ordered list of public keys in this multisig
- * @returns encoded multisig blob
+ * @param pks - array of typed array public keys
  */
-function createMultisigTransactionWithSignature(
-  txn: txnBuilder.Transaction,
-  { rawSig, myPk }: MultisigOptions,
-  { version, threshold, pks }: MultisigMetadataWithPks
-) {
-  // Create an empty encoded multisig transaction
-  const encodedMsig = createMultisigTransaction(txn, {
-    version,
-    threshold,
-    addrs: pks.map((pk) => address.encodeAddress(pk)),
-  });
-  // note: this is not signed yet, but will be shortly
-  const signedTxn = encoding.decode(encodedMsig) as EncodedSignedTransaction;
-
-  let keyExist = false;
-  // append the multisig signature to the corresponding public key in the multisig blob
-  signedTxn.msig.subsig.forEach((subsig, i) => {
-    if (nacl.bytesEqual(subsig.pk, myPk)) {
-      keyExist = true;
-      signedTxn.msig.subsig[i].s = rawSig;
-    }
-  });
-  if (keyExist === false) {
-    throw new Error(MULTISIG_KEY_NOT_EXIST_ERROR_MSG);
+export function addressFromMultisigPreImg({
+  version,
+  threshold,
+  pks,
+}: Omit<MultisigMetadata, 'addrs'> & {
+  pks: Uint8Array[];
+}): Address {
+  if (version !== 1 || version > 255 || version < 0) {
+    // ^ a tad redundant, but in case in the future version != 1, still check for uint8
+    throw new Error(INVALID_MSIG_VERSION_ERROR_MSG);
   }
-
-  // if the address of this multisig is different from the transaction sender,
-  // we need to add the auth-addr field
-  const msigAddr = address.fromMultisigPreImg({
-    version,
-    threshold,
-    pks,
-  });
   if (
-    address.encodeAddress(signedTxn.txn.snd) !== address.encodeAddress(msigAddr)
+    threshold === 0 ||
+    pks.length === 0 ||
+    threshold > pks.length ||
+    threshold > 255
   ) {
-    signedTxn.sgnr = Buffer.from(msigAddr);
+    throw new Error(INVALID_MSIG_THRESHOLD_ERROR_MSG);
   }
-
-  return new Uint8Array(encoding.encode(signedTxn));
-}
-
-/**
- * MultisigTransaction is a Transaction that also supports creating partially-signed multisig transactions.
- */
-export class MultisigTransaction extends txnBuilder.Transaction {
-  /* eslint-disable class-methods-use-this,@typescript-eslint/no-unused-vars,no-dupe-class-members */
-  /**
-   * Override inherited method to throw an error, as mutating transactions are prohibited in this context
-   */
-  addLease() {
-    throw new Error(MULTISIG_NO_MUTATE_ERROR_MSG);
+  const pkLen = ALGORAND_ADDRESS_BYTE_LENGTH - ALGORAND_CHECKSUM_BYTE_LENGTH;
+  if (pkLen !== nacl.PUBLIC_KEY_LENGTH) {
+    throw new Error(UNEXPECTED_PK_LEN_ERROR_MSG);
   }
-
-  /**
-   * Override inherited method to throw an error, as mutating transactions are prohibited in this context
-   */
-  addRekey() {
-    throw new Error(MULTISIG_NO_MUTATE_ERROR_MSG);
-  }
-
-  /**
-   * Override inherited method to throw an error, as traditional signing is not allowed
-   */
-  signTxn(sk: Uint8Array): Uint8Array; // This overload ensures that the override has a compatible type definition with the parent method
-  signTxn(sk: any): any {
-    throw new Error(MULTISIG_USE_PARTIAL_SIGN_ERROR_MSG);
-  }
-  /* eslint-enable class-methods-use-this,@typescript-eslint/no-unused-vars,no-dupe-class-members */
-
-  /**
-   * partialSignTxn partially signs this transaction and returns a partially-signed multisig transaction,
-   * encoded with msgpack as a typed array.
-   * @param version - multisig version
-   * @param threshold - multisig threshold
-   * @param pks - multisig public key list, order is important.
-   * @param sk - an Algorand secret key to sign with.
-   * @returns an encoded, partially signed multisig transaction.
-   */
-  partialSignTxn(
-    { version, threshold, pks }: MultisigMetadataWithPks,
-    sk: Uint8Array
-  ) {
-    // get signature verifier
-    const myPk = nacl.keyPairFromSecretKey(sk).publicKey;
-    return createMultisigTransactionWithSignature(
-      this,
-      { rawSig: this.rawSignTxn(sk), myPk },
-      { version, threshold, pks }
-    );
-  }
-
-  /**
-   * partialSignWithMultisigSignature partially signs this transaction with an external raw multisig signature and returns
-   * a partially-signed multisig transaction, encoded with msgpack as a typed array.
-   * @param metadata - multisig metadata
-   * @param signerAddr - address of the signer
-   * @param signature - raw multisig signature
-   * @returns an encoded, partially signed multisig transaction.
-   */
-  partialSignWithMultisigSignature(
-    metadata: MultisigMetadataWithPks,
-    signerAddr: string,
-    signature: Uint8Array
-  ) {
-    if (!nacl.isValidSignatureLength(signature.length)) {
-      throw new Error(MULTISIG_SIGNATURE_LENGTH_ERROR_MSG);
+  const merged = new Uint8Array(
+    MULTISIG_PREIMG2ADDR_PREFIX.length + 2 + pkLen * pks.length
+  );
+  merged.set(MULTISIG_PREIMG2ADDR_PREFIX, 0);
+  merged.set([version], MULTISIG_PREIMG2ADDR_PREFIX.length);
+  merged.set([threshold], MULTISIG_PREIMG2ADDR_PREFIX.length + 1);
+  for (let i = 0; i < pks.length; i++) {
+    if (pks[i].length !== pkLen) {
+      throw new Error(INVALID_MSIG_PK_ERROR_MSG);
     }
-    return createMultisigTransactionWithSignature(
-      this,
-      {
-        rawSig: signature,
-        myPk: address.decodeAddress(signerAddr).publicKey,
-      },
-      metadata
-    );
-  }
-
-  // eslint-disable-next-line camelcase
-  static from_obj_for_encoding(
-    txnForEnc: EncodedTransaction
-  ): MultisigTransaction {
-    return super.from_obj_for_encoding(txnForEnc) as MultisigTransaction;
+    merged.set(pks[i], MULTISIG_PREIMG2ADDR_PREFIX.length + 2 + i * pkLen);
   }
+  return new Address(Uint8Array.from(nacl.genericHash(merged)));
 }
 
 /**
- * mergeMultisigTransactions takes a list of multisig transaction blobs, and merges them.
- * @param multisigTxnBlobs - a list of blobs representing encoded multisig txns
- * @returns typed array msg-pack encoded multisig txn
+ * fromMultisigPreImgAddrs takes multisig parameters and returns a human readable Algorand address.
+ * This is equivalent to fromMultisigPreImg, but interfaces with encoded addresses.
+ * @param version - multisig version
+ * @param threshold - multisig threshold
+ * @param addrs - array of encoded addresses
  */
-export function mergeMultisigTransactions(multisigTxnBlobs: Uint8Array[]) {
-  if (multisigTxnBlobs.length < 2) {
-    throw new Error(MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG);
-  }
-  const refSigTx = encoding.decode(
-    multisigTxnBlobs[0]
-  ) as EncodedSignedTransaction;
-  const refTxID = MultisigTransaction.from_obj_for_encoding(
-    refSigTx.txn
-  ).txID();
-  const refAuthAddr = refSigTx.sgnr
-    ? address.encodeAddress(refSigTx.sgnr)
-    : undefined;
-  const refPreImage = {
-    version: refSigTx.msig.v,
-    threshold: refSigTx.msig.thr,
-    pks: refSigTx.msig.subsig.map((subsig) => subsig.pk),
-  };
-  const refMsigAddr = address.encodeAddress(
-    address.fromMultisigPreImg(refPreImage)
-  );
-
-  const newSubsigs = refSigTx.msig.subsig.map((sig) => ({ ...sig }));
-  for (let i = 1; i < multisigTxnBlobs.length; i++) {
-    const unisig = encoding.decode(
-      multisigTxnBlobs[i]
-    ) as EncodedSignedTransaction;
-
-    const unisigAlgoTxn = MultisigTransaction.from_obj_for_encoding(unisig.txn);
-    if (unisigAlgoTxn.txID() !== refTxID) {
-      throw new Error(MULTISIG_MERGE_MISMATCH_ERROR_MSG);
-    }
-
-    const authAddr = unisig.sgnr
-      ? address.encodeAddress(unisig.sgnr)
-      : undefined;
-    if (refAuthAddr !== authAddr) {
-      throw new Error(MULTISIG_MERGE_MISMATCH_AUTH_ADDR_MSG);
-    }
-
-    // check multisig has same preimage as reference
-    if (unisig.msig.subsig.length !== refSigTx.msig.subsig.length) {
-      throw new Error(MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG);
-    }
-    const preimg: MultisigMetadataWithPks = {
-      version: unisig.msig.v,
-      threshold: unisig.msig.thr,
-      pks: unisig.msig.subsig.map((subsig) => subsig.pk),
-    };
-    const msgigAddr = address.encodeAddress(address.fromMultisigPreImg(preimg));
-    if (refMsigAddr !== msgigAddr) {
-      throw new Error(MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG);
-    }
-
-    // now, we can merge
-    unisig.msig.subsig.forEach((uniSubsig, index) => {
-      if (!uniSubsig.s) return;
-      const current = newSubsigs[index];
-      // we convert the Uint8Arrays uniSubsig.s and current.s to Buffers here because (as
-      // of Dec 2020) React overrides the buffer package with an older version that does
-      // not support Uint8Arrays in the comparison function. See this thread for more
-      // info: https://github.com/algorand/js-algorand-sdk/issues/252
-      if (
-        current.s &&
-        Buffer.compare(Buffer.from(uniSubsig.s), Buffer.from(current.s)) !== 0
-      ) {
-        // mismatch
-        throw new Error(MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG);
-      }
-      current.s = uniSubsig.s;
-    });
-  }
-  const msig: EncodedMultisig = {
-    v: refSigTx.msig.v,
-    thr: refSigTx.msig.thr,
-    subsig: newSubsigs,
-  };
-  const signedTxn: EncodedSignedTransaction = {
-    msig,
-    txn: refSigTx.txn,
-  };
-  if (typeof refAuthAddr !== 'undefined') {
-    signedTxn.sgnr = Buffer.from(address.decodeAddress(refAuthAddr).publicKey);
-  }
-  return new Uint8Array(encoding.encode(signedTxn));
+export function addressFromMultisigPreImgAddrs({
+  version,
+  threshold,
+  addrs,
+}: MultisigMetadata): Address {
+  const pks = pksFromAddresses(addrs);
+  return addressFromMultisigPreImg({ version, threshold, pks });
 }
 
 export function verifyMultisig(
@@ -330,7 +132,7 @@ export function verifyMultisig(
 
   let pk: Uint8Array;
   try {
-    pk = address.fromMultisigPreImg({ version, threshold, pks });
+    pk = addressFromMultisigPreImg({ version, threshold, pks }).publicKey;
   } catch (e) {
     return false;
   }
@@ -365,122 +167,6 @@ export function verifyMultisig(
   return true;
 }
 
-/**
- * signMultisigTransaction takes a raw transaction (see signTransaction), a multisig preimage, a secret key, and returns
- * a multisig transaction, which is a blob representing a transaction and multisignature account preimage. The returned
- * multisig txn can accumulate additional signatures through mergeMultisigTransactions or appendSignMultisigTransaction.
- * @param txn - object with either payment or key registration fields
- * @param version - multisig version
- * @param threshold - multisig threshold
- * @param addrs - a list of Algorand addresses representing possible signers for this multisig. Order is important.
- * @param sk - Algorand secret key. The corresponding pk should be in the pre image.
- * @returns object containing txID, and blob of partially signed multisig transaction (with multisig preimage information)
- * If the final calculated fee is lower than the protocol minimum fee, the fee will be increased to match the minimum.
- */
-export function signMultisigTransaction(
-  txn: txnBuilder.TransactionLike,
-  { version, threshold, addrs }: MultisigMetadata,
-  sk: Uint8Array
-) {
-  // check that the from field matches the mSigPreImage. If from field is not populated, fill it in.
-  const expectedFromRaw = address.fromMultisigPreImgAddrs({
-    version,
-    threshold,
-    addrs,
-  });
-  if (!Object.prototype.hasOwnProperty.call(txn, 'from')) {
-    // eslint-disable-next-line no-param-reassign
-    txn.from = expectedFromRaw;
-  }
-  // build pks for partialSign
-  const pks = addrs.map((addr) => address.decodeAddress(addr).publicKey);
-  // `txn` needs to be handled differently if it's a constructed `Transaction` vs a dict of constructor args
-  const txnAlreadyBuilt = txn instanceof txnBuilder.Transaction;
-  let algoTxn: MultisigTransaction;
-  let blob: Uint8Array;
-  if (txnAlreadyBuilt) {
-    algoTxn = (txn as unknown) as MultisigTransaction;
-    blob = MultisigTransaction.prototype.partialSignTxn.call(
-      algoTxn,
-      { version, threshold, pks },
-      sk
-    );
-  } else {
-    algoTxn = new MultisigTransaction(txn as AnyTransaction);
-    blob = algoTxn.partialSignTxn({ version, threshold, pks }, sk);
-  }
-  return {
-    txID: algoTxn.txID().toString(),
-    blob,
-  };
-}
-
-/**
- * appendSignMultisigTransaction takes a multisig transaction blob, and appends our signature to it.
- * While we could derive public key preimagery from the partially-signed multisig transaction,
- * we ask the caller to pass it back in, to ensure they know what they are signing.
- * @param multisigTxnBlob - an encoded multisig txn. Supports non-payment txn types.
- * @param version - multisig version
- * @param threshold - multisig threshold
- * @param addrs - a list of Algorand addresses representing possible signers for this multisig. Order is important.
- * @param sk - Algorand secret key
- * @returns object containing txID, and blob representing encoded multisig txn
- */
-export function appendSignMultisigTransaction(
-  multisigTxnBlob: Uint8Array,
-  { version, threshold, addrs }: MultisigMetadata,
-  sk: Uint8Array
-) {
-  const pks = addrs.map((addr) => address.decodeAddress(addr).publicKey);
-  // obtain underlying txn, sign it, and merge it
-  const multisigTxObj = encoding.decode(
-    multisigTxnBlob
-  ) as EncodedSignedTransaction;
-  const msigTxn = MultisigTransaction.from_obj_for_encoding(multisigTxObj.txn);
-  const partialSignedBlob = msigTxn.partialSignTxn(
-    { version, threshold, pks },
-    sk
-  );
-  return {
-    txID: msigTxn.txID().toString(),
-    blob: mergeMultisigTransactions([multisigTxnBlob, partialSignedBlob]),
-  };
-}
-
-/**
- * appendMultisigTransactionSignature takes a multisig transaction blob, and appends a given raw signature to it.
- * This makes it possible to compile a multisig signature using only raw signatures from external methods.
- * @param multisigTxnBlob - an encoded multisig txn. Supports non-payment txn types.
- * @param version - multisig version
- * @param threshold - multisig threshold
- * @param addrs - a list of Algorand addresses representing possible signers for this multisig. Order is important.
- * @param signerAddr - address of the signer
- * @param signature - raw multisig signature
- * @returns object containing txID, and blob representing encoded multisig txn
- */
-export function appendSignRawMultisigSignature(
-  multisigTxnBlob: Uint8Array,
-  { version, threshold, addrs }: MultisigMetadata,
-  signerAddr: string,
-  signature: Uint8Array
-) {
-  const pks = addrs.map((addr) => address.decodeAddress(addr).publicKey);
-  // obtain underlying txn, sign it, and merge it
-  const multisigTxObj = encoding.decode(
-    multisigTxnBlob
-  ) as EncodedSignedTransaction;
-  const msigTxn = MultisigTransaction.from_obj_for_encoding(multisigTxObj.txn);
-  const partialSignedBlob = msigTxn.partialSignWithMultisigSignature(
-    { version, threshold, pks },
-    signerAddr,
-    signature
-  );
-  return {
-    txID: msigTxn.txID().toString(),
-    blob: mergeMultisigTransactions([multisigTxnBlob, partialSignedBlob]),
-  };
-}
-
 /**
  * multisigAddress takes multisig metadata (preimage) and returns the corresponding human readable Algorand address.
  * @param version - multisig version
@@ -491,6 +177,6 @@ export function multisigAddress({
   version,
   threshold,
   addrs,
-}: MultisigMetadata) {
-  return address.fromMultisigPreImgAddrs({ version, threshold, addrs });
+}: MultisigMetadata): Address {
+  return addressFromMultisigPreImgAddrs({ version, threshold, addrs });
 }